@living-architecture/riviere-cli 0.9.18 → 0.9.20

package/dist/index.js

@@ -1497,37 +1497,37 @@ var require_dataType = __commonJS({
       DataType2[DataType2["Wrong"] = 1] = "Wrong";
     })(DataType || (exports.DataType = DataType = {}));
     function getSchemaTypes(schema) {
-      const types2 = getJSONTypes(schema.type);
-      const hasNull = types2.includes("null");
+      const types = getJSONTypes(schema.type);
+      const hasNull = types.includes("null");
       if (hasNull) {
         if (schema.nullable === false)
           throw new Error("type: null contradicts nullable: false");
       } else {
-        if (!types2.length && schema.nullable !== void 0) {
+        if (!types.length && schema.nullable !== void 0) {
           throw new Error('"nullable" cannot be used without "type"');
         }
         if (schema.nullable === true)
-          types2.push("null");
+          types.push("null");
       }
-      return types2;
+      return types;
     }
     exports.getSchemaTypes = getSchemaTypes;
     function getJSONTypes(ts) {
-      const types2 = Array.isArray(ts) ? ts : ts ? [ts] : [];
-      if (types2.every(rules_1.isJSONType))
-        return types2;
-      throw new Error("type must be JSONType or JSONType[]: " + types2.join(","));
+      const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
+      if (types.every(rules_1.isJSONType))
+        return types;
+      throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
     }
     exports.getJSONTypes = getJSONTypes;
-    function coerceAndCheckDataType(it, types2) {
+    function coerceAndCheckDataType(it, types) {
       const { gen, data, opts } = it;
-      const coerceTo = coerceToTypes(types2, opts.coerceTypes);
-      const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types2[0]));
+      const coerceTo = coerceToTypes(types, opts.coerceTypes);
+      const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
       if (checkTypes) {
-        const wrongType = checkDataTypes(types2, data, opts.strictNumbers, DataType.Wrong);
+        const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
         gen.if(wrongType, () => {
           if (coerceTo.length)
-            coerceData(it, types2, coerceTo);
+            coerceData(it, types, coerceTo);
           else
             reportTypeError(it);
         });
@@ -1536,15 +1536,15 @@ var require_dataType = __commonJS({
     }
     exports.coerceAndCheckDataType = coerceAndCheckDataType;
     var COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
-    function coerceToTypes(types2, coerceTypes) {
-      return coerceTypes ? types2.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+    function coerceToTypes(types, coerceTypes) {
+      return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
     }
-    function coerceData(it, types2, coerceTo) {
+    function coerceData(it, types, coerceTo) {
       const { gen, data, opts } = it;
       const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
       const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
       if (opts.coerceTypes === "array") {
-        gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types2, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+        gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
       }
       gen.if((0, codegen_1._)`${coerced} !== undefined`);
       for (const t of coerceTo) {
@@ -1620,19 +1620,19 @@ var require_dataType = __commonJS({
         return checkDataType(dataTypes[0], data, strictNums, correct);
       }
       let cond;
-      const types2 = (0, util_1.toHash)(dataTypes);
-      if (types2.array && types2.object) {
+      const types = (0, util_1.toHash)(dataTypes);
+      if (types.array && types.object) {
         const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
-        cond = types2.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
-        delete types2.null;
-        delete types2.array;
-        delete types2.object;
+        cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+        delete types.null;
+        delete types.array;
+        delete types.object;
       } else {
         cond = codegen_1.nil;
       }
-      if (types2.number)
-        delete types2.integer;
-      for (const t in types2)
+      if (types.number)
+        delete types.integer;
+      for (const t in types)
         cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
       return cond;
     }
@@ -2437,9 +2437,9 @@ var require_validate = __commonJS({
     function typeAndKeywords(it, errsCount) {
       if (it.opts.jtd)
         return schemaKeywords(it, [], false, errsCount);
-      const types2 = (0, dataType_1.getSchemaTypes)(it.schema);
-      const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types2);
-      schemaKeywords(it, types2, !checkedTypes, errsCount);
+      const types = (0, dataType_1.getSchemaTypes)(it.schema);
+      const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types);
+      schemaKeywords(it, types, !checkedTypes, errsCount);
     }
     function checkRefsAndKeywords(it) {
       const { schema, errSchemaPath, opts, self } = it;
@@ -2489,7 +2489,7 @@ var require_validate = __commonJS({
       if (items instanceof codegen_1.Name)
         gen.assign((0, codegen_1._)`${evaluated}.items`, items);
     }
-    function schemaKeywords(it, types2, typeErrors, errsCount) {
+    function schemaKeywords(it, types, typeErrors, errsCount) {
       const { gen, schema, data, allErrors, opts, self } = it;
       const { RULES } = self;
       if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
@@ -2497,7 +2497,7 @@ var require_validate = __commonJS({
         return;
       }
       if (!opts.jtd)
-        checkStrictTypes(it, types2);
+        checkStrictTypes(it, types);
       gen.block(() => {
         for (const group of RULES.rules)
           groupKeywords(group);
@@ -2509,7 +2509,7 @@ var require_validate = __commonJS({
         if (group.type) {
           gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
           iterateKeywords(it, group);
-          if (types2.length === 1 && types2[0] === group.type && typeErrors) {
+          if (types.length === 1 && types[0] === group.type && typeErrors) {
             gen.else();
             (0, dataType_2.reportTypeError)(it);
           }
@@ -2533,27 +2533,27 @@ var require_validate = __commonJS({
         }
       });
     }
-    function checkStrictTypes(it, types2) {
+    function checkStrictTypes(it, types) {
       if (it.schemaEnv.meta || !it.opts.strictTypes)
         return;
-      checkContextTypes(it, types2);
+      checkContextTypes(it, types);
       if (!it.opts.allowUnionTypes)
-        checkMultipleTypes(it, types2);
+        checkMultipleTypes(it, types);
       checkKeywordTypes(it, it.dataTypes);
     }
-    function checkContextTypes(it, types2) {
-      if (!types2.length)
+    function checkContextTypes(it, types) {
+      if (!types.length)
         return;
       if (!it.dataTypes.length) {
-        it.dataTypes = types2;
+        it.dataTypes = types;
         return;
       }
-      types2.forEach((t) => {
+      types.forEach((t) => {
         if (!includesType(it.dataTypes, t)) {
           strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
         }
       });
-      narrowSchemaTypes(it, types2);
+      narrowSchemaTypes(it, types);
     }
     function checkMultipleTypes(it, ts) {
       if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -2979,7 +2979,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve5.call(this, root, ref);
+      let _sch = resolve6.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -3006,7 +3006,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve5(root, ref) {
+    function resolve6(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3221,8 +3221,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path2) {
-      let input = path2;
+    function removeDotSegments(path) {
+      let input = path;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3421,8 +3421,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path2, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
+        const [path, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path && path !== "/" ? path : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3581,7 +3581,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve5(baseURI, relativeURI, options) {
+    function resolve6(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3808,7 +3808,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve5,
+      resolve: resolve6,
       resolveComponent,
       equal,
       serialize,
@@ -7868,7 +7868,7 @@ function maybePushScalarOverwriteWarning(warnings, componentId, field, existingV
   });
 }
 function mergeNestedObject(existing, incoming, options, warnings, componentId, pathPrefix) {
-  const merged = { ...existing ?? {} };
+  const merged = { ...existing };
   for (const [field, incomingValue] of Object.entries(incoming)) {
     if (!isDefined(incomingValue)) {
       continue;
@@ -9071,9 +9071,9 @@ function floatSafeRemainder(val, step) {
   const stepString = step.toString();
   let stepDecCount = (stepString.split(".")[1] || "").length;
   if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
-    const match2 = stepString.match(/\d?e-(\d?)/);
-    if (match2?.[1]) {
-      stepDecCount = Number.parseInt(match2[1]);
+    const match = stepString.match(/\d?e-(\d?)/);
+    if (match?.[1]) {
+      stepDecCount = Number.parseInt(match[1]);
     }
   }
   const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
@@ -9126,10 +9126,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path) {
+  if (!path)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -9512,11 +9512,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path);
     return iss;
   });
 }
@@ -9699,7 +9699,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path2 = []) => {
+  const processError = (error49, path = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -9709,7 +9709,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -9741,8 +9741,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18855,10 +18855,10 @@ function _property(property, schema, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _mime(types2, params) {
+function _mime(types, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types2,
+    mime: types,
     ...normalizeParams(params)
   });
 }
@@ -19384,8 +19384,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       continue;
     }
     if (ctx.external) {
-      const ext2 = ctx.external.registry.get(entry[0])?.id;
-      if (schema !== entry[0] && ext2) {
+      const ext = ctx.external.registry.get(entry[0])?.id;
+      if (schema !== entry[0] && ext) {
         extractToDef(entry);
         continue;
       }
@@ -21290,7 +21290,7 @@ var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
-  inst.mime = (types2, params) => inst.check(_mime(Array.isArray(types2) ? types2 : [types2], params));
+  inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -21719,13 +21719,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path2 = ref.slice(1).split("/").filter(Boolean);
-  if (path2.length === 0) {
+  const path = ref.slice(1).split("/").filter(Boolean);
+  if (path.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path2[0] === defsKey) {
-    const key = path2[1];
+  if (path[0] === defsKey) {
+    const key = path[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -24017,9 +24017,9 @@ import { accessSync } from "node:fs";
 function isNodeError(error48) {
   return error48 instanceof Error && "code" in error48;
 }
-function fileExists(path2) {
+function fileExists(path) {
   try {
-    accessSync(path2);
+    accessSync(path);
     return true;
   } catch (error48) {
     if (isNodeError(error48) && error48.code === "ENOENT") {
@@ -24588,11 +24588,11 @@ function failure11(code, message, suggestions = []) {
 function isRestApiWithPath(component) {
   return component.type === "API" && "path" in component && "httpMethod" in component;
 }
-function findApisByPath(graph, path2, method) {
+function findApisByPath(graph, path, method) {
   const query = new RiviereQuery(graph);
   const allComponents = query.componentsByType("API");
   const apis = allComponents.filter(isRestApiWithPath);
-  const matchingPath = apis.filter((api) => api.path === path2);
+  const matchingPath = apis.filter((api) => api.path === path);
   if (method) {
     return matchingPath.filter((api) => api.httpMethod === method);
   }
@@ -25801,21 +25801,19 @@ Examples:
 
 // src/features/extract/infra/persistence/extraction-project/extraction-project-repository.ts
 import {
-  existsSync as existsSync4,
-  readFileSync as readFileSync3
+  existsSync as existsSync5,
+  readFileSync as readFileSync4
 } from "node:fs";
-import { createRequire } from "node:module";
 import {
-  dirname as dirname2,
-  posix as posix4,
-  resolve as resolve4
+  dirname as dirname3,
+  posix,
+  resolve as resolve5
 } from "node:path";
-import { parse as parseYaml } from "yaml";
+import { parse as parseYaml2 } from "yaml";
 import { globSync } from "glob";
 
 // ../riviere-extract-ts/dist/features/extraction/domain/component-extraction/extractor.js
 import { Scope } from "ts-morph";
-import { posix } from "node:path";
 
 // ../riviere-extract-ts/dist/features/extraction/domain/predicate-evaluation/evaluate-predicate.js
 import { Node as TsMorphNode } from "ts-morph";
@@ -25939,6 +25937,22 @@ function evaluateInClassWith(node, predicate) {
   return evaluatePredicate(parent, predicate);
 }
 
+// ../riviere-extract-ts/dist/features/extraction/domain/component-extraction/draft-component.js
+var DraftComponent = class {
+  type;
+  name;
+  location;
+  domain;
+  module;
+  constructor(params) {
+    this.type = params.type;
+    this.name = params.name;
+    this.location = params.location;
+    this.domain = params.domain;
+    this.module = params.module;
+  }
+};
+
 // ../riviere-extract-ts/dist/features/extraction/domain/component-extraction/extractor.js
 var COMPONENT_TYPES = [
   "api",
@@ -25948,19 +25962,15 @@ var COMPONENT_TYPES = [
   "eventHandler",
   "ui"
 ];
-function extractComponents(project, sourceFilePaths, config2, globMatcher, configDir) {
-  return sourceFilePaths.flatMap((filePath) => extractFromFile(project, filePath, config2, globMatcher, configDir));
+function extractComponents(project, sourceFilePaths, module) {
+  return sourceFilePaths.flatMap((filePath) => extractFromFile(project, filePath, module));
 }
-function extractFromFile(project, filePath, config2, globMatcher, configDir) {
+function extractFromFile(project, filePath, module) {
   const sourceFile = project.getSourceFile(filePath);
   if (sourceFile === void 0) {
     return [];
   }
-  const matchingModule = findMatchingModule(filePath, config2.modules, globMatcher, configDir);
-  if (matchingModule === void 0) {
-    return [];
-  }
-  return extractFromModule(sourceFile, filePath, matchingModule);
+  return extractFromModule(sourceFile, filePath, module);
 }
 function extractFromModule(sourceFile, filePath, module) {
   const context = resolveComponentContext(filePath, module);
@@ -26041,7 +26051,7 @@ function createClassComponent(classDecl, filePath, context, componentType) {
     return [];
   }
   return [
-    {
+    new DraftComponent({
       type: componentType,
       name,
       location: {
@@ -26050,13 +26060,13 @@ function createClassComponent(classDecl, filePath, context, componentType) {
       },
       domain: context.domain,
       module: context.module
-    }
+    })
   ];
 }
 function createMethodComponent(method, filePath, context, componentType) {
   const name = method.getName();
   return [
-    {
+    new DraftComponent({
       type: componentType,
       name,
       location: {
@@ -26065,7 +26075,7 @@ function createMethodComponent(method, filePath, context, componentType) {
       },
       domain: context.domain,
       module: context.module
-    }
+    })
   ];
 }
 function createFunctionComponent(func, filePath, context, componentType) {
@@ -26074,7 +26084,7 @@ function createFunctionComponent(func, filePath, context, componentType) {
     return [];
   }
   return [
-    {
+    new DraftComponent({
       type: componentType,
       name,
       location: {
@@ -26083,28 +26093,11 @@ function createFunctionComponent(func, filePath, context, componentType) {
       },
       domain: context.domain,
       module: context.module
-    }
+    })
   ];
 }
-function findMatchingModule(filePath, modules, globMatcher, configDir) {
-  const normalized = filePath.replaceAll(/\\+/g, "/");
-  if (configDir === void 0) {
-    return modules.find((m) => globMatcher(normalized, posix.join(m.path, m.glob)));
-  }
-  const normalizedConfigDir = configDir.replaceAll(/\\+/g, "/");
-  const pathToMatch = posix.relative(normalizedConfigDir, normalized);
-  return modules.find((m) => globMatcher(pathToMatch, posix.join(m.path, m.glob)));
-}
 
 // ../riviere-extract-ts/dist/features/extraction/domain/config-resolution/config-resolution-errors.js
-var ConfigLoaderRequiredError = class extends Error {
-  moduleName;
-  constructor(moduleName) {
-    super(`Module '${moduleName}' uses extends but no config loader was provided.`);
-    this.name = "ConfigLoaderRequiredError";
-    this.moduleName = moduleName;
-  }
-};
 var MissingComponentRuleError = class extends Error {
   moduleName;
   ruleName;
@@ -26117,17 +26110,13 @@ var MissingComponentRuleError = class extends Error {
 };
 
 // ../riviere-extract-ts/dist/features/extraction/domain/config-resolution/resolve-config.js
-function resolveConfig(config2, loader) {
+function resolveConfig(config2) {
   return {
     ...config2,
-    modules: config2.modules.map((m) => resolveModule(m, loader))
+    modules: config2.modules.map(resolveModule)
   };
 }
-function resolveModule(moduleConfig, loader) {
-  const extendsSource = moduleConfig.extends;
-  if (extendsSource !== void 0) {
-    return resolveModuleWithExtends(moduleConfig, extendsSource, loader);
-  }
+function resolveModule(moduleConfig) {
   return {
     name: moduleConfig.name,
     domain: moduleConfig.domain,
@@ -26143,36 +26132,6 @@ function resolveModule(moduleConfig, loader) {
     ...moduleConfig.customTypes !== void 0 && { customTypes: moduleConfig.customTypes }
   };
 }
-function resolveModuleWithExtends(moduleConfig, extendsSource, loader) {
-  if (loader === void 0) {
-    throw new ConfigLoaderRequiredError(moduleConfig.name);
-  }
-  const baseModule = loader(extendsSource);
-  const mergedCustomTypes = mergeCustomTypes(baseModule.customTypes, moduleConfig.customTypes);
-  return {
-    name: moduleConfig.name,
-    domain: moduleConfig.domain,
-    path: moduleConfig.path,
-    glob: moduleConfig.glob,
-    ...moduleConfig.modules !== void 0 && { modules: moduleConfig.modules },
-    api: moduleConfig.api ?? baseModule.api,
-    useCase: moduleConfig.useCase ?? baseModule.useCase,
-    domainOp: moduleConfig.domainOp ?? baseModule.domainOp,
-    event: moduleConfig.event ?? baseModule.event,
-    eventHandler: moduleConfig.eventHandler ?? baseModule.eventHandler,
-    ui: moduleConfig.ui ?? baseModule.ui,
-    ...mergedCustomTypes !== void 0 && { customTypes: mergedCustomTypes }
-  };
-}
-function mergeCustomTypes(base, local) {
-  if (base === void 0 && local === void 0) {
-    return void 0;
-  }
-  return {
-    ...base,
-    ...local
-  };
-}
 function requireRule(rule, ruleName, moduleName) {
   if (rule === void 0) {
     throw new MissingComponentRuleError(moduleName, ruleName);
@@ -26180,6 +26139,14 @@ function requireRule(rule, ruleName, moduleName) {
   return rule;
 }
 
+// ../riviere-extract-ts/dist/features/extraction/domain/value-extraction/extraction-result.js
+var ExtractionResult = class {
+  value;
+  constructor(params) {
+    this.value = params.value;
+  }
+};
+
 // ../riviere-extract-ts/dist/platform/domain/string-transforms/transforms.js
 function stripSuffix(value, suffix) {
   if (value.endsWith(suffix)) {
@@ -26244,6 +26211,14 @@ var ExtractionError = class extends Error {
     };
   }
 };
+var LiteralResult = class {
+  kind;
+  value;
+  constructor(params) {
+    this.kind = params.kind;
+    this.value = params.value;
+  }
+};
 function extractString(expression) {
   return expression.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
 }
@@ -26266,34 +26241,34 @@ function buildExtractionResult(expression) {
   const syntaxKind = expression.getKind();
   switch (syntaxKind) {
     case SyntaxKind.StringLiteral:
-      return {
+      return new LiteralResult({
         kind: "string",
         value: extractString(expression)
-      };
+      });
     case SyntaxKind.NumericLiteral:
-      return {
+      return new LiteralResult({
         kind: "number",
         value: extractNumber(expression)
-      };
+      });
     case SyntaxKind.TrueKeyword:
-      return {
+      return new LiteralResult({
         kind: "boolean",
         value: true
-      };
+      });
     case SyntaxKind.FalseKeyword:
-      return {
+      return new LiteralResult({
         kind: "boolean",
         value: false
-      };
+      });
     case SyntaxKind.ArrayLiteralExpression: {
       const values = extractStringArray(expression);
       if (values === void 0) {
         return void 0;
       }
-      return {
+      return new LiteralResult({
         kind: "string[]",
         value: values
-      };
+      });
     }
     default:
       return void 0;
@@ -26316,1911 +26291,177 @@ function extractLiteralValue(expression, file2, line) {
   return result;
 }
 
-// ../riviere-extract-ts/dist/features/extraction/domain/value-extraction/evaluate-extraction-rule-generic.js
-import { SyntaxKind as SyntaxKind2 } from "ts-morph";
-function getInterfaceTypeArgs(classDecl, interfaceName) {
-  const implementsClause = classDecl.getImplements();
-  for (const impl of implementsClause) {
-    const expression = impl.getExpression();
-    if (expression.getText() === interfaceName) {
-      return impl.getTypeArguments();
-    }
-  }
-  const extendsClause = classDecl.getExtends();
-  if (extendsClause === void 0) {
-    return void 0;
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/detect-connections.js
+import { performance } from "node:perf_hooks";
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/async-detection-options.js
+var AsyncDetectionOptions = class {
+  strict;
+  repository;
+  constructor(params) {
+    this.strict = params.strict;
+    this.repository = params.repository;
   }
-  const baseClass = classDecl.getBaseClass();
-  if (baseClass === void 0)
-    return void 0;
-  return getInterfaceTypeArgs(baseClass, interfaceName);
+};
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/component-index.js
+function locationKey(file2, line) {
+  return `${file2}:${line}`;
 }
-function extractTypeNames(typeNode) {
-  if (typeNode.getKind() === SyntaxKind2.UnionType) {
-    const unionType = typeNode.asKindOrThrow(SyntaxKind2.UnionType);
-    return unionType.getTypeNodes().map((t) => t.getText());
+var ComponentIndex = class {
+  byName;
+  byLocation;
+  constructor(components) {
+    const nameMap = /* @__PURE__ */ new Map();
+    const locationMap = /* @__PURE__ */ new Map();
+    for (const component of components) {
+      nameMap.set(component.name, component);
+      locationMap.set(locationKey(component.location.file, component.location.line), component);
+    }
+    this.byName = nameMap;
+    this.byLocation = locationMap;
   }
-  return [typeNode.getText()];
-}
-function evaluateFromGenericArgRule(rule, classDecl) {
-  const { interface: interfaceName, position, transform: transform2 } = rule.fromGenericArg;
-  const sourceFile = classDecl.getSourceFile();
-  const location = {
-    filePath: sourceFile.getFilePath(),
-    line: classDecl.getStartLineNumber()
-  };
-  const typeArgs = getInterfaceTypeArgs(classDecl, interfaceName);
-  if (typeArgs === void 0) {
-    throw new ExtractionError(`Class '${classDecl.getName() ?? "anonymous"}' does not implement interface '${interfaceName}'`, location.filePath, location.line);
+  isComponent(typeName) {
+    return this.byName.has(this.withoutGenericArguments(typeName));
   }
-  const typeArg = typeArgs[position];
-  if (typeArg === void 0) {
-    throw new ExtractionError(`Position ${position} out of bounds. Interface has ${typeArgs.length} type argument(s)`, location.filePath, location.line);
+  getComponentByTypeName(typeName) {
+    return this.byName.get(this.withoutGenericArguments(typeName));
   }
-  if (typeArg.getKind() === SyntaxKind2.TypeReference) {
-    const typeRef = typeArg.asKindOrThrow(SyntaxKind2.TypeReference);
-    const typeName = typeRef.getTypeName();
-    if (typeName.getKind() === SyntaxKind2.Identifier) {
-      const classTypeParams = classDecl.getTypeParameters();
-      const paramName = typeName.getText();
-      const isTypeParam = classTypeParams.some((p) => p.getName() === paramName);
-      if (isTypeParam) {
-        throw new ExtractionError(`Generic argument at position ${position} is type parameter '${paramName}', expected concrete type`, location.filePath, location.line);
-      }
-    }
+  getComponentByLocation(file2, line) {
+    return this.byLocation.get(locationKey(file2, line));
   }
-  const typeNames = extractTypeNames(typeArg);
-  if (transform2 === void 0) {
-    return { value: typeNames };
+  withoutGenericArguments(typeName) {
+    const index = typeName.indexOf("<");
+    if (index === -1) {
+      return typeName;
+    }
+    return typeName.slice(0, index);
   }
-  return { value: typeNames.map((name) => applyTransforms(name, transform2)) };
-}
+};
 
-// ../riviere-extract-ts/dist/features/extraction/domain/value-extraction/evaluate-extraction-rule.js
-import { SyntaxKind as SyntaxKind3 } from "ts-morph";
-function literal2(value) {
-  return { value };
-}
-function evaluateLiteralRule(rule) {
-  return literal2(rule.literal);
-}
-function evaluateFromClassNameRule(rule, classDecl) {
-  const className = classDecl.getName();
-  if (!className) {
-    const filePath = classDecl.getSourceFile().getFilePath();
-    const lineNumber = classDecl.getStartLineNumber();
-    throw new ExtractionError("Expected class name, got undefined", filePath, lineNumber);
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/build-call-graph.js
+import { Node as Node3, SyntaxKind as SyntaxKind4 } from "ts-morph";
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/call-graph-types.js
+var CallGraphOptions = class {
+  strict;
+  sourceFilePaths;
+  repository;
+  constructor(params) {
+    this.strict = params.strict;
+    this.sourceFilePaths = params.sourceFilePaths;
+    this.repository = params.repository;
   }
-  if (rule.fromClassName === true) {
-    return { value: className };
+};
+var CallSite = class {
+  filePath;
+  lineNumber;
+  methodName;
+  constructor(params) {
+    this.filePath = params.filePath;
+    this.lineNumber = params.lineNumber;
+    this.methodName = params.methodName;
   }
-  const transform2 = rule.fromClassName.transform;
-  if (transform2 === void 0) {
-    return { value: className };
+};
+var RawLink = class {
+  source;
+  target;
+  callSite;
+  constructor(params) {
+    this.source = params.source;
+    this.target = params.target;
+    this.callSite = params.callSite;
+  }
+};
+var UncertainRawLink = class {
+  source;
+  reason;
+  callSite;
+  constructor(params) {
+    this.source = params.source;
+    this.reason = params.reason;
+    this.callSite = params.callSite;
   }
-  return { value: applyTransforms(className, transform2) };
+};
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/component-identity.js
+function componentIdentity(component) {
+  return ComponentId.create({
+    domain: component.domain,
+    module: component.module,
+    type: component.type,
+    name: component.name
+  }).toString();
 }
-function evaluateFromMethodNameRule(rule, methodDecl) {
-  const methodName = methodDecl.getName();
-  if (rule.fromMethodName === true) {
-    return { value: methodName };
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/trace-calls.js
+import { Node as Node2, SyntaxKind as SyntaxKind3 } from "ts-morph";
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/method-level-target.js
+var MethodLevelTarget = class {
+  classDecl;
+  method;
+  constructor(params) {
+    this.classDecl = params.classDecl;
+    this.method = params.method;
   }
-  const transform2 = rule.fromMethodName.transform;
-  if (transform2 === void 0) {
-    return { value: methodName };
+};
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/type-resolver.js
+import { CallExpression, SourceFile, Node } from "ts-morph";
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/connection-detection-error.js
+var ConnectionDetectionError = class extends Error {
+  file;
+  line;
+  typeName;
+  reason;
+  constructor(params) {
+    super(`Connection detection failed for ${params.typeName} at ${params.file}:${params.line}: ${params.reason}`);
+    this.name = "ConnectionDetectionError";
+    this.file = params.file;
+    this.line = params.line;
+    this.typeName = params.typeName;
+    this.reason = params.reason;
   }
-  return { value: applyTransforms(methodName, transform2) };
-}
-function evaluateFromFilePathRule(rule, filePath) {
-  const pattern = rule.fromFilePath.pattern;
-  const capture = rule.fromFilePath.capture;
-  const transform2 = rule.fromFilePath.transform;
-  const regex = new RegExp(pattern);
-  const match2 = regex.exec(filePath);
-  if (match2 === null) {
-    throw new ExtractionError(`Pattern '${pattern}' did not match file path '${filePath}'`, filePath, 0);
+};
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/type-resolver.js
+var TypeResolution = class _TypeResolution {
+  resolved;
+  typeName;
+  reason;
+  constructor(params) {
+    this.resolved = params.resolved;
+    this.typeName = params.typeName;
+    this.reason = params.reason;
   }
-  const capturedValue = match2[capture];
-  if (capturedValue === void 0) {
-    throw new ExtractionError(`Capture group ${capture} out of bounds. Pattern has ${match2.length - 1} capture groups`, filePath, 0);
+  static resolved(typeName) {
+    return new _TypeResolution({
+      resolved: true,
+      typeName,
+      reason: void 0
+    });
   }
-  if (transform2 === void 0) {
-    return { value: capturedValue };
+  static unresolved(reason) {
+    return new _TypeResolution({
+      resolved: false,
+      typeName: void 0,
+      reason
+    });
   }
-  return { value: applyTransforms(capturedValue, transform2) };
+};
+function stripGenerics(typeName) {
+  const angleBracketIndex = typeName.indexOf("<");
+  if (angleBracketIndex === -1)
+    return typeName;
+  return typeName.slice(0, angleBracketIndex);
 }
-function findPropertyInHierarchy(classDecl, propertyName, isStatic) {
-  const properties = isStatic ? classDecl.getStaticProperties() : classDecl.getInstanceProperties();
-  const property = properties.find((p) => p.getName() === propertyName);
-  if (property !== void 0 && "getInitializer" in property) {
-    const sourceFile = classDecl.getSourceFile();
-    return {
-      initializer: property.getInitializer(),
-      filePath: sourceFile.getFilePath(),
-      line: property.getStartLineNumber()
-    };
-  }
-  if (classDecl.getExtends() === void 0) {
-    return void 0;
+function stripPromise(typeName) {
+  if (typeName.startsWith("Promise<") && typeName.endsWith(">")) {
+    return typeName.slice(8, -1);
   }
-  const baseClass = classDecl.getBaseClass();
-  if (baseClass === void 0)
-    return void 0;
-  return findPropertyInHierarchy(baseClass, propertyName, isStatic);
-}
-function evaluateFromPropertyRule(rule, classDecl) {
-  const name = rule.fromProperty.name;
-  const kind = rule.fromProperty.kind;
-  const transform2 = rule.fromProperty.transform;
-  const isStatic = kind === "static";
-  const propertyInfo = findPropertyInHierarchy(classDecl, name, isStatic);
-  if (propertyInfo === void 0) {
-    const sourceFile = classDecl.getSourceFile();
-    throw new ExtractionError(`Property '${name}' not found on class '${classDecl.getName() ?? "anonymous"}'`, sourceFile.getFilePath(), classDecl.getStartLineNumber());
-  }
-  const literalResult = extractLiteralValue(propertyInfo.initializer, propertyInfo.filePath, propertyInfo.line);
-  if (transform2 === void 0) {
-    return { value: literalResult.value };
-  }
-  if (typeof literalResult.value !== "string") {
-    return { value: literalResult.value };
-  }
-  return { value: applyTransforms(literalResult.value, transform2) };
-}
-function getDecoratorLocation(decorator) {
-  const sourceFile = decorator.getSourceFile();
-  return {
-    filePath: sourceFile.getFilePath(),
-    line: decorator.getStartLineNumber()
-  };
-}
-function extractPositionalArg(decorator, position) {
-  const args = decorator.getArguments();
-  const location = getDecoratorLocation(decorator);
-  if (args.length === 0) {
-    throw new ExtractionError(`Decorator '@${decorator.getName()}' has no arguments`, location.filePath, location.line);
-  }
-  const arg = args[position];
-  if (arg === void 0) {
-    throw new ExtractionError(`Argument position ${position} out of bounds. Decorator has ${args.length} argument(s)`, location.filePath, location.line);
-  }
-  if (arg.getKind() !== SyntaxKind3.StringLiteral) {
-    throw new ExtractionError(`Expected string literal at position ${position}, got ${arg.getKindName()}`, location.filePath, location.line);
-  }
-  return arg.asKindOrThrow(SyntaxKind3.StringLiteral).getLiteralValue();
-}
-function throwNoArguments(decorator, location) {
-  throw new ExtractionError(`Decorator '@${decorator.getName()}' has no arguments`, location.filePath, location.line);
-}
-function getFirstArgument(decorator, location) {
-  const args = decorator.getArguments();
-  const firstArg = args[0];
-  if (firstArg === void 0) {
-    throwNoArguments(decorator, location);
-  }
-  return firstArg;
-}
-function extractNamedArg(decorator, name) {
-  const location = getDecoratorLocation(decorator);
-  const firstArg = getFirstArgument(decorator, location);
-  if (firstArg.getKind() !== SyntaxKind3.ObjectLiteralExpression) {
-    throw new ExtractionError(`Expected object literal argument, got ${firstArg.getKindName()}`, location.filePath, location.line);
-  }
-  const objectLiteral = firstArg.asKindOrThrow(SyntaxKind3.ObjectLiteralExpression);
-  const property = objectLiteral.getProperty(name);
-  if (property === void 0) {
-    throw new ExtractionError(`Property '${name}' not found in decorator argument`, location.filePath, location.line);
-  }
-  if (!("getInitializer" in property)) {
-    throw new ExtractionError(`Property '${name}' has no initializer`, location.filePath, location.line);
-  }
-  const initializer3 = property.getInitializer();
-  if (initializer3?.getKind() !== SyntaxKind3.StringLiteral) {
-    throw new ExtractionError(`Expected string literal for property '${name}'`, location.filePath, location.line);
-  }
-  return initializer3.asKindOrThrow(SyntaxKind3.StringLiteral).getLiteralValue();
-}
-function evaluateFromDecoratorArgRule(rule, decorator) {
-  const decoratorName = rule.fromDecoratorArg.decorator;
-  const position = rule.fromDecoratorArg.position;
-  const name = rule.fromDecoratorArg.name;
-  const transform2 = rule.fromDecoratorArg.transform;
-  if (decoratorName !== void 0 && decorator.getName() !== decoratorName) {
-    const location = getDecoratorLocation(decorator);
-    throw new ExtractionError(`Expected decorator '@${decoratorName}', got '@${decorator.getName()}'`, location.filePath, location.line);
-  }
-  const extractValue = () => {
-    if (position !== void 0) {
-      return extractPositionalArg(decorator, position);
-    }
-    if (!name) {
-      const location = getDecoratorLocation(decorator);
-      throw new ExtractionError("Expected name parameter when position is undefined", location.filePath, location.line);
-    }
-    return extractNamedArg(decorator, name);
-  };
-  const value = extractValue();
-  if (transform2 === void 0) {
-    return { value };
-  }
-  return { value: applyTransforms(value, transform2) };
-}
-function evaluateFromClassDecoratorArgRule(rule, methodDecl) {
-  const classDecl = methodDecl.getParentIfKind(SyntaxKind3.ClassDeclaration);
-  if (classDecl === void 0) {
-    const sourceFile = methodDecl.getSourceFile();
-    throw new ExtractionError(`Expected method '${methodDecl.getName()}' to be declared inside a class`, sourceFile.getFilePath(), methodDecl.getStartLineNumber());
-  }
-  const classDecorator = classDecl.getDecorators().find((decorator) => decorator.getName() === rule.fromClassDecoratorArg.decorator);
-  if (classDecorator === void 0) {
-    const sourceFile = classDecl.getSourceFile();
-    throw new ExtractionError(`Decorator '@${rule.fromClassDecoratorArg.decorator}' not found on containing class '${classDecl.getName() ?? "anonymous"}'`, sourceFile.getFilePath(), classDecl.getStartLineNumber());
-  }
-  const fromClassDecoratorArg = rule.fromClassDecoratorArg;
-  const fromDecoratorArgRule = {
-    decorator: fromClassDecoratorArg.decorator,
-    ...fromClassDecoratorArg.position === void 0 ? {} : { position: fromClassDecoratorArg.position },
-    ...fromClassDecoratorArg.name === void 0 ? {} : { name: fromClassDecoratorArg.name },
-    ...fromClassDecoratorArg.transform === void 0 ? {} : { transform: fromClassDecoratorArg.transform }
-  };
-  return evaluateFromDecoratorArgRule({ fromDecoratorArg: fromDecoratorArgRule }, classDecorator);
-}
-function evaluateFromDecoratorNameRule(rule, decorator) {
-  const decoratorName = decorator.getName();
-  if (rule.fromDecoratorName === true) {
-    return { value: decoratorName };
-  }
-  const mapping = rule.fromDecoratorName.mapping;
-  const transform2 = rule.fromDecoratorName.transform;
-  const mappedValue = mapping?.[decoratorName] ?? decoratorName;
-  if (transform2 === void 0) {
-    return { value: mappedValue };
-  }
-  return { value: applyTransforms(mappedValue, transform2) };
-}
-
-// ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
-var balanced = (a, b, str) => {
-  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
-  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
-  const r = ma !== null && mb != null && range(ma, mb, str);
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + ma.length, r[1]),
-    post: str.slice(r[1] + mb.length)
-  };
-};
-var maybeMatch = (reg, str) => {
-  const m = str.match(reg);
-  return m ? m[0] : null;
-};
-var range = (a, b, str) => {
-  let begs, beg, left, right = void 0, result;
-  let ai = str.indexOf(a);
-  let bi = str.indexOf(b, ai + 1);
-  let i = ai;
-  if (ai >= 0 && bi > 0) {
-    if (a === b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str.length;
-    while (i >= 0 && !result) {
-      if (i === ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length === 1) {
-        const r = begs.pop();
-        if (r !== void 0)
-          result = [r, bi];
-      } else {
-        beg = begs.pop();
-        if (beg !== void 0 && beg < left) {
-          left = beg;
-          right = bi;
-        }
-        bi = str.indexOf(b, i + 1);
-      }
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-    if (begs.length && right !== void 0) {
-      result = [left, right];
-    }
-  }
-  return result;
-};
-
-// ../../node_modules/.pnpm/@isaacs+brace-expansion@5.0.0/node_modules/@isaacs/brace-expansion/dist/esm/index.js
-var escSlash = "\0SLASH" + Math.random() + "\0";
-var escOpen = "\0OPEN" + Math.random() + "\0";
-var escClose = "\0CLOSE" + Math.random() + "\0";
-var escComma = "\0COMMA" + Math.random() + "\0";
-var escPeriod = "\0PERIOD" + Math.random() + "\0";
-var escSlashPattern = new RegExp(escSlash, "g");
-var escOpenPattern = new RegExp(escOpen, "g");
-var escClosePattern = new RegExp(escClose, "g");
-var escCommaPattern = new RegExp(escComma, "g");
-var escPeriodPattern = new RegExp(escPeriod, "g");
-var slashPattern = /\\\\/g;
-var openPattern = /\\{/g;
-var closePattern = /\\}/g;
-var commaPattern = /\\,/g;
-var periodPattern = /\\./g;
-function numeric(str) {
-  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
-}
-function escapeBraces(str) {
-  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
-}
-function unescapeBraces(str) {
-  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
-}
-function parseCommaParts(str) {
-  if (!str) {
-    return [""];
-  }
-  const parts = [];
-  const m = balanced("{", "}", str);
-  if (!m) {
-    return str.split(",");
-  }
-  const { pre, body, post } = m;
-  const p = pre.split(",");
-  p[p.length - 1] += "{" + body + "}";
-  const postParts = parseCommaParts(post);
-  if (post.length) {
-    ;
-    p[p.length - 1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-  parts.push.apply(parts, p);
-  return parts;
-}
-function expand(str) {
-  if (!str) {
-    return [];
-  }
-  if (str.slice(0, 2) === "{}") {
-    str = "\\{\\}" + str.slice(2);
-  }
-  return expand_(escapeBraces(str), true).map(unescapeBraces);
-}
-function embrace(str) {
-  return "{" + str + "}";
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
-}
-function lte(i, y) {
-  return i <= y;
-}
-function gte(i, y) {
-  return i >= y;
-}
-function expand_(str, isTop) {
-  const expansions = [];
-  const m = balanced("{", "}", str);
-  if (!m)
-    return [str];
-  const pre = m.pre;
-  const post = m.post.length ? expand_(m.post, false) : [""];
-  if (/\$$/.test(m.pre)) {
-    for (let k = 0; k < post.length; k++) {
-      const expansion = pre + "{" + m.body + "}" + post[k];
-      expansions.push(expansion);
-    }
-  } else {
-    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    const isSequence = isNumericSequence || isAlphaSequence;
-    const isOptions = m.body.indexOf(",") >= 0;
-    if (!isSequence && !isOptions) {
-      if (m.post.match(/,(?!,).*\}/)) {
-        str = m.pre + "{" + m.body + escClose + m.post;
-        return expand_(str);
-      }
-      return [str];
-    }
-    let n;
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-      if (n.length === 1 && n[0] !== void 0) {
-        n = expand_(n[0], false).map(embrace);
-        if (n.length === 1) {
-          return post.map((p) => m.pre + n[0] + p);
-        }
-      }
-    }
-    let N;
-    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-      const x = numeric(n[0]);
-      const y = numeric(n[1]);
-      const width = Math.max(n[0].length, n[1].length);
-      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
-      let test = lte;
-      const reverse = y < x;
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-      const pad = n.some(isPadded);
-      N = [];
-      for (let i = x; test(i, y); i += incr) {
-        let c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === "\\") {
-            c = "";
-          }
-        } else {
-          c = String(i);
-          if (pad) {
-            const need = width - c.length;
-            if (need > 0) {
-              const z2 = new Array(need + 1).join("0");
-              if (i < 0) {
-                c = "-" + z2 + c.slice(1);
-              } else {
-                c = z2 + c;
-              }
-            }
-          }
-        }
-        N.push(c);
-      }
-    } else {
-      N = [];
-      for (let j = 0; j < n.length; j++) {
-        N.push.apply(N, expand_(n[j], false));
-      }
-    }
-    for (let j = 0; j < N.length; j++) {
-      for (let k = 0; k < post.length; k++) {
-        const expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion) {
-          expansions.push(expansion);
-        }
-      }
-    }
-  }
-  return expansions;
-}
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/assert-valid-pattern.js
-var MAX_PATTERN_LENGTH = 1024 * 64;
-var assertValidPattern = (pattern) => {
-  if (typeof pattern !== "string") {
-    throw new TypeError("invalid pattern");
-  }
-  if (pattern.length > MAX_PATTERN_LENGTH) {
-    throw new TypeError("pattern is too long");
-  }
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/brace-expressions.js
-var posixClasses = {
-  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
-  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
-  "[:ascii:]": ["\\x00-\\x7f", false],
-  "[:blank:]": ["\\p{Zs}\\t", true],
-  "[:cntrl:]": ["\\p{Cc}", true],
-  "[:digit:]": ["\\p{Nd}", true],
-  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
-  "[:lower:]": ["\\p{Ll}", true],
-  "[:print:]": ["\\p{C}", true],
-  "[:punct:]": ["\\p{P}", true],
-  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
-  "[:upper:]": ["\\p{Lu}", true],
-  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
-  "[:xdigit:]": ["A-Fa-f0-9", false]
-};
-var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
-var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-var rangesToString = (ranges) => ranges.join("");
-var parseClass = (glob, position) => {
-  const pos = position;
-  if (glob.charAt(pos) !== "[") {
-    throw new Error("not in a brace expression");
-  }
-  const ranges = [];
-  const negs = [];
-  let i = pos + 1;
-  let sawStart = false;
-  let uflag = false;
-  let escaping = false;
-  let negate = false;
-  let endPos = pos;
-  let rangeStart = "";
-  WHILE: while (i < glob.length) {
-    const c = glob.charAt(i);
-    if ((c === "!" || c === "^") && i === pos + 1) {
-      negate = true;
-      i++;
-      continue;
-    }
-    if (c === "]" && sawStart && !escaping) {
-      endPos = i + 1;
-      break;
-    }
-    sawStart = true;
-    if (c === "\\") {
-      if (!escaping) {
-        escaping = true;
-        i++;
-        continue;
-      }
-    }
-    if (c === "[" && !escaping) {
-      for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
-        if (glob.startsWith(cls, i)) {
-          if (rangeStart) {
-            return ["$.", false, glob.length - pos, true];
-          }
-          i += cls.length;
-          if (neg)
-            negs.push(unip);
-          else
-            ranges.push(unip);
-          uflag = uflag || u;
-          continue WHILE;
-        }
-      }
-    }
-    escaping = false;
-    if (rangeStart) {
-      if (c > rangeStart) {
-        ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
-      } else if (c === rangeStart) {
-        ranges.push(braceEscape(c));
-      }
-      rangeStart = "";
-      i++;
-      continue;
-    }
-    if (glob.startsWith("-]", i + 1)) {
-      ranges.push(braceEscape(c + "-"));
-      i += 2;
-      continue;
-    }
-    if (glob.startsWith("-", i + 1)) {
-      rangeStart = c;
-      i += 2;
-      continue;
-    }
-    ranges.push(braceEscape(c));
-    i++;
-  }
-  if (endPos < i) {
-    return ["", false, 0, false];
-  }
-  if (!ranges.length && !negs.length) {
-    return ["$.", false, glob.length - pos, true];
-  }
-  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
-    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
-    return [regexpEscape(r), false, endPos - pos, false];
-  }
-  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
-  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
-  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
-  return [comb, uflag, endPos - pos, true];
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/unescape.js
-var unescape2 = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
-  if (magicalBraces) {
-    return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
-  }
-  return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/ast.js
-var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
-var isExtglobType = (c) => types.has(c);
-var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
-var startNoDot = "(?!\\.)";
-var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
-var justDots = /* @__PURE__ */ new Set(["..", "."]);
-var reSpecials = new Set("().*{}+?[]^$\\!");
-var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-var qmark = "[^/]";
-var star = qmark + "*?";
-var starNoEmpty = qmark + "+?";
-var AST = class _AST {
-  type;
-  #root;
-  #hasMagic;
-  #uflag = false;
-  #parts = [];
-  #parent;
-  #parentIndex;
-  #negs;
-  #filledNegs = false;
-  #options;
-  #toString;
-  // set to true if it's an extglob with no children
-  // (which really means one child of '')
-  #emptyExt = false;
-  constructor(type, parent, options = {}) {
-    this.type = type;
-    if (type)
-      this.#hasMagic = true;
-    this.#parent = parent;
-    this.#root = this.#parent ? this.#parent.#root : this;
-    this.#options = this.#root === this ? options : this.#root.#options;
-    this.#negs = this.#root === this ? [] : this.#root.#negs;
-    if (type === "!" && !this.#root.#filledNegs)
-      this.#negs.push(this);
-    this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
-  }
-  get hasMagic() {
-    if (this.#hasMagic !== void 0)
-      return this.#hasMagic;
-    for (const p of this.#parts) {
-      if (typeof p === "string")
-        continue;
-      if (p.type || p.hasMagic)
-        return this.#hasMagic = true;
-    }
-    return this.#hasMagic;
-  }
-  // reconstructs the pattern
-  toString() {
-    if (this.#toString !== void 0)
-      return this.#toString;
-    if (!this.type) {
-      return this.#toString = this.#parts.map((p) => String(p)).join("");
-    } else {
-      return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
-    }
-  }
-  #fillNegs() {
-    if (this !== this.#root)
-      throw new Error("should only call on root");
-    if (this.#filledNegs)
-      return this;
-    this.toString();
-    this.#filledNegs = true;
-    let n;
-    while (n = this.#negs.pop()) {
-      if (n.type !== "!")
-        continue;
-      let p = n;
-      let pp = p.#parent;
-      while (pp) {
-        for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
-          for (const part of n.#parts) {
-            if (typeof part === "string") {
-              throw new Error("string part in extglob AST??");
-            }
-            part.copyIn(pp.#parts[i]);
-          }
-        }
-        p = pp;
-        pp = p.#parent;
-      }
-    }
-    return this;
-  }
-  push(...parts) {
-    for (const p of parts) {
-      if (p === "")
-        continue;
-      if (typeof p !== "string" && !(p instanceof _AST && p.#parent === this)) {
-        throw new Error("invalid part: " + p);
-      }
-      this.#parts.push(p);
-    }
-  }
-  toJSON() {
-    const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
-    if (this.isStart() && !this.type)
-      ret.unshift([]);
-    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
-      ret.push({});
-    }
-    return ret;
-  }
-  isStart() {
-    if (this.#root === this)
-      return true;
-    if (!this.#parent?.isStart())
-      return false;
-    if (this.#parentIndex === 0)
-      return true;
-    const p = this.#parent;
-    for (let i = 0; i < this.#parentIndex; i++) {
-      const pp = p.#parts[i];
-      if (!(pp instanceof _AST && pp.type === "!")) {
-        return false;
-      }
-    }
-    return true;
-  }
-  isEnd() {
-    if (this.#root === this)
-      return true;
-    if (this.#parent?.type === "!")
-      return true;
-    if (!this.#parent?.isEnd())
-      return false;
-    if (!this.type)
-      return this.#parent?.isEnd();
-    const pl = this.#parent ? this.#parent.#parts.length : 0;
-    return this.#parentIndex === pl - 1;
-  }
-  copyIn(part) {
-    if (typeof part === "string")
-      this.push(part);
-    else
-      this.push(part.clone(this));
-  }
-  clone(parent) {
-    const c = new _AST(this.type, parent);
-    for (const p of this.#parts) {
-      c.copyIn(p);
-    }
-    return c;
-  }
-  static #parseAST(str, ast, pos, opt) {
-    let escaping = false;
-    let inBrace = false;
-    let braceStart = -1;
-    let braceNeg = false;
-    if (ast.type === null) {
-      let i2 = pos;
-      let acc2 = "";
-      while (i2 < str.length) {
-        const c = str.charAt(i2++);
-        if (escaping || c === "\\") {
-          escaping = !escaping;
-          acc2 += c;
-          continue;
-        }
-        if (inBrace) {
-          if (i2 === braceStart + 1) {
-            if (c === "^" || c === "!") {
-              braceNeg = true;
-            }
-          } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
-            inBrace = false;
-          }
-          acc2 += c;
-          continue;
-        } else if (c === "[") {
-          inBrace = true;
-          braceStart = i2;
-          braceNeg = false;
-          acc2 += c;
-          continue;
-        }
-        if (!opt.noext && isExtglobType(c) && str.charAt(i2) === "(") {
-          ast.push(acc2);
-          acc2 = "";
-          const ext2 = new _AST(c, ast);
-          i2 = _AST.#parseAST(str, ext2, i2, opt);
-          ast.push(ext2);
-          continue;
-        }
-        acc2 += c;
-      }
-      ast.push(acc2);
-      return i2;
-    }
-    let i = pos + 1;
-    let part = new _AST(null, ast);
-    const parts = [];
-    let acc = "";
-    while (i < str.length) {
-      const c = str.charAt(i++);
-      if (escaping || c === "\\") {
-        escaping = !escaping;
-        acc += c;
-        continue;
-      }
-      if (inBrace) {
-        if (i === braceStart + 1) {
-          if (c === "^" || c === "!") {
-            braceNeg = true;
-          }
-        } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
-          inBrace = false;
-        }
-        acc += c;
-        continue;
-      } else if (c === "[") {
-        inBrace = true;
-        braceStart = i;
-        braceNeg = false;
-        acc += c;
-        continue;
-      }
-      if (isExtglobType(c) && str.charAt(i) === "(") {
-        part.push(acc);
-        acc = "";
-        const ext2 = new _AST(c, part);
-        part.push(ext2);
-        i = _AST.#parseAST(str, ext2, i, opt);
-        continue;
-      }
-      if (c === "|") {
-        part.push(acc);
-        acc = "";
-        parts.push(part);
-        part = new _AST(null, ast);
-        continue;
-      }
-      if (c === ")") {
-        if (acc === "" && ast.#parts.length === 0) {
-          ast.#emptyExt = true;
-        }
-        part.push(acc);
-        acc = "";
-        ast.push(...parts, part);
-        return i;
-      }
-      acc += c;
-    }
-    ast.type = null;
-    ast.#hasMagic = void 0;
-    ast.#parts = [str.substring(pos - 1)];
-    return i;
-  }
-  static fromGlob(pattern, options = {}) {
-    const ast = new _AST(null, void 0, options);
-    _AST.#parseAST(pattern, ast, 0, options);
-    return ast;
-  }
-  // returns the regular expression if there's magic, or the unescaped
-  // string if not.
-  toMMPattern() {
-    if (this !== this.#root)
-      return this.#root.toMMPattern();
-    const glob = this.toString();
-    const [re, body, hasMagic, uflag] = this.toRegExpSource();
-    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
-    if (!anyMagic) {
-      return body;
-    }
-    const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
-    return Object.assign(new RegExp(`^${re}$`, flags), {
-      _src: re,
-      _glob: glob
-    });
-  }
-  get options() {
-    return this.#options;
-  }
-  // returns the string match, the regexp source, whether there's magic
-  // in the regexp (so a regular expression is required) and whether or
-  // not the uflag is needed for the regular expression (for posix classes)
-  // TODO: instead of injecting the start/end at this point, just return
-  // the BODY of the regexp, along with the start/end portions suitable
-  // for binding the start/end in either a joined full-path makeRe context
-  // (where we bind to (^|/), or a standalone matchPart context (where
-  // we bind to ^, and not /).  Otherwise slashes get duped!
-  //
-  // In part-matching mode, the start is:
-  // - if not isStart: nothing
-  // - if traversal possible, but not allowed: ^(?!\.\.?$)
-  // - if dots allowed or not possible: ^
-  // - if dots possible and not allowed: ^(?!\.)
-  // end is:
-  // - if not isEnd(): nothing
-  // - else: $
-  //
-  // In full-path matching mode, we put the slash at the START of the
-  // pattern, so start is:
-  // - if first pattern: same as part-matching mode
-  // - if not isStart(): nothing
-  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
-  // - if dots allowed or not possible: /
-  // - if dots possible and not allowed: /(?!\.)
-  // end is:
-  // - if last pattern, same as part-matching mode
-  // - else nothing
-  //
-  // Always put the (?:$|/) on negated tails, though, because that has to be
-  // there to bind the end of the negated pattern portion, and it's easier to
-  // just stick it in now rather than try to inject it later in the middle of
-  // the pattern.
-  //
-  // We can just always return the same end, and leave it up to the caller
-  // to know whether it's going to be used joined or in parts.
-  // And, if the start is adjusted slightly, can do the same there:
-  // - if not isStart: nothing
-  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
-  // - if dots allowed or not possible: (?:/|^)
-  // - if dots possible and not allowed: (?:/|^)(?!\.)
-  //
-  // But it's better to have a simpler binding without a conditional, for
-  // performance, so probably better to return both start options.
-  //
-  // Then the caller just ignores the end if it's not the first pattern,
-  // and the start always gets applied.
-  //
-  // But that's always going to be $ if it's the ending pattern, or nothing,
-  // so the caller can just attach $ at the end of the pattern when building.
-  //
-  // So the todo is:
-  // - better detect what kind of start is needed
-  // - return both flavors of starting pattern
-  // - attach $ at the end of the pattern when creating the actual RegExp
-  //
-  // Ah, but wait, no, that all only applies to the root when the first pattern
-  // is not an extglob. If the first pattern IS an extglob, then we need all
-  // that dot prevention biz to live in the extglob portions, because eg
-  // +(*|.x*) can match .xy but not .yx.
-  //
-  // So, return the two flavors if it's #root and the first child is not an
-  // AST, otherwise leave it to the child AST to handle it, and there,
-  // use the (?:^|/) style of start binding.
-  //
-  // Even simplified further:
-  // - Since the start for a join is eg /(?!\.) and the start for a part
-  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
-  // or start or whatever) and prepend ^ or / at the Regexp construction.
-  toRegExpSource(allowDot) {
-    const dot = allowDot ?? !!this.#options.dot;
-    if (this.#root === this)
-      this.#fillNegs();
-    if (!this.type) {
-      const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
-      const src = this.#parts.map((p) => {
-        const [re, _, hasMagic, uflag] = typeof p === "string" ? _AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
-        this.#hasMagic = this.#hasMagic || hasMagic;
-        this.#uflag = this.#uflag || uflag;
-        return re;
-      }).join("");
-      let start2 = "";
-      if (this.isStart()) {
-        if (typeof this.#parts[0] === "string") {
-          const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
-          if (!dotTravAllowed) {
-            const aps = addPatternStart;
-            const needNoTrav = (
-              // dots are allowed, and the pattern starts with [ or .
-              dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
-              src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
-              src.startsWith("\\.\\.") && aps.has(src.charAt(4))
-            );
-            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
-            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
-          }
-        }
-      }
-      let end = "";
-      if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
-        end = "(?:$|\\/)";
-      }
-      const final2 = start2 + src + end;
-      return [
-        final2,
-        unescape2(src),
-        this.#hasMagic = !!this.#hasMagic,
-        this.#uflag
-      ];
-    }
-    const repeated = this.type === "*" || this.type === "+";
-    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
-    let body = this.#partsToRegExp(dot);
-    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
-      const s = this.toString();
-      this.#parts = [s];
-      this.type = null;
-      this.#hasMagic = void 0;
-      return [s, unescape2(this.toString()), false, false];
-    }
-    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
-    if (bodyDotAllowed === body) {
-      bodyDotAllowed = "";
-    }
-    if (bodyDotAllowed) {
-      body = `(?:${body})(?:${bodyDotAllowed})*?`;
-    }
-    let final = "";
-    if (this.type === "!" && this.#emptyExt) {
-      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
-    } else {
-      const close = this.type === "!" ? (
-        // !() must match something,but !(x) can match ''
-        "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
-      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
-      final = start + body + close;
-    }
-    return [
-      final,
-      unescape2(body),
-      this.#hasMagic = !!this.#hasMagic,
-      this.#uflag
-    ];
-  }
-  #partsToRegExp(dot) {
-    return this.#parts.map((p) => {
-      if (typeof p === "string") {
-        throw new Error("string type in extglob ast??");
-      }
-      const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
-      this.#uflag = this.#uflag || uflag;
-      return re;
-    }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
-  }
-  static #parseGlob(glob, hasMagic, noEmpty = false) {
-    let escaping = false;
-    let re = "";
-    let uflag = false;
-    for (let i = 0; i < glob.length; i++) {
-      const c = glob.charAt(i);
-      if (escaping) {
-        escaping = false;
-        re += (reSpecials.has(c) ? "\\" : "") + c;
-        continue;
-      }
-      if (c === "\\") {
-        if (i === glob.length - 1) {
-          re += "\\\\";
-        } else {
-          escaping = true;
-        }
-        continue;
-      }
-      if (c === "[") {
-        const [src, needUflag, consumed, magic] = parseClass(glob, i);
-        if (consumed) {
-          re += src;
-          uflag = uflag || needUflag;
-          i += consumed - 1;
-          hasMagic = hasMagic || magic;
-          continue;
-        }
-      }
-      if (c === "*") {
-        re += noEmpty && glob === "*" ? starNoEmpty : star;
-        hasMagic = true;
-        continue;
-      }
-      if (c === "?") {
-        re += qmark;
-        hasMagic = true;
-        continue;
-      }
-      re += regExpEscape(c);
-    }
-    return [re, unescape2(glob), !!hasMagic, uflag];
-  }
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/escape.js
-var escape2 = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
-  if (magicalBraces) {
-    return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
-  }
-  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/index.js
-var minimatch = (p, pattern, options = {}) => {
-  assertValidPattern(pattern);
-  if (!options.nocomment && pattern.charAt(0) === "#") {
-    return false;
-  }
-  return new Minimatch(pattern, options).match(p);
-};
-var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
-var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
-var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
-var starDotExtTestNocase = (ext2) => {
-  ext2 = ext2.toLowerCase();
-  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
-};
-var starDotExtTestNocaseDot = (ext2) => {
-  ext2 = ext2.toLowerCase();
-  return (f) => f.toLowerCase().endsWith(ext2);
-};
-var starDotStarRE = /^\*+\.\*+$/;
-var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
-var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
-var dotStarRE = /^\.\*+$/;
-var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
-var starRE = /^\*+$/;
-var starTest = (f) => f.length !== 0 && !f.startsWith(".");
-var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
-var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
-var qmarksTestNocase = ([$0, ext2 = ""]) => {
-  const noext = qmarksTestNoExt([$0]);
-  if (!ext2)
-    return noext;
-  ext2 = ext2.toLowerCase();
-  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
-};
-var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
-  const noext = qmarksTestNoExtDot([$0]);
-  if (!ext2)
-    return noext;
-  ext2 = ext2.toLowerCase();
-  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
-};
-var qmarksTestDot = ([$0, ext2 = ""]) => {
-  const noext = qmarksTestNoExtDot([$0]);
-  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
-};
-var qmarksTest = ([$0, ext2 = ""]) => {
-  const noext = qmarksTestNoExt([$0]);
-  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
-};
-var qmarksTestNoExt = ([$0]) => {
-  const len = $0.length;
-  return (f) => f.length === len && !f.startsWith(".");
-};
-var qmarksTestNoExtDot = ([$0]) => {
-  const len = $0.length;
-  return (f) => f.length === len && f !== "." && f !== "..";
-};
-var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path = {
-  win32: { sep: "\\" },
-  posix: { sep: "/" }
-};
-var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
-minimatch.sep = sep;
-var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
-minimatch.GLOBSTAR = GLOBSTAR;
-var qmark2 = "[^/]";
-var star2 = qmark2 + "*?";
-var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
-var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
-var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
-minimatch.filter = filter;
-var ext = (a, b = {}) => Object.assign({}, a, b);
-var defaults = (def) => {
-  if (!def || typeof def !== "object" || !Object.keys(def).length) {
-    return minimatch;
-  }
-  const orig = minimatch;
-  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
-  return Object.assign(m, {
-    Minimatch: class Minimatch extends orig.Minimatch {
-      constructor(pattern, options = {}) {
-        super(pattern, ext(def, options));
-      }
-      static defaults(options) {
-        return orig.defaults(ext(def, options)).Minimatch;
-      }
-    },
-    AST: class AST extends orig.AST {
-      /* c8 ignore start */
-      constructor(type, parent, options = {}) {
-        super(type, parent, ext(def, options));
-      }
-      /* c8 ignore stop */
-      static fromGlob(pattern, options = {}) {
-        return orig.AST.fromGlob(pattern, ext(def, options));
-      }
-    },
-    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
-    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
-    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
-    defaults: (options) => orig.defaults(ext(def, options)),
-    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
-    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
-    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
-    sep: orig.sep,
-    GLOBSTAR
-  });
-};
-minimatch.defaults = defaults;
-var braceExpand = (pattern, options = {}) => {
-  assertValidPattern(pattern);
-  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
-    return [pattern];
-  }
-  return expand(pattern);
-};
-minimatch.braceExpand = braceExpand;
-var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
-minimatch.makeRe = makeRe;
-var match = (list, pattern, options = {}) => {
-  const mm = new Minimatch(pattern, options);
-  list = list.filter((f) => mm.match(f));
-  if (mm.options.nonull && !list.length) {
-    list.push(pattern);
-  }
-  return list;
-};
-minimatch.match = match;
-var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
-var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-var Minimatch = class {
-  options;
-  set;
-  pattern;
-  windowsPathsNoEscape;
-  nonegate;
-  negate;
-  comment;
-  empty;
-  preserveMultipleSlashes;
-  partial;
-  globSet;
-  globParts;
-  nocase;
-  isWindows;
-  platform;
-  windowsNoMagicRoot;
-  regexp;
-  constructor(pattern, options = {}) {
-    assertValidPattern(pattern);
-    options = options || {};
-    this.options = options;
-    this.pattern = pattern;
-    this.platform = options.platform || defaultPlatform;
-    this.isWindows = this.platform === "win32";
-    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
-    if (this.windowsPathsNoEscape) {
-      this.pattern = this.pattern.replace(/\\/g, "/");
-    }
-    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
-    this.regexp = null;
-    this.negate = false;
-    this.nonegate = !!options.nonegate;
-    this.comment = false;
-    this.empty = false;
-    this.partial = !!options.partial;
-    this.nocase = !!this.options.nocase;
-    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
-    this.globSet = [];
-    this.globParts = [];
-    this.set = [];
-    this.make();
-  }
-  hasMagic() {
-    if (this.options.magicalBraces && this.set.length > 1) {
-      return true;
-    }
-    for (const pattern of this.set) {
-      for (const part of pattern) {
-        if (typeof part !== "string")
-          return true;
-      }
-    }
-    return false;
-  }
-  debug(..._) {
-  }
-  make() {
-    const pattern = this.pattern;
-    const options = this.options;
-    if (!options.nocomment && pattern.charAt(0) === "#") {
-      this.comment = true;
-      return;
-    }
-    if (!pattern) {
-      this.empty = true;
-      return;
-    }
-    this.parseNegate();
-    this.globSet = [...new Set(this.braceExpand())];
-    if (options.debug) {
-      this.debug = (...args) => console.error(...args);
-    }
-    this.debug(this.pattern, this.globSet);
-    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
-    this.globParts = this.preprocess(rawGlobParts);
-    this.debug(this.pattern, this.globParts);
-    let set2 = this.globParts.map((s, _, __) => {
-      if (this.isWindows && this.windowsNoMagicRoot) {
-        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
-        const isDrive = /^[a-z]:/i.test(s[0]);
-        if (isUNC) {
-          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
-        } else if (isDrive) {
-          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
-        }
-      }
-      return s.map((ss) => this.parse(ss));
-    });
-    this.debug(this.pattern, set2);
-    this.set = set2.filter((s) => s.indexOf(false) === -1);
-    if (this.isWindows) {
-      for (let i = 0; i < this.set.length; i++) {
-        const p = this.set[i];
-        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
-          p[2] = "?";
-        }
-      }
-    }
-    this.debug(this.pattern, this.set);
-  }
-  // various transforms to equivalent pattern sets that are
-  // faster to process in a filesystem walk.  The goal is to
-  // eliminate what we can, and push all ** patterns as far
-  // to the right as possible, even if it increases the number
-  // of patterns that we have to process.
-  preprocess(globParts) {
-    if (this.options.noglobstar) {
-      for (let i = 0; i < globParts.length; i++) {
-        for (let j = 0; j < globParts[i].length; j++) {
-          if (globParts[i][j] === "**") {
-            globParts[i][j] = "*";
-          }
-        }
-      }
-    }
-    const { optimizationLevel = 1 } = this.options;
-    if (optimizationLevel >= 2) {
-      globParts = this.firstPhasePreProcess(globParts);
-      globParts = this.secondPhasePreProcess(globParts);
-    } else if (optimizationLevel >= 1) {
-      globParts = this.levelOneOptimize(globParts);
-    } else {
-      globParts = this.adjascentGlobstarOptimize(globParts);
-    }
-    return globParts;
-  }
-  // just get rid of adjascent ** portions
-  adjascentGlobstarOptimize(globParts) {
-    return globParts.map((parts) => {
-      let gs = -1;
-      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
-        let i = gs;
-        while (parts[i + 1] === "**") {
-          i++;
-        }
-        if (i !== gs) {
-          parts.splice(gs, i - gs);
-        }
-      }
-      return parts;
-    });
-  }
-  // get rid of adjascent ** and resolve .. portions
-  levelOneOptimize(globParts) {
-    return globParts.map((parts) => {
-      parts = parts.reduce((set2, part) => {
-        const prev = set2[set2.length - 1];
-        if (part === "**" && prev === "**") {
-          return set2;
-        }
-        if (part === "..") {
-          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
-            set2.pop();
-            return set2;
-          }
-        }
-        set2.push(part);
-        return set2;
-      }, []);
-      return parts.length === 0 ? [""] : parts;
-    });
-  }
-  levelTwoFileOptimize(parts) {
-    if (!Array.isArray(parts)) {
-      parts = this.slashSplit(parts);
-    }
-    let didSomething = false;
-    do {
-      didSomething = false;
-      if (!this.preserveMultipleSlashes) {
-        for (let i = 1; i < parts.length - 1; i++) {
-          const p = parts[i];
-          if (i === 1 && p === "" && parts[0] === "")
-            continue;
-          if (p === "." || p === "") {
-            didSomething = true;
-            parts.splice(i, 1);
-            i--;
-          }
-        }
-        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
-          didSomething = true;
-          parts.pop();
-        }
-      }
-      let dd = 0;
-      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
-        const p = parts[dd - 1];
-        if (p && p !== "." && p !== ".." && p !== "**") {
-          didSomething = true;
-          parts.splice(dd - 1, 2);
-          dd -= 2;
-        }
-      }
-    } while (didSomething);
-    return parts.length === 0 ? [""] : parts;
-  }
-  // First phase: single-pattern processing
-  // <pre> is 1 or more portions
-  // <rest> is 1 or more portions
-  // <p> is any portion other than ., .., '', or **
-  // <e> is . or ''
-  //
-  // **/.. is *brutal* for filesystem walking performance, because
-  // it effectively resets the recursive walk each time it occurs,
-  // and ** cannot be reduced out by a .. pattern part like a regexp
-  // or most strings (other than .., ., and '') can be.
-  //
-  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
-  // <pre>/<e>/<rest> -> <pre>/<rest>
-  // <pre>/<p>/../<rest> -> <pre>/<rest>
-  // **/**/<rest> -> **/<rest>
-  //
-  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
-  // this WOULD be allowed if ** did follow symlinks, or * didn't
-  firstPhasePreProcess(globParts) {
-    let didSomething = false;
-    do {
-      didSomething = false;
-      for (let parts of globParts) {
-        let gs = -1;
-        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
-          let gss = gs;
-          while (parts[gss + 1] === "**") {
-            gss++;
-          }
-          if (gss > gs) {
-            parts.splice(gs + 1, gss - gs);
-          }
-          let next = parts[gs + 1];
-          const p = parts[gs + 2];
-          const p2 = parts[gs + 3];
-          if (next !== "..")
-            continue;
-          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
-            continue;
-          }
-          didSomething = true;
-          parts.splice(gs, 1);
-          const other = parts.slice(0);
-          other[gs] = "**";
-          globParts.push(other);
-          gs--;
-        }
-        if (!this.preserveMultipleSlashes) {
-          for (let i = 1; i < parts.length - 1; i++) {
-            const p = parts[i];
-            if (i === 1 && p === "" && parts[0] === "")
-              continue;
-            if (p === "." || p === "") {
-              didSomething = true;
-              parts.splice(i, 1);
-              i--;
-            }
-          }
-          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
-            didSomething = true;
-            parts.pop();
-          }
-        }
-        let dd = 0;
-        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
-          const p = parts[dd - 1];
-          if (p && p !== "." && p !== ".." && p !== "**") {
-            didSomething = true;
-            const needDot = dd === 1 && parts[dd + 1] === "**";
-            const splin = needDot ? ["."] : [];
-            parts.splice(dd - 1, 2, ...splin);
-            if (parts.length === 0)
-              parts.push("");
-            dd -= 2;
-          }
-        }
-      }
-    } while (didSomething);
-    return globParts;
-  }
-  // second phase: multi-pattern dedupes
-  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
-  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
-  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
-  //
-  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
-  // ^-- not valid because ** doens't follow symlinks
-  secondPhasePreProcess(globParts) {
-    for (let i = 0; i < globParts.length - 1; i++) {
-      for (let j = i + 1; j < globParts.length; j++) {
-        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
-        if (matched) {
-          globParts[i] = [];
-          globParts[j] = matched;
-          break;
-        }
-      }
-    }
-    return globParts.filter((gs) => gs.length);
-  }
-  partsMatch(a, b, emptyGSMatch = false) {
-    let ai = 0;
-    let bi = 0;
-    let result = [];
-    let which = "";
-    while (ai < a.length && bi < b.length) {
-      if (a[ai] === b[bi]) {
-        result.push(which === "b" ? b[bi] : a[ai]);
-        ai++;
-        bi++;
-      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
-        result.push(a[ai]);
-        ai++;
-      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
-        result.push(b[bi]);
-        bi++;
-      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
-        if (which === "b")
-          return false;
-        which = "a";
-        result.push(a[ai]);
-        ai++;
-        bi++;
-      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
-        if (which === "a")
-          return false;
-        which = "b";
-        result.push(b[bi]);
-        ai++;
-        bi++;
-      } else {
-        return false;
-      }
-    }
-    return a.length === b.length && result;
-  }
-  parseNegate() {
-    if (this.nonegate)
-      return;
-    const pattern = this.pattern;
-    let negate = false;
-    let negateOffset = 0;
-    for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
-      negate = !negate;
-      negateOffset++;
-    }
-    if (negateOffset)
-      this.pattern = pattern.slice(negateOffset);
-    this.negate = negate;
-  }
-  // set partial to true to test if, for example,
-  // "/a/b" matches the start of "/*/b/*/d"
-  // Partial means, if you run out of file before you run
-  // out of pattern, then that's fine, as long as all
-  // the parts match.
-  matchOne(file2, pattern, partial2 = false) {
-    const options = this.options;
-    if (this.isWindows) {
-      const fileDrive = typeof file2[0] === "string" && /^[a-z]:$/i.test(file2[0]);
-      const fileUNC = !fileDrive && file2[0] === "" && file2[1] === "" && file2[2] === "?" && /^[a-z]:$/i.test(file2[3]);
-      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
-      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
-      const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
-      const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
-      if (typeof fdi === "number" && typeof pdi === "number") {
-        const [fd, pd] = [file2[fdi], pattern[pdi]];
-        if (fd.toLowerCase() === pd.toLowerCase()) {
-          pattern[pdi] = fd;
-          if (pdi > fdi) {
-            pattern = pattern.slice(pdi);
-          } else if (fdi > pdi) {
-            file2 = file2.slice(fdi);
-          }
-        }
-      }
-    }
-    const { optimizationLevel = 1 } = this.options;
-    if (optimizationLevel >= 2) {
-      file2 = this.levelTwoFileOptimize(file2);
-    }
-    this.debug("matchOne", this, { file: file2, pattern });
-    this.debug("matchOne", file2.length, pattern.length);
-    for (var fi = 0, pi = 0, fl = file2.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
-      this.debug("matchOne loop");
-      var p = pattern[pi];
-      var f = file2[fi];
-      this.debug(pattern, p, f);
-      if (p === false) {
-        return false;
-      }
-      if (p === GLOBSTAR) {
-        this.debug("GLOBSTAR", [pattern, p, f]);
-        var fr = fi;
-        var pr = pi + 1;
-        if (pr === pl) {
-          this.debug("** at the end");
-          for (; fi < fl; fi++) {
-            if (file2[fi] === "." || file2[fi] === ".." || !options.dot && file2[fi].charAt(0) === ".")
-              return false;
-          }
-          return true;
-        }
-        while (fr < fl) {
-          var swallowee = file2[fr];
-          this.debug("\nglobstar while", file2, fr, pattern, pr, swallowee);
-          if (this.matchOne(file2.slice(fr), pattern.slice(pr), partial2)) {
-            this.debug("globstar found match!", fr, fl, swallowee);
-            return true;
-          } else {
-            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
-              this.debug("dot detected!", file2, fr, pattern, pr);
-              break;
-            }
-            this.debug("globstar swallow a segment, and continue");
-            fr++;
-          }
-        }
-        if (partial2) {
-          this.debug("\n>>> no match, partial?", file2, fr, pattern, pr);
-          if (fr === fl) {
-            return true;
-          }
-        }
-        return false;
-      }
-      let hit;
-      if (typeof p === "string") {
-        hit = f === p;
-        this.debug("string match", p, f, hit);
-      } else {
-        hit = p.test(f);
-        this.debug("pattern match", p, f, hit);
-      }
-      if (!hit)
-        return false;
-    }
-    if (fi === fl && pi === pl) {
-      return true;
-    } else if (fi === fl) {
-      return partial2;
-    } else if (pi === pl) {
-      return fi === fl - 1 && file2[fi] === "";
-    } else {
-      throw new Error("wtf?");
-    }
-  }
-  braceExpand() {
-    return braceExpand(this.pattern, this.options);
-  }
-  parse(pattern) {
-    assertValidPattern(pattern);
-    const options = this.options;
-    if (pattern === "**")
-      return GLOBSTAR;
-    if (pattern === "")
-      return "";
-    let m;
-    let fastTest = null;
-    if (m = pattern.match(starRE)) {
-      fastTest = options.dot ? starTestDot : starTest;
-    } else if (m = pattern.match(starDotExtRE)) {
-      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
-    } else if (m = pattern.match(qmarksRE)) {
-      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
-    } else if (m = pattern.match(starDotStarRE)) {
-      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
-    } else if (m = pattern.match(dotStarRE)) {
-      fastTest = dotStarTest;
-    }
-    const re = AST.fromGlob(pattern, this.options).toMMPattern();
-    if (fastTest && typeof re === "object") {
-      Reflect.defineProperty(re, "test", { value: fastTest });
-    }
-    return re;
-  }
-  makeRe() {
-    if (this.regexp || this.regexp === false)
-      return this.regexp;
-    const set2 = this.set;
-    if (!set2.length) {
-      this.regexp = false;
-      return this.regexp;
-    }
-    const options = this.options;
-    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
-    const flags = new Set(options.nocase ? ["i"] : []);
-    let re = set2.map((pattern) => {
-      const pp = pattern.map((p) => {
-        if (p instanceof RegExp) {
-          for (const f of p.flags.split(""))
-            flags.add(f);
-        }
-        return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
-      });
-      pp.forEach((p, i) => {
-        const next = pp[i + 1];
-        const prev = pp[i - 1];
-        if (p !== GLOBSTAR || prev === GLOBSTAR) {
-          return;
-        }
-        if (prev === void 0) {
-          if (next !== void 0 && next !== GLOBSTAR) {
-            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
-          } else {
-            pp[i] = twoStar;
-          }
-        } else if (next === void 0) {
-          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
-        } else if (next !== GLOBSTAR) {
-          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
-          pp[i + 1] = GLOBSTAR;
-        }
-      });
-      const filtered = pp.filter((p) => p !== GLOBSTAR);
-      if (this.partial && filtered.length >= 1) {
-        const prefixes = [];
-        for (let i = 1; i <= filtered.length; i++) {
-          prefixes.push(filtered.slice(0, i).join("/"));
-        }
-        return "(?:" + prefixes.join("|") + ")";
-      }
-      return filtered.join("/");
-    }).join("|");
-    const [open, close] = set2.length > 1 ? ["(?:", ")"] : ["", ""];
-    re = "^" + open + re + close + "$";
-    if (this.partial) {
-      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
-    }
-    if (this.negate)
-      re = "^(?!" + re + ").+$";
-    try {
-      this.regexp = new RegExp(re, [...flags].join(""));
-    } catch (ex) {
-      this.regexp = false;
-    }
-    return this.regexp;
-  }
-  slashSplit(p) {
-    if (this.preserveMultipleSlashes) {
-      return p.split("/");
-    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
-      return ["", ...p.split(/\/+/)];
-    } else {
-      return p.split(/\/+/);
-    }
-  }
-  match(f, partial2 = this.partial) {
-    this.debug("match", f, this.pattern);
-    if (this.comment) {
-      return false;
-    }
-    if (this.empty) {
-      return f === "";
-    }
-    if (f === "/" && partial2) {
-      return true;
-    }
-    const options = this.options;
-    if (this.isWindows) {
-      f = f.split("\\").join("/");
-    }
-    const ff = this.slashSplit(f);
-    this.debug(this.pattern, "split", ff);
-    const set2 = this.set;
-    this.debug(this.pattern, "set", set2);
-    let filename = ff[ff.length - 1];
-    if (!filename) {
-      for (let i = ff.length - 2; !filename && i >= 0; i--) {
-        filename = ff[i];
-      }
-    }
-    for (let i = 0; i < set2.length; i++) {
-      const pattern = set2[i];
-      let file2 = ff;
-      if (options.matchBase && pattern.length === 1) {
-        file2 = [filename];
-      }
-      const hit = this.matchOne(file2, pattern, partial2);
-      if (hit) {
-        if (options.flipNegate) {
-          return true;
-        }
-        return !this.negate;
-      }
-    }
-    if (options.flipNegate) {
-      return false;
-    }
-    return this.negate;
-  }
-  static defaults(def) {
-    return minimatch.defaults(def).Minimatch;
-  }
-};
-minimatch.AST = AST;
-minimatch.Minimatch = Minimatch;
-minimatch.escape = escape2;
-minimatch.unescape = unescape2;
-
-// ../riviere-extract-ts/dist/platform/infra/external-clients/minimatch/minimatch-glob.js
-function matchesGlob(path2, pattern) {
-  return minimatch(path2, pattern);
-}
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/detect-connections.js
-import { performance } from "node:perf_hooks";
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/call-graph-types.js
-function componentIdentity(component) {
-  return ComponentId.create({
-    domain: component.domain,
-    module: component.module,
-    type: component.type,
-    name: component.name
-  }).toString();
-}
-function stripGenericArgs(typeName) {
-  const index = typeName.indexOf("<");
-  if (index === -1) {
-    return typeName;
-  }
-  return typeName.slice(0, index);
-}
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/component-index.js
-function locationKey(file2, line) {
-  return `${file2}:${line}`;
-}
-var ComponentIndex = class {
-  byName;
-  byLocation;
-  constructor(components) {
-    const nameMap = /* @__PURE__ */ new Map();
-    const locationMap = /* @__PURE__ */ new Map();
-    for (const component of components) {
-      nameMap.set(component.name, component);
-      locationMap.set(locationKey(component.location.file, component.location.line), component);
-    }
-    this.byName = nameMap;
-    this.byLocation = locationMap;
-  }
-  isComponent(typeName) {
-    return this.byName.has(stripGenericArgs(typeName));
-  }
-  getComponentByTypeName(typeName) {
-    return this.byName.get(stripGenericArgs(typeName));
-  }
-  getComponentByLocation(file2, line) {
-    return this.byLocation.get(locationKey(file2, line));
-  }
-};
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/build-call-graph.js
-import { Node as Node3, SyntaxKind as SyntaxKind6 } from "ts-morph";
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/trace-calls.js
-import { Node as Node2, SyntaxKind as SyntaxKind5 } from "ts-morph";
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/type-resolver.js
-import { CallExpression, SourceFile, Node } from "ts-morph";
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/connection-detection-error.js
-var ConnectionDetectionError = class extends Error {
-  file;
-  line;
-  typeName;
-  reason;
-  constructor(params) {
-    super(`Connection detection failed for ${params.typeName} at ${params.file}:${params.line}: ${params.reason}`);
-    this.name = "ConnectionDetectionError";
-    this.file = params.file;
-    this.line = params.line;
-    this.typeName = params.typeName;
-    this.reason = params.reason;
-  }
-};
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/type-resolver.js
-function stripGenerics(typeName) {
-  const angleBracketIndex = typeName.indexOf("<");
-  if (angleBracketIndex === -1)
-    return typeName;
-  return typeName.slice(0, angleBracketIndex);
-}
-function stripPromise(typeName) {
-  if (typeName.startsWith("Promise<") && typeName.endsWith(">")) {
-    return typeName.slice(8, -1);
-  }
-  return typeName;
+  return typeName;
 }
 var UNRESOLVABLE_TYPES = /* @__PURE__ */ new Set(["any", "unknown", "object"]);
 function isUnresolvableType(typeName) {
@@ -28310,10 +26551,7 @@ function handleUnresolvable(sourceFile, callExpression, rawTypeName, options) {
   if (options.strict) {
     throw buildError(sourceFile, callExpression, rawTypeName, reason);
   }
-  return {
-    resolved: false,
-    reason
-  };
+  return TypeResolution.unresolved(reason);
 }
 function resolveCallExpressionReceiverType(callExpression, sourceFile, options) {
   const receiver = getReceiverExpression(callExpression);
@@ -28322,26 +26560,68 @@ function resolveCallExpressionReceiverType(callExpression, sourceFile, options)
     if (options.strict) {
       throw buildError(sourceFile, callExpression, "unknown", reason);
     }
-    return {
-      resolved: false,
-      reason
-    };
+    return TypeResolution.unresolved(reason);
   }
   const rawTypeName = resolveReceiverTypeName(receiver);
   if (isUnresolvableType(rawTypeName)) {
     return handleUnresolvable(sourceFile, callExpression, rawTypeName, options);
   }
-  return {
-    resolved: true,
-    typeName: stripGenerics(rawTypeName)
-  };
+  return TypeResolution.resolved(stripGenerics(rawTypeName));
 }
 
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/call-graph-shared.js
-import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/call-graph-outcomes.js
+var InterfaceResolutionOutcome = class {
+  component;
+  resolvedTypeName;
+  uncertain;
+  constructor(params) {
+    this.component = params.component;
+    this.resolvedTypeName = params.resolvedTypeName;
+    this.uncertain = params.uncertain;
+  }
+};
+var MethodLookup = class {
+  method;
+  classFound;
+  constructor(params) {
+    this.method = params.method;
+    this.classFound = params.classFound;
+  }
+};
 
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/interface-resolution/resolve-interface.js
 import { Project, ClassDeclaration, SourceFile as SourceFile2 } from "ts-morph";
+var InterfaceResolution = class _InterfaceResolution {
+  resolved;
+  typeName;
+  reason;
+  typeDefinedInSource;
+  constructor(params) {
+    this.resolved = params.resolved;
+    this.typeName = params.typeName;
+    this.reason = params.reason;
+    this.typeDefinedInSource = params.typeDefinedInSource;
+  }
+  static resolved(typeName) {
+    return new _InterfaceResolution({
+      resolved: true,
+      typeName,
+      reason: void 0,
+      typeDefinedInSource: void 0
+    });
+  }
+  static unresolved(params) {
+    return new _InterfaceResolution({
+      resolved: false,
+      typeName: void 0,
+      reason: params.reason,
+      typeDefinedInSource: params.typeDefinedInSource
+    });
+  }
+};
 function isNodeModulesPath(filePath) {
   return filePath.includes("node_modules");
 }
@@ -28384,10 +26664,7 @@ function resolveInterface(interfaceName, project, sourceFilePaths, options) {
   const implementations = findImplementations(interfaceName, sourceFiles);
   const [singleImpl] = implementations;
   if (implementations.length === 1 && singleImpl) {
-    return {
-      resolved: true,
-      typeName: singleImpl
-    };
+    return InterfaceResolution.resolved(singleImpl);
   }
   if (implementations.length === 0) {
     const definedInSource = isDefinedInSourceFiles(interfaceName, sourceFiles);
@@ -28395,50 +26672,56 @@ function resolveInterface(interfaceName, project, sourceFilePaths, options) {
     if (definedInSource && options.strict) {
       throw createError(interfaceName, reason2);
     }
-    return {
-      resolved: false,
+    return InterfaceResolution.unresolved({
       reason: reason2,
       typeDefinedInSource: definedInSource
-    };
+    });
   }
   const reason = `Multiple implementations found for ${interfaceName} (${implementations.length}): ${implementations.join(", ")}`;
   if (options.strict) {
     throw createError(interfaceName, reason);
   }
-  return {
-    resolved: false,
+  return InterfaceResolution.unresolved({
     reason,
     typeDefinedInSource: true
-  };
+  });
 }
 
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/call-graph-shared.js
 function getCalledMethodName(callExpr) {
   const expression = callExpr.getExpression();
-  return expression.asKindOrThrow(SyntaxKind4.PropertyAccessExpression).getName();
+  return expression.asKindOrThrow(SyntaxKind2.PropertyAccessExpression).getName();
 }
 function resolveTypeThroughInterface(typeName, project, componentIndex, options) {
   const component = componentIndex.getComponentByTypeName(typeName);
   if (component !== void 0) {
-    return {
+    return new InterfaceResolutionOutcome({
       component,
       resolvedTypeName: void 0,
       uncertain: void 0
-    };
+    });
   }
   const interfaceResult = resolveInterface(typeName, project, options.sourceFilePaths, { strict: options.strict });
   if (interfaceResult.resolved) {
-    return {
-      component: componentIndex.getComponentByTypeName(interfaceResult.typeName),
-      resolvedTypeName: interfaceResult.typeName,
+    const resolvedTypeName = requireInterfaceTypeName(interfaceResult);
+    return new InterfaceResolutionOutcome({
+      component: componentIndex.getComponentByTypeName(resolvedTypeName),
+      resolvedTypeName,
       uncertain: void 0
-    };
+    });
   }
-  return {
+  return new InterfaceResolutionOutcome({
     component: void 0,
     resolvedTypeName: void 0,
     uncertain: interfaceResult.typeDefinedInSource ? interfaceResult.reason : void 0
-  };
+  });
+}
+function requireInterfaceTypeName(interfaceResolution) {
+  const typeName = interfaceResolution.typeName;
+  if (typeName === void 0) {
+    throw new TypeError("Expected interface resolution type name");
+  }
+  return typeName;
 }
 function findClassByNameInProject(project, typeName) {
   for (const sourceFile of project.getSourceFiles()) {
@@ -28467,15 +26750,15 @@ function resolveContainerMethod(project, typeName, calledMethodName, componentIn
 function findMethodInProject(project, typeName, methodName) {
   const lookup = findClassByNameInProject(project, typeName);
   if (lookup === void 0) {
-    return {
+    return new MethodLookup({
       method: void 0,
       classFound: false
-    };
+    });
   }
-  return {
+  return new MethodLookup({
     method: lookup.classDecl.getMethod(methodName),
     classFound: true
-  };
+  });
 }
 
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/trace-calls.js
@@ -28504,16 +26787,16 @@ function traceCallExpression(callExpr, ctx) {
   if (!typeResult.resolved) {
     return;
   }
-  const typeName = typeResult.typeName;
+  const typeName = requireResolvedTypeName(typeResult);
   const calledMethodName = getCalledMethodName(callExpr);
   const outcome = resolveComponentTarget(typeName, calledMethodName, ctx);
   if (outcome.target !== void 0) {
     if (componentIdentity(ctx.sourceComponent) !== componentIdentity(outcome.target)) {
-      ctx.results.push({
+      ctx.results.push(new RawLink({
         source: ctx.sourceComponent,
         target: outcome.target,
         callSite: ctx.originCallSite
-      });
+      }));
     }
     return;
   }
@@ -28532,15 +26815,22 @@ function traceIntoNonComponent(typeName, calledMethodName, outcome, ctx) {
     return;
   }
   if (!classFound && outcome.uncertain !== void 0) {
-    ctx.uncertainResults.push({
+    ctx.uncertainResults.push(new UncertainRawLink({
       source: ctx.sourceComponent,
       reason: outcome.uncertain,
       callSite: ctx.originCallSite
-    });
+    }));
+  }
+}
+function requireResolvedTypeName(typeResolution) {
+  const typeName = typeResolution.typeName;
+  if (typeName === void 0) {
+    throw new TypeError("Expected resolved type name");
   }
+  return typeName;
 }
 function traceBody(body, ctx) {
-  const callExpressions = body.getDescendantsOfKind(SyntaxKind5.CallExpression);
+  const callExpressions = body.getDescendantsOfKind(SyntaxKind3.CallExpression);
   for (const callExpr of callExpressions) {
     traceCallExpression(callExpr, ctx);
   }
@@ -28572,10 +26862,10 @@ function findMethodLevelComponent(project, component) {
   for (const classDecl of sourceFile.getClasses()) {
     const method = classDecl.getMethods().find((m) => m.getStartLineNumber() === component.location.line);
     if (method !== void 0) {
-      return {
+      return new MethodLevelTarget({
         classDecl,
         method
-      };
+      });
     }
   }
   return void 0;
@@ -28588,12 +26878,34 @@ function findFunctionInProject(project, component) {
   return sourceFile.getFunctions().find((f) => f.getStartLineNumber() === component.location.line);
 }
 
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/extracted-link.js
+var ExtractedLink = class {
+  source;
+  target;
+  type;
+  _uncertain;
+  sourceLocation;
+  constructor(params) {
+    this.source = params.source;
+    this.target = params.target;
+    this.type = params.type;
+    this._uncertain = params._uncertain;
+    this.sourceLocation = params.sourceLocation;
+  }
+};
+
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/deduplicate-links.js
+var MissingSourceLocationError = class extends Error {
+  constructor() {
+    super("Expected sourceLocation on extracted link");
+    this.name = "MissingSourceLocationError";
+  }
+};
 function linkKey(source, target, type) {
   return `${source}|${target}|${type}`;
 }
 function buildExtractedLink(source, target, type, callSite, repository) {
-  return {
+  const link = new ExtractedLink({
     source,
     target,
     type,
@@ -28603,10 +26915,15 @@ function buildExtractedLink(source, target, type, callSite, repository) {
       lineNumber: callSite.lineNumber,
       methodName: callSite.methodName
     }
-  };
+  });
+  const sourceLocation = link.sourceLocation;
+  if (sourceLocation === void 0) {
+    throw new MissingSourceLocationError();
+  }
+  return link;
 }
 function buildUncertainLink(source, reason, callSite, repository) {
-  return {
+  return new ExtractedLink({
     source,
     target: "_unresolved",
     type: "sync",
@@ -28617,7 +26934,7 @@ function buildUncertainLink(source, reason, callSite, repository) {
       lineNumber: callSite.lineNumber,
       methodName: callSite.methodName
     }
-  };
+  });
 }
 function deduplicateLinks(rawLinks, uncertainLinks, repository = "") {
   const seen = /* @__PURE__ */ new Map();
@@ -28628,7 +26945,7 @@ function deduplicateLinks(rawLinks, uncertainLinks, repository = "") {
     const key = linkKey(sourceId, targetId, type);
     const existing = seen.get(key);
     if (existing !== void 0) {
-      if (raw.callSite.lineNumber < existing.sourceLocation.lineNumber) {
+      if (raw.callSite.lineNumber < requireSourceLocation(existing).lineNumber) {
         seen.set(key, buildExtractedLink(sourceId, targetId, type, raw.callSite, repository));
       }
       continue;
@@ -28641,6 +26958,24 @@ function deduplicateLinks(rawLinks, uncertainLinks, repository = "") {
   }
   return result;
 }
+function requireSourceLocation(link) {
+  const sourceLocation = link.sourceLocation;
+  if (sourceLocation === void 0) {
+    throw new MissingSourceLocationError();
+  }
+  if (sourceLocation.lineNumber === void 0) {
+    throw new MissingSourceLocationError();
+  }
+  if (sourceLocation.methodName === void 0) {
+    throw new MissingSourceLocationError();
+  }
+  return {
+    repository: sourceLocation.repository,
+    filePath: sourceLocation.filePath,
+    lineNumber: sourceLocation.lineNumber,
+    methodName: sourceLocation.methodName
+  };
+}
 
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/call-graph/build-call-graph.js
 function processCallExpression(callExpr, component, methodName, project, componentIndex, rawLinks, uncertainLinks, options) {
@@ -28649,55 +26984,65 @@ function processCallExpression(callExpr, component, methodName, project, compone
   }
   const sourceFile = callExpr.getSourceFile();
   const typeResult = resolveCallExpressionReceiverType(callExpr, sourceFile, { strict: options.strict });
-  const currentCallSite = {
+  const currentCallSite = new CallSite({
     filePath: component.location.file,
     lineNumber: callExpr.getStartLineNumber(),
     methodName
-  };
+  });
   if (!typeResult.resolved) {
-    uncertainLinks.push({
+    uncertainLinks.push(new UncertainRawLink({
       source: component,
-      reason: typeResult.reason,
+      reason: typeResult.reason ?? "Receiver type unresolved",
       callSite: currentCallSite
-    });
+    }));
     return;
   }
-  const typeName = typeResult.typeName;
+  const typeName = requireResolvedTypeName2(typeResult);
   const calledMethodName = getCalledMethodName(callExpr);
-  const { component: targetComponent, resolvedTypeName, uncertain } = resolveTypeThroughInterface(typeName, project, componentIndex, options);
+  const interfaceResolution = resolveTypeThroughInterface(typeName, project, componentIndex, options);
+  const targetComponent = interfaceResolution.component;
+  const resolvedTypeName = interfaceResolution.resolvedTypeName;
+  const uncertain = interfaceResolution.uncertain;
   if (targetComponent !== void 0) {
     if (componentIdentity(component) !== componentIdentity(targetComponent)) {
-      rawLinks.push({
+      rawLinks.push(new RawLink({
         source: component,
         target: targetComponent,
         callSite: currentCallSite
-      });
+      }));
     }
     return;
   }
   const containerTarget = resolveContainerMethod(project, resolvedTypeName ?? typeName, calledMethodName, componentIndex);
   if (containerTarget !== void 0) {
     if (componentIdentity(component) !== componentIdentity(containerTarget)) {
-      rawLinks.push({
+      rawLinks.push(new RawLink({
         source: component,
         target: containerTarget,
         callSite: currentCallSite
-      });
+      }));
     }
     return;
   }
   traceNonComponent(project, componentIndex, component, resolvedTypeName ?? typeName, calledMethodName, currentCallSite, rawLinks, uncertainLinks, uncertain, options);
 }
+function requireResolvedTypeName2(typeResolution) {
+  const typeName = typeResolution.typeName;
+  if (typeName === void 0) {
+    throw new TypeError("Expected resolved type name");
+  }
+  return typeName;
+}
 function processFunction(funcDecl, component, project, componentIndex, rawLinks, uncertainLinks, options) {
   const functionName = funcDecl.getNameOrThrow();
-  const callExpressions = funcDecl.getDescendantsOfKind(SyntaxKind6.CallExpression);
+  const callExpressions = funcDecl.getDescendantsOfKind(SyntaxKind4.CallExpression);
   for (const callExpr of callExpressions) {
     processCallExpression(callExpr, component, functionName, project, componentIndex, rawLinks, uncertainLinks, options);
   }
 }
 function processMethod(method, component, project, componentIndex, rawLinks, uncertainLinks, options) {
   const methodName = method.getName();
-  const callExpressions = method.getDescendantsOfKind(SyntaxKind6.CallExpression);
+  const callExpressions = method.getDescendantsOfKind(SyntaxKind4.CallExpression);
   for (const callExpr of callExpressions) {
     processCallExpression(callExpr, component, methodName, project, componentIndex, rawLinks, uncertainLinks, options);
   }
@@ -28734,11 +27079,11 @@ function traceNonComponent(project, componentIndex, source, typeName, calledMeth
     return;
   }
   if (!classFound && interfaceUncertainty !== void 0) {
-    uncertainLinks.push({
+    uncertainLinks.push(new UncertainRawLink({
       source,
       reason: interfaceUncertainty,
       callSite
-    });
+    }));
   }
 }
 
@@ -28785,13 +27130,13 @@ function handleMissingMetadata(publisher, metadataKey, options) {
       reason: `published event type in "${metadataKey}" metadata is missing or invalid`
     });
   }
-  return {
+  return new ExtractedLink({
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
     sourceLocation: toSourceLocation(publisher, options.repository),
     _uncertain: `event publisher "${publisher.name}" is missing required "${metadataKey}" metadata`
-  };
+  });
 }
 function resolvePublishTarget(publisher, publishedEventType, events, options) {
   const matchingEvents = events.filter((e) => e.metadata[EVENT_NAME_FIELD] === publishedEventType);
@@ -28801,7 +27146,7 @@ function resolvePublishTarget(publisher, publishedEventType, events, options) {
   if (matchingEvents.length > 1) {
     return [handleAmbiguousMatch(publisher, publishedEventType, matchingEvents.length, options)];
   }
-  return matchingEvents.map((event) => ({
+  return matchingEvents.map((event) => new ExtractedLink({
     source: componentIdentity(publisher),
     target: componentIdentity(event),
     type: "async",
@@ -28817,13 +27162,13 @@ function handleAmbiguousMatch(publisher, publishedEventType, matchCount, options
       reason: `published event "${publishedEventType}" matches ${matchCount} Event components (ambiguous)`
     });
   }
-  return {
+  return new ExtractedLink({
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
     sourceLocation: toSourceLocation(publisher, options.repository),
     _uncertain: `ambiguous: ${matchCount} events match published event type: ${publishedEventType}`
-  };
+  });
 }
 function handleNoMatch(publisher, publishedEventType, options) {
   if (options.strict) {
@@ -28834,13 +27179,13 @@ function handleNoMatch(publisher, publishedEventType, options) {
       reason: `published event "${publishedEventType}" does not match any Event component`
     });
   }
-  return {
+  return new ExtractedLink({
     source: componentIdentity(publisher),
     target: "_unresolved",
     type: "async",
     sourceLocation: toSourceLocation(publisher, options.repository),
     _uncertain: `no event found for published event type: ${publishedEventType}`
-  };
+  });
 }
 
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/detect-subscribe-connections.js
@@ -28858,7 +27203,7 @@ function resolveSubscription(handler, eventName, events, options, repository) {
   if (matchingEvents.length > 1) {
     return [handleAmbiguousMatch2(handler, eventName, matchingEvents.length, options, repository)];
   }
-  return matchingEvents.map((event) => ({
+  return matchingEvents.map((event) => new ExtractedLink({
     source: componentIdentity(event),
     target: componentIdentity(handler),
     type: "async",
@@ -28874,13 +27219,13 @@ function handleAmbiguousMatch2(handler, eventName, matchCount, options, reposito
       reason: `subscribed event "${eventName}" matches ${matchCount} Event components (ambiguous)`
     });
   }
-  return {
+  return new ExtractedLink({
     source: "_unresolved",
     target: componentIdentity(handler),
     type: "async",
     sourceLocation: toSourceLocation(handler, repository),
     _uncertain: `ambiguous: ${matchCount} events match subscribed event name: ${eventName}`
-  };
+  });
 }
 function handleNoMatch2(handler, eventName, options, repository) {
   if (options.strict) {
@@ -28891,13 +27236,13 @@ function handleNoMatch2(handler, eventName, options, repository) {
       reason: `subscribed event "${eventName}" does not match any Event component`
     });
   }
-  return {
+  return new ExtractedLink({
     source: "_unresolved",
     target: componentIdentity(handler),
     type: "async",
     sourceLocation: toSourceLocation(handler, repository),
     _uncertain: `no event found for subscribed event name: ${eventName}`
-  };
+  });
 }
 function getSubscribedEvents(handler) {
   const raw = handler.metadata[SUBSCRIBED_EVENTS_FIELD];
@@ -28907,13 +27252,57 @@ function getSubscribedEvents(handler) {
   return raw.filter((item) => typeof item === "string");
 }
 
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/connection-detection-values.js
+function assignLinkCollections(target, params) {
+  target.links = params.links;
+  target.externalLinks = params.externalLinks;
+  target.timings = params.timings;
+}
+var PerModuleTimings = class {
+  callGraphMs;
+  setupMs;
+  constructor(params) {
+    this.callGraphMs = params.callGraphMs;
+    this.setupMs = params.setupMs;
+  }
+};
+var PerModuleDetectionResult = class {
+  constructor(params) {
+    assignLinkCollections(this, params);
+  }
+};
+var CrossModuleTimings = class {
+  asyncDetectionMs;
+  constructor(params) {
+    this.asyncDetectionMs = params.asyncDetectionMs;
+  }
+};
+var CrossModuleDetectionResult = class {
+  links;
+  timings;
+  constructor(params) {
+    this.links = params.links;
+    this.timings = params.timings;
+  }
+};
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/http-link-resolution-result.js
+var HttpLinkResolutionResult = class {
+  links;
+  externalLinks;
+  constructor(params) {
+    this.links = params.links;
+    this.externalLinks = params.externalLinks;
+  }
+};
+
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/resolve-http-links.js
 function resolveHttpLinks(links, components, httpLinkConfigs) {
   if (httpLinkConfigs.length === 0) {
-    return {
+    return new HttpLinkResolutionResult({
       links: [...links],
       externalLinks: []
-    };
+    });
   }
   const resolvedCustomTypes = new Set(httpLinkConfigs.map((config2) => config2.fromCustomType));
   const componentsByIdentity = indexComponentsByIdentity(components);
@@ -28940,15 +27329,18 @@ function resolveHttpLinks(links, components, httpLinkConfigs) {
       externalLinks.push(toExternalLink(link, domainName, targetComponent, config2.matchApiBy));
       continue;
     }
-    resolvedLinks.push({
-      ...link,
-      target: componentIdentity(matchedApi)
-    });
+    resolvedLinks.push(new ExtractedLink({
+      source: link.source,
+      target: componentIdentity(matchedApi),
+      ...link.type !== void 0 && { type: link.type },
+      ...link._uncertain !== void 0 && { _uncertain: link._uncertain },
+      ...link.sourceLocation !== void 0 && { sourceLocation: link.sourceLocation }
+    }));
   }
-  return {
+  return new HttpLinkResolutionResult({
     links: resolvedLinks,
     externalLinks
-  };
+  });
 }
 function stripResolvedCustomTypes(components, httpLinkConfigs, resolvedLinks) {
   const resolvedCustomTypes = new Set(httpLinkConfigs.map((config2) => config2.fromCustomType));
@@ -29019,76 +27411,368 @@ function toExternalLink(link, serviceName, targetComponent, matchApiBy) {
     ...link.sourceLocation !== void 0 && { sourceLocation: link.sourceLocation }
   };
 }
-
-// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/detect-connections.js
-function computeFilteredFilePaths(project, moduleGlobs, globMatcher) {
-  return project.getSourceFiles().map((sf) => sf.getFilePath()).filter((filePath) => moduleGlobs.some((glob) => globMatcher(filePath, glob)));
+
+// ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/detect-connections.js
+function deduplicateCrossStrategy(links) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const key = `${link.source}|${link.target}|${link.type}`;
+    const existing = seen.get(key);
+    if (existing !== void 0) {
+      if (existing._uncertain !== void 0 && link._uncertain === void 0) {
+        seen.set(key, link);
+      }
+      continue;
+    }
+    seen.set(key, link);
+  }
+  return [...seen.values()];
+}
+function detectPerModuleConnections(project, components, options) {
+  const setupStart = performance.now();
+  const visibleComponents = options.allComponents ?? components;
+  const componentIndex = new ComponentIndex(visibleComponents);
+  const sourceFilePaths = options.sourceFilePaths;
+  const setupMs = performance.now() - setupStart;
+  const strict = options.allowIncomplete !== true;
+  const repository = options.repository;
+  const callGraphStart = performance.now();
+  const syncLinks = buildCallGraph(project, components, componentIndex, new CallGraphOptions({
+    strict,
+    sourceFilePaths,
+    repository
+  }));
+  const callGraphMs = performance.now() - callGraphStart;
+  const httpLinkConfigs = options.httpLinks ?? [];
+  const resolved = resolveHttpLinks(syncLinks, visibleComponents, httpLinkConfigs);
+  return new PerModuleDetectionResult({
+    links: resolved.links,
+    externalLinks: resolved.externalLinks,
+    timings: new PerModuleTimings({
+      callGraphMs,
+      setupMs
+    })
+  });
+}
+function detectCrossModuleConnections(allComponents, options) {
+  const strict = options.allowIncomplete !== true;
+  const repository = options.repository;
+  const asyncOptions = new AsyncDetectionOptions({
+    strict,
+    repository
+  });
+  const asyncStart = performance.now();
+  const publishLinks = detectEventPublisherConnections(allComponents, options.eventPublishers ?? [], asyncOptions);
+  const subscribeLinks = detectSubscribeConnections(allComponents, asyncOptions);
+  const asyncDetectionMs = performance.now() - asyncStart;
+  return new CrossModuleDetectionResult({
+    links: [...publishLinks, ...subscribeLinks],
+    timings: new CrossModuleTimings({ asyncDetectionMs })
+  });
+}
+
+// ../riviere-extract-ts/dist/features/extraction/domain/value-extraction/enriched-component.js
+var EnrichedComponent = class {
+  type;
+  name;
+  location;
+  domain;
+  module;
+  metadata;
+  _missing;
+  constructor(params) {
+    this.type = params.type;
+    this.name = params.name;
+    this.location = params.location;
+    this.domain = params.domain;
+    this.module = params.module;
+    this.metadata = params.metadata;
+    this._missing = params._missing;
+  }
+};
+var EnrichmentFailure = class {
+  component;
+  field;
+  error;
+  constructor(params) {
+    this.component = params.component;
+    this.field = params.field;
+    this.error = params.error;
+  }
+};
+var EnrichmentResult = class {
+  components;
+  failures;
+  constructor(params) {
+    this.components = params.components;
+    this.failures = params.failures;
+  }
+};
+
+// ../riviere-extract-ts/dist/features/extraction/domain/value-extraction/evaluate-extraction-rule-generic.js
+import { SyntaxKind as SyntaxKind5 } from "ts-morph";
+function getInterfaceTypeArgs(classDecl, interfaceName) {
+  const implementsClause = classDecl.getImplements();
+  for (const impl of implementsClause) {
+    const expression = impl.getExpression();
+    if (expression.getText() === interfaceName) {
+      return impl.getTypeArguments();
+    }
+  }
+  const extendsClause = classDecl.getExtends();
+  if (extendsClause === void 0) {
+    return void 0;
+  }
+  const baseClass = classDecl.getBaseClass();
+  if (baseClass === void 0)
+    return void 0;
+  return getInterfaceTypeArgs(baseClass, interfaceName);
+}
+function extractTypeNames(typeNode) {
+  if (typeNode.getKind() === SyntaxKind5.UnionType) {
+    const unionType = typeNode.asKindOrThrow(SyntaxKind5.UnionType);
+    return unionType.getTypeNodes().map((t) => t.getText());
+  }
+  return [typeNode.getText()];
+}
+function evaluateFromGenericArgRule(rule, classDecl) {
+  const { interface: interfaceName, position, transform: transform2 } = rule.fromGenericArg;
+  const sourceFile = classDecl.getSourceFile();
+  const location = {
+    filePath: sourceFile.getFilePath(),
+    line: classDecl.getStartLineNumber()
+  };
+  const typeArgs = getInterfaceTypeArgs(classDecl, interfaceName);
+  if (typeArgs === void 0) {
+    throw new ExtractionError(`Class '${classDecl.getName() ?? "anonymous"}' does not implement interface '${interfaceName}'`, location.filePath, location.line);
+  }
+  const typeArg = typeArgs[position];
+  if (typeArg === void 0) {
+    throw new ExtractionError(`Position ${position} out of bounds. Interface has ${typeArgs.length} type argument(s)`, location.filePath, location.line);
+  }
+  if (typeArg.getKind() === SyntaxKind5.TypeReference) {
+    const typeRef = typeArg.asKindOrThrow(SyntaxKind5.TypeReference);
+    const typeName = typeRef.getTypeName();
+    if (typeName.getKind() === SyntaxKind5.Identifier) {
+      const classTypeParams = classDecl.getTypeParameters();
+      const paramName = typeName.getText();
+      const isTypeParam = classTypeParams.some((p) => p.getName() === paramName);
+      if (isTypeParam) {
+        throw new ExtractionError(`Generic argument at position ${position} is type parameter '${paramName}', expected concrete type`, location.filePath, location.line);
+      }
+    }
+  }
+  const typeNames = extractTypeNames(typeArg);
+  if (transform2 === void 0) {
+    return new ExtractionResult({ value: typeNames });
+  }
+  return new ExtractionResult({ value: typeNames.map((name) => applyTransforms(name, transform2)) });
+}
+
+// ../riviere-extract-ts/dist/features/extraction/domain/value-extraction/evaluate-extraction-rule.js
+import { SyntaxKind as SyntaxKind6 } from "ts-morph";
+function literal2(value) {
+  return new ExtractionResult({ value });
+}
+function evaluateLiteralRule(rule) {
+  return literal2(rule.literal);
+}
+function evaluateFromClassNameRule(rule, classDecl) {
+  const className = classDecl.getName();
+  if (!className) {
+    const filePath = classDecl.getSourceFile().getFilePath();
+    const lineNumber = classDecl.getStartLineNumber();
+    throw new ExtractionError("Expected class name, got undefined", filePath, lineNumber);
+  }
+  if (rule.fromClassName === true) {
+    return new ExtractionResult({ value: className });
+  }
+  const transform2 = rule.fromClassName.transform;
+  if (transform2 === void 0) {
+    return new ExtractionResult({ value: className });
+  }
+  return new ExtractionResult({ value: applyTransforms(className, transform2) });
+}
+function evaluateFromMethodNameRule(rule, methodDecl) {
+  const methodName = methodDecl.getName();
+  if (rule.fromMethodName === true) {
+    return new ExtractionResult({ value: methodName });
+  }
+  const transform2 = rule.fromMethodName.transform;
+  if (transform2 === void 0) {
+    return new ExtractionResult({ value: methodName });
+  }
+  return new ExtractionResult({ value: applyTransforms(methodName, transform2) });
+}
+function evaluateFromFilePathRule(rule, filePath) {
+  const pattern = rule.fromFilePath.pattern;
+  const capture = rule.fromFilePath.capture;
+  const transform2 = rule.fromFilePath.transform;
+  const regex = new RegExp(pattern);
+  const match = regex.exec(filePath);
+  if (match === null) {
+    throw new ExtractionError(`Pattern '${pattern}' did not match file path '${filePath}'`, filePath, 0);
+  }
+  const capturedValue = match[capture];
+  if (capturedValue === void 0) {
+    throw new ExtractionError(`Capture group ${capture} out of bounds. Pattern has ${match.length - 1} capture groups`, filePath, 0);
+  }
+  if (transform2 === void 0) {
+    return new ExtractionResult({ value: capturedValue });
+  }
+  return new ExtractionResult({ value: applyTransforms(capturedValue, transform2) });
+}
+function findPropertyInHierarchy(classDecl, propertyName, isStatic) {
+  const properties = isStatic ? classDecl.getStaticProperties() : classDecl.getInstanceProperties();
+  const property = properties.find((p) => p.getName() === propertyName);
+  if (property !== void 0 && "getInitializer" in property) {
+    const sourceFile = classDecl.getSourceFile();
+    return {
+      initializer: property.getInitializer(),
+      filePath: sourceFile.getFilePath(),
+      line: property.getStartLineNumber()
+    };
+  }
+  if (classDecl.getExtends() === void 0) {
+    return void 0;
+  }
+  const baseClass = classDecl.getBaseClass();
+  if (baseClass === void 0)
+    return void 0;
+  return findPropertyInHierarchy(baseClass, propertyName, isStatic);
+}
+function evaluateFromPropertyRule(rule, classDecl) {
+  const name = rule.fromProperty.name;
+  const kind = rule.fromProperty.kind;
+  const transform2 = rule.fromProperty.transform;
+  const isStatic = kind === "static";
+  const propertyInfo = findPropertyInHierarchy(classDecl, name, isStatic);
+  if (propertyInfo === void 0) {
+    const sourceFile = classDecl.getSourceFile();
+    throw new ExtractionError(`Property '${name}' not found on class '${classDecl.getName() ?? "anonymous"}'`, sourceFile.getFilePath(), classDecl.getStartLineNumber());
+  }
+  const literalResult = extractLiteralValue(propertyInfo.initializer, propertyInfo.filePath, propertyInfo.line);
+  if (transform2 === void 0) {
+    return new ExtractionResult({ value: literalResult.value });
+  }
+  if (typeof literalResult.value !== "string") {
+    return new ExtractionResult({ value: literalResult.value });
+  }
+  return new ExtractionResult({ value: applyTransforms(literalResult.value, transform2) });
+}
+function getDecoratorLocation(decorator) {
+  const sourceFile = decorator.getSourceFile();
+  return {
+    filePath: sourceFile.getFilePath(),
+    line: decorator.getStartLineNumber()
+  };
+}
+function extractPositionalArg(decorator, position) {
+  const args = decorator.getArguments();
+  const location = getDecoratorLocation(decorator);
+  if (args.length === 0) {
+    throw new ExtractionError(`Decorator '@${decorator.getName()}' has no arguments`, location.filePath, location.line);
+  }
+  const arg = args[position];
+  if (arg === void 0) {
+    throw new ExtractionError(`Argument position ${position} out of bounds. Decorator has ${args.length} argument(s)`, location.filePath, location.line);
+  }
+  if (arg.getKind() !== SyntaxKind6.StringLiteral) {
+    throw new ExtractionError(`Expected string literal at position ${position}, got ${arg.getKindName()}`, location.filePath, location.line);
+  }
+  return arg.asKindOrThrow(SyntaxKind6.StringLiteral).getLiteralValue();
+}
+function throwNoArguments(decorator, location) {
+  throw new ExtractionError(`Decorator '@${decorator.getName()}' has no arguments`, location.filePath, location.line);
 }
-function deduplicateCrossStrategy(links) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const link of links) {
-    const key = `${link.source}|${link.target}|${link.type}`;
-    const existing = seen.get(key);
-    if (existing !== void 0) {
-      if (existing._uncertain !== void 0 && link._uncertain === void 0) {
-        seen.set(key, link);
-      }
-      continue;
-    }
-    seen.set(key, link);
+function getFirstArgument(decorator, location) {
+  const args = decorator.getArguments();
+  const firstArg = args[0];
+  if (firstArg === void 0) {
+    throwNoArguments(decorator, location);
   }
-  return [...seen.values()];
+  return firstArg;
 }
-function detectPerModuleConnections(project, components, options, globMatcher) {
-  const setupStart = performance.now();
-  const visibleComponents = options.allComponents ?? components;
-  const componentIndex = new ComponentIndex(visibleComponents);
-  const sourceFilePaths = computeFilteredFilePaths(project, options.moduleGlobs, globMatcher);
-  const setupMs = performance.now() - setupStart;
-  const strict = options.allowIncomplete !== true;
-  const repository = options.repository;
-  const callGraphStart = performance.now();
-  const syncLinks = buildCallGraph(project, components, componentIndex, {
-    strict,
-    sourceFilePaths,
-    repository
-  });
-  const callGraphMs = performance.now() - callGraphStart;
-  const httpLinkConfigs = options.httpLinks ?? [];
-  const resolved = resolveHttpLinks(syncLinks, visibleComponents, httpLinkConfigs);
-  return {
-    links: resolved.links,
-    externalLinks: resolved.externalLinks,
-    timings: {
-      callGraphMs,
-      setupMs
+function extractNamedArg(decorator, name) {
+  const location = getDecoratorLocation(decorator);
+  const firstArg = getFirstArgument(decorator, location);
+  if (firstArg.getKind() !== SyntaxKind6.ObjectLiteralExpression) {
+    throw new ExtractionError(`Expected object literal argument, got ${firstArg.getKindName()}`, location.filePath, location.line);
+  }
+  const objectLiteral = firstArg.asKindOrThrow(SyntaxKind6.ObjectLiteralExpression);
+  const property = objectLiteral.getProperty(name);
+  if (property === void 0) {
+    throw new ExtractionError(`Property '${name}' not found in decorator argument`, location.filePath, location.line);
+  }
+  if (!("getInitializer" in property)) {
+    throw new ExtractionError(`Property '${name}' has no initializer`, location.filePath, location.line);
+  }
+  const initializer3 = property.getInitializer();
+  if (initializer3?.getKind() !== SyntaxKind6.StringLiteral) {
+    throw new ExtractionError(`Expected string literal for property '${name}'`, location.filePath, location.line);
+  }
+  return initializer3.asKindOrThrow(SyntaxKind6.StringLiteral).getLiteralValue();
+}
+function evaluateFromDecoratorArgRule(rule, decorator) {
+  const decoratorName = rule.fromDecoratorArg.decorator;
+  const position = rule.fromDecoratorArg.position;
+  const name = rule.fromDecoratorArg.name;
+  const transform2 = rule.fromDecoratorArg.transform;
+  if (decoratorName !== void 0 && decorator.getName() !== decoratorName) {
+    const location = getDecoratorLocation(decorator);
+    throw new ExtractionError(`Expected decorator '@${decoratorName}', got '@${decorator.getName()}'`, location.filePath, location.line);
+  }
+  const extractValue = () => {
+    if (position !== void 0) {
+      return extractPositionalArg(decorator, position);
+    }
+    if (!name) {
+      const location = getDecoratorLocation(decorator);
+      throw new ExtractionError("Expected name parameter when position is undefined", location.filePath, location.line);
     }
+    return extractNamedArg(decorator, name);
   };
+  const value = extractValue();
+  if (transform2 === void 0) {
+    return new ExtractionResult({ value });
+  }
+  return new ExtractionResult({ value: applyTransforms(value, transform2) });
 }
-function detectCrossModuleConnections(allComponents, options) {
-  const strict = options.allowIncomplete !== true;
-  const repository = options.repository;
-  const asyncOptions = {
-    strict,
-    repository
-  };
-  const asyncStart = performance.now();
-  const publishLinks = detectEventPublisherConnections(allComponents, options.eventPublishers ?? [], asyncOptions);
-  const subscribeLinks = detectSubscribeConnections(allComponents, asyncOptions);
-  const asyncDetectionMs = performance.now() - asyncStart;
-  return {
-    links: [...publishLinks, ...subscribeLinks],
-    timings: { asyncDetectionMs }
+function evaluateFromClassDecoratorArgRule(rule, methodDecl) {
+  const classDecl = methodDecl.getParentIfKind(SyntaxKind6.ClassDeclaration);
+  if (classDecl === void 0) {
+    const sourceFile = methodDecl.getSourceFile();
+    throw new ExtractionError(`Expected method '${methodDecl.getName()}' to be declared inside a class`, sourceFile.getFilePath(), methodDecl.getStartLineNumber());
+  }
+  const classDecorator = classDecl.getDecorators().find((decorator) => decorator.getName() === rule.fromClassDecoratorArg.decorator);
+  if (classDecorator === void 0) {
+    const sourceFile = classDecl.getSourceFile();
+    throw new ExtractionError(`Decorator '@${rule.fromClassDecoratorArg.decorator}' not found on containing class '${classDecl.getName() ?? "anonymous"}'`, sourceFile.getFilePath(), classDecl.getStartLineNumber());
+  }
+  const fromClassDecoratorArg = rule.fromClassDecoratorArg;
+  const fromDecoratorArgRule = {
+    decorator: fromClassDecoratorArg.decorator,
+    ...fromClassDecoratorArg.position === void 0 ? {} : { position: fromClassDecoratorArg.position },
+    ...fromClassDecoratorArg.name === void 0 ? {} : { name: fromClassDecoratorArg.name },
+    ...fromClassDecoratorArg.transform === void 0 ? {} : { transform: fromClassDecoratorArg.transform }
   };
+  return evaluateFromDecoratorArgRule({ fromDecoratorArg: fromDecoratorArgRule }, classDecorator);
+}
+function evaluateFromDecoratorNameRule(rule, decorator) {
+  const decoratorName = decorator.getName();
+  if (rule.fromDecoratorName === true) {
+    return new ExtractionResult({ value: decoratorName });
+  }
+  const mapping = rule.fromDecoratorName.mapping;
+  const transform2 = rule.fromDecoratorName.transform;
+  const mappedValue = mapping?.[decoratorName] ?? decoratorName;
+  if (transform2 === void 0) {
+    return new ExtractionResult({ value: mappedValue });
+  }
+  return new ExtractionResult({ value: applyTransforms(mappedValue, transform2) });
 }
 
 // ../riviere-extract-ts/dist/features/extraction/domain/value-extraction/enrich-components.js
-import { posix as posix2 } from "node:path";
-function findMatchingModule2(filePath, modules, globMatcher, configDir) {
-  const normalized = filePath.replaceAll(/\\+/g, "/");
-  const pathToMatch = posix2.relative(configDir.replaceAll(/\\+/g, "/"), normalized);
-  return modules.find((m) => globMatcher(pathToMatch, posix2.join(m.path, m.glob)));
-}
 function getBuiltInRule(module, componentType) {
   const ruleMap = {
     api: module.api,
@@ -29223,9 +27907,9 @@ function evaluateMethodRule(rule, draft, project) {
     const typeName = param.getTypeNode()?.getText() ?? "unknown";
     const transform2 = rule.fromParameterType.transform;
     if (transform2 === void 0) {
-      return { value: typeName };
+      return new ExtractionResult({ value: typeName });
     }
-    return { value: applyTransforms(typeName, transform2) };
+    return new ExtractionResult({ value: applyTransforms(typeName, transform2) });
   }
   return void 0;
 }
@@ -29253,10 +27937,15 @@ function evaluateRule(rule, draft, project) {
 }
 function componentWithEmptyMetadata(draft) {
   return {
-    enriched: {
-      ...draft,
-      metadata: {}
-    },
+    enriched: new EnrichedComponent({
+      type: draft.type,
+      name: draft.name,
+      location: draft.location,
+      domain: draft.domain,
+      module: draft.module,
+      metadata: {},
+      _missing: void 0
+    }),
     failures: []
   };
 }
@@ -29275,11 +27964,11 @@ function extractMetadataFields(extractBlock, draft, project) {
       if (shouldIgnoreMissingMetadataField(draft, fieldName, extractionRule, errorMessage)) {
         continue;
       }
-      failures.push({
+      failures.push(new EnrichmentFailure({
         component: draft,
         field: fieldName,
         error: errorMessage
-      });
+      }));
       missing.push(fieldName);
     }
   }
@@ -29289,40 +27978,38 @@ function extractMetadataFields(extractBlock, draft, project) {
     failures
   };
 }
-function enrichSingleComponent(draft, config2, project, globMatcher, configDir) {
-  const module = findMatchingModule2(draft.location.file, config2.modules, globMatcher, configDir);
-  if (module === void 0) {
-    return componentWithEmptyMetadata(draft);
-  }
+function enrichSingleComponent(draft, module, project) {
   const detectionRule = findDetectionRule(module, draft.type);
   if (detectionRule?.extract === void 0) {
     return componentWithEmptyMetadata(draft);
   }
   const extracted = extractMetadataFields(detectionRule.extract, draft, project);
-  const enriched = {
-    ...draft,
-    metadata: extracted.metadata
-  };
-  if (extracted.missing.length > 0) {
-    enriched._missing = extracted.missing;
-  }
+  const enriched = new EnrichedComponent({
+    type: draft.type,
+    name: draft.name,
+    location: draft.location,
+    domain: draft.domain,
+    module: draft.module,
+    metadata: extracted.metadata,
+    _missing: extracted.missing.length > 0 ? extracted.missing : void 0
+  });
   return {
     enriched,
     failures: extracted.failures
   };
 }
-function enrichComponents(draftComponents, config2, project, globMatcher, configDir) {
+function enrichComponents(draftComponents, module, project) {
   const allComponents = [];
   const allFailures = [];
   for (const draft of draftComponents) {
-    const result = enrichSingleComponent(draft, config2, project, globMatcher, configDir);
+    const result = enrichSingleComponent(draft, module, project);
     allComponents.push(result.enriched);
     allFailures.push(...result.failures);
   }
-  return {
+  return new EnrichmentResult({
     components: allComponents,
     failures: allFailures
-  };
+  });
 }
 
 // ../riviere-extract-config/dist/validation.js
@@ -30499,7 +29186,6 @@ function loadDraftComponentsFromFile(filePath) {
 }
 
 // src/features/extract/domain/extraction-project.ts
-import { posix as posix3 } from "node:path";
 var OrphanedDraftComponentError = class extends Error {
   constructor(orphanedModules, knownModules) {
     super(
@@ -30509,8 +29195,7 @@ var OrphanedDraftComponentError = class extends Error {
   }
 };
 var ExtractionProject = class {
-  constructor(configDir, moduleContexts, resolvedConfig, repositoryName, draftComponents = []) {
-    this.configDir = configDir;
+  constructor(moduleContexts, resolvedConfig, repositoryName, draftComponents = []) {
     this.moduleContexts = moduleContexts;
     this.resolvedConfig = resolvedConfig;
     this.repositoryName = repositoryName;
@@ -30518,13 +29203,7 @@ var ExtractionProject = class {
   }
   extractDraftComponents(options) {
     const draftComponents = this.moduleContexts.flatMap(
-      (moduleContext) => extractComponents(
-        moduleContext.project,
-        moduleContext.files,
-        this.resolvedConfig,
-        matchesGlob,
-        this.configDir
-      )
+      (moduleContext) => extractComponents(moduleContext.project, moduleContext.files, moduleContext.module)
     );
     if (!options.includeConnections) {
       return {
@@ -30597,18 +29276,13 @@ var ExtractionProject = class {
       if (moduleComponents.length === 0) {
         continue;
       }
-      const result = detectPerModuleConnections(
-        moduleContext.project,
-        moduleComponents,
-        {
-          allComponents: enrichedComponents,
-          allowIncomplete,
-          moduleGlobs: [posix3.join(moduleContext.module.path, moduleContext.module.glob)],
-          httpLinks,
-          repository: this.repositoryName
-        },
-        matchesGlob
-      );
+      const result = detectPerModuleConnections(moduleContext.project, moduleComponents, {
+        allComponents: enrichedComponents,
+        allowIncomplete,
+        httpLinks,
+        repository: this.repositoryName,
+        sourceFilePaths: moduleContext.files
+      });
       links.push(...result.links);
       externalLinks.push(...result.externalLinks);
       timings.push({
@@ -30647,13 +29321,7 @@ var ExtractionProject = class {
       if (moduleDrafts.length === 0) {
         continue;
       }
-      const result = enrichComponents(
-        moduleDrafts,
-        this.resolvedConfig,
-        moduleContext.project,
-        matchesGlob,
-        this.configDir
-      );
+      const result = enrichComponents(moduleDrafts, moduleContext.module, moduleContext.project);
       components.push(...result.components);
       for (const failure14 of result.failures) {
         failedFieldSet.add(failure14.field);
@@ -30692,42 +29360,17 @@ function groupDraftsByModule(drafts) {
   return grouped;
 }
 
-// src/features/extract/infra/external-clients/ts-morph/create-configured-project.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
-import { Project as Project2 } from "ts-morph";
-function createConfiguredProject(configDir, skipTsConfig) {
-  if (skipTsConfig) {
-    return new Project2();
-  }
-  const tsConfigPath = resolve2(configDir, "tsconfig.json");
-  if (!existsSync2(tsConfigPath)) {
-    return new Project2();
-  }
-  return new Project2({
-    tsConfigFilePath: tsConfigPath,
-    skipAddingFilesFromTsConfig: true
-  });
-}
-
-// src/features/extract/infra/external-clients/ts-morph/find-module-tsconfig-dir.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { resolve as resolve3 } from "node:path";
-function findModuleTsConfigDir(configDir, modulePath) {
-  const moduleTsConfigPath = resolve3(configDir, modulePath, "tsconfig.json");
-  if (existsSync3(moduleTsConfigPath)) {
-    return resolve3(configDir, modulePath);
-  }
-  return configDir;
-}
-
-// src/features/extract/infra/persistence/extraction-project/extraction-project-repository.ts
-var ModuleRefNotFoundError = class extends Error {
-  constructor(ref, filePath) {
-    super(`Cannot resolve module reference '${ref}'. File not found: ${filePath}`);
-    this.name = "ModuleRefNotFoundError";
-  }
-};
+// src/features/extract/infra/external-clients/extraction-config/load-extended-module.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync3
+} from "node:fs";
+import { createRequire } from "node:module";
+import {
+  dirname as dirname2,
+  resolve as resolve2
+} from "node:path";
+import { parse as parseYaml } from "yaml";
 var ConfigSchemaValidationError = class extends Error {
   constructor(source, details) {
     super(`Invalid extended config in '${source}': ${details}`);
@@ -30757,6 +29400,121 @@ var ConfigFileNotFoundError = class extends Error {
   }
 };
 var NOT_USED = { notUsed: true };
+function loadExtendedModule(params) {
+  const filePath = resolveExtendedConfigPath(params.source, params.configDir);
+  if (!existsSync2(filePath)) {
+    throw new ConfigFileNotFoundError(params.source, filePath);
+  }
+  const content = readFileSync3(filePath, "utf-8");
+  return parseExtendedConfigContent(
+    content,
+    params.source,
+    dirname2(filePath),
+    params.resolveConfigWithExtends
+  );
+}
+function resolveExtendedConfigPath(source, configDir) {
+  return isPackageReference(source) ? resolvePackagePath(source, configDir) : resolve2(configDir, source);
+}
+function isPackageReference(source) {
+  return !source.startsWith(".") && !source.startsWith("/");
+}
+function resolvePackagePath(packageName, configDir) {
+  const require2 = createRequire(resolve2(configDir, "package.json"));
+  try {
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`);
+    const packageDir = dirname2(packageJsonPath);
+    const defaultConfigPath = resolve2(packageDir, "src/default-extraction.config.json");
+    if (existsSync2(defaultConfigPath)) {
+      return defaultConfigPath;
+    }
+    throw new PackageResolveError(packageName);
+  } catch {
+    throw new PackageResolveError(packageName);
+  }
+}
+function parseExtendedConfigContent(content, source, configDir, resolveConfigWithExtends) {
+  const parsed = parseYaml(content);
+  if (hasModulesArray(parsed)) {
+    return resolveFirstModuleFromConfig(parsed, source, configDir, resolveConfigWithExtends);
+  }
+  if (isTopLevelRulesConfig(parsed)) {
+    return topLevelRulesToModule(parsed);
+  }
+  const preview = JSON.stringify(parsed, null, 2).slice(0, 200);
+  throw new InvalidConfigFormatError(source, preview);
+}
+function resolveFirstModuleFromConfig(parsed, source, configDir, resolveConfigWithExtends) {
+  if (parsed.modules.length === 0) {
+    throw new ConfigSchemaValidationError(source, "Config has empty modules array");
+  }
+  try {
+    const config2 = parseExtractionConfig(parsed);
+    const [first] = resolveConfigWithExtends(config2, configDir).modules;
+    if (first === void 0) {
+      throw new ConfigSchemaValidationError(source, "Config has empty modules array");
+    }
+    return first;
+  } catch (error48) {
+    throw new ConfigSchemaValidationError(source, String(error48));
+  }
+}
+function hasModulesArray(value) {
+  return typeof value === "object" && value !== null && "modules" in value && Array.isArray(value.modules);
+}
+function isTopLevelRulesConfig(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !("modules" in value);
+}
+function topLevelRulesToModule(parsed) {
+  return {
+    name: "extended",
+    path: ".",
+    glob: "**",
+    api: parsed.api ?? NOT_USED,
+    useCase: parsed.useCase ?? NOT_USED,
+    domainOp: parsed.domainOp ?? NOT_USED,
+    event: parsed.event ?? NOT_USED,
+    eventHandler: parsed.eventHandler ?? NOT_USED,
+    ui: parsed.ui ?? NOT_USED
+  };
+}
+
+// src/features/extract/infra/external-clients/ts-morph/create-configured-project.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+import { Project as Project2 } from "ts-morph";
+function createConfiguredProject(configDir, skipTsConfig) {
+  if (skipTsConfig) {
+    return new Project2();
+  }
+  const tsConfigPath = resolve3(configDir, "tsconfig.json");
+  if (!existsSync3(tsConfigPath)) {
+    return new Project2();
+  }
+  return new Project2({
+    tsConfigFilePath: tsConfigPath,
+    skipAddingFilesFromTsConfig: true
+  });
+}
+
+// src/features/extract/infra/external-clients/ts-morph/find-module-tsconfig-dir.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
+function findModuleTsConfigDir(configDir, modulePath) {
+  const moduleTsConfigPath = resolve4(configDir, modulePath, "tsconfig.json");
+  if (existsSync4(moduleTsConfigPath)) {
+    return resolve4(configDir, modulePath);
+  }
+  return configDir;
+}
+
+// src/features/extract/infra/persistence/extraction-project/extraction-project-repository.ts
+var ModuleRefNotFoundError = class extends Error {
+  constructor(ref, filePath) {
+    super(`Cannot resolve module reference '${ref}'. File not found: ${filePath}`);
+    this.name = "ModuleRefNotFoundError";
+  }
+};
 var ExtractionProjectRepository = class {
   loadFromChangedProject(params) {
     const parsedConfigState = this.loadParsedConfigState(params.configPath);
@@ -30792,15 +29550,15 @@ var ExtractionProjectRepository = class {
     return this.createExtractionProject(parsedConfigState, sourceFilePaths, params.useTsConfig);
   }
   loadParsedConfigState(configPath) {
-    if (!existsSync4(configPath)) {
+    if (!existsSync5(configPath)) {
       throw new ConfigValidationError(
         "CONFIG_NOT_FOUND" /* ConfigNotFound */,
         `Config file not found: ${configPath}`
       );
     }
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     const parsed = this.parseConfigFile(content);
-    const configDir = dirname2(resolve4(configPath));
+    const configDir = dirname3(resolve5(configPath));
     const expanded = this.expandModuleRefs(parsed, configDir);
     if (!isValidExtractionConfig(expanded)) {
       const validationResult = validateExtractionConfig(expanded);
@@ -30812,12 +29570,12 @@ ${formatValidationErrors2(validationResult.errors)}`
     }
     return {
       configDir,
-      resolvedConfig: resolveConfig(expanded, this.createExtendedConfigLoader(configDir))
+      resolvedConfig: this.resolveConfigWithExtends(expanded, configDir)
     };
   }
   parseConfigFile(content) {
     try {
-      const parsed = parseYaml(content);
+      const parsed = parseYaml2(content);
       return parsed;
     } catch (error48) {
       throw new ConfigValidationError(
@@ -30846,93 +29604,66 @@ ${formatValidationErrors2(validationResult.errors)}`
     if (!this.isModuleRef(item)) {
       return item;
     }
-    const refPath = resolve4(configDir, item.$ref);
-    if (!existsSync4(refPath)) {
+    const refPath = resolve5(configDir, item.$ref);
+    if (!existsSync5(refPath)) {
       throw new ModuleRefNotFoundError(item.$ref, refPath);
     }
-    const content = readFileSync3(refPath, "utf-8");
-    const parsed = parseYaml(content);
+    const content = readFileSync4(refPath, "utf-8");
+    const parsed = parseYaml2(content);
     return parsed;
   }
-  createExtendedConfigLoader(configDir) {
-    return (source) => {
-      const filePath = this.resolveExtendedConfigPath(source, configDir);
-      return this.loadExtendedConfigFile(filePath, source);
-    };
-  }
-  resolveExtendedConfigPath(source, configDir) {
-    return this.isPackageReference(source) ? this.resolvePackagePath(source, configDir) : resolve4(configDir, source);
-  }
-  isPackageReference(source) {
-    return !source.startsWith(".") && !source.startsWith("/");
+  resolveConfigWithExtends(config2, configDir) {
+    return resolveConfig({
+      ...config2,
+      modules: config2.modules.map(
+        (moduleConfig) => this.resolveModuleConfig(moduleConfig, configDir)
+      )
+    });
   }
-  resolvePackagePath(packageName, configDir) {
-    const require2 = createRequire(resolve4(configDir, "package.json"));
-    try {
-      const packageJsonPath = require2.resolve(`${packageName}/package.json`);
-      const packageDir = dirname2(packageJsonPath);
-      const defaultConfigPath = resolve4(packageDir, "src/default-extraction.config.json");
-      if (existsSync4(defaultConfigPath)) {
-        return defaultConfigPath;
+  resolveModuleConfig(moduleConfig, configDir) {
+    const extendsSource = moduleConfig.extends;
+    if (extendsSource === void 0) {
+      const [resolvedModule] = resolveConfig({ modules: [moduleConfig] }).modules;
+      if (resolvedModule === void 0) {
+        throw new TypeError(`Expected resolved module for '${moduleConfig.name}'`);
       }
-      throw new PackageResolveError(packageName);
-    } catch {
-      throw new PackageResolveError(packageName);
-    }
-  }
-  loadExtendedConfigFile(filePath, source) {
-    if (!existsSync4(filePath)) {
-      throw new ConfigFileNotFoundError(source, filePath);
-    }
-    const content = readFileSync3(filePath, "utf-8");
-    return this.parseExtendedConfigContent(content, source);
-  }
-  parseExtendedConfigContent(content, source) {
-    const parsed = parseYaml(content);
-    if (this.hasModulesArray(parsed)) {
-      return this.resolveFirstModuleFromConfig(parsed, source);
+      return resolvedModule;
     }
-    if (this.isTopLevelRulesConfig(parsed)) {
-      return this.topLevelRulesToModule(parsed);
-    }
-    const preview = JSON.stringify(parsed, null, 2).slice(0, 200);
-    throw new InvalidConfigFormatError(source, preview);
+    const baseModule = loadExtendedModule({
+      configDir,
+      source: extendsSource,
+      resolveConfigWithExtends: (config2, nextConfigDir) => this.resolveConfigWithExtends(config2, nextConfigDir)
+    });
+    const mergedCustomTypes = this.mergeCustomTypes(
+      baseModule.customTypes,
+      moduleConfig.customTypes
+    );
+    return {
+      name: moduleConfig.name,
+      domain: moduleConfig.domain,
+      path: moduleConfig.path,
+      glob: moduleConfig.glob,
+      ...moduleConfig.modules !== void 0 && { modules: moduleConfig.modules },
+      api: moduleConfig.api ?? baseModule.api,
+      useCase: moduleConfig.useCase ?? baseModule.useCase,
+      domainOp: moduleConfig.domainOp ?? baseModule.domainOp,
+      event: moduleConfig.event ?? baseModule.event,
+      eventHandler: moduleConfig.eventHandler ?? baseModule.eventHandler,
+      ui: moduleConfig.ui ?? baseModule.ui,
+      ...mergedCustomTypes !== void 0 && { customTypes: mergedCustomTypes }
+    };
   }
-  resolveFirstModuleFromConfig(parsed, source) {
-    if (parsed.modules.length === 0) {
-      throw new ConfigSchemaValidationError(source, "Config has empty modules array");
-    }
-    try {
-      const config2 = parseExtractionConfig(parsed);
-      const [first] = resolveConfig(config2).modules;
-      if (first === void 0) {
-        throw new ConfigSchemaValidationError(source, "Config has empty modules array");
-      }
-      return first;
-    } catch (error48) {
-      const message = error48 instanceof Error ? error48.message : String(error48);
-      throw new ConfigSchemaValidationError(source, message);
+  mergeCustomTypes(base, local) {
+    if (base === void 0 && local === void 0) {
+      return void 0;
     }
-  }
-  isTopLevelRulesConfig(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value) && !("modules" in value);
-  }
-  topLevelRulesToModule(parsed) {
     return {
-      name: "extended",
-      path: ".",
-      glob: "**",
-      api: parsed.api ?? NOT_USED,
-      useCase: parsed.useCase ?? NOT_USED,
-      domainOp: parsed.domainOp ?? NOT_USED,
-      event: parsed.event ?? NOT_USED,
-      eventHandler: parsed.eventHandler ?? NOT_USED,
-      ui: parsed.ui ?? NOT_USED
+      ...base,
+      ...local
     };
   }
   createExtractionProject(parsedConfigState, sourceFilePaths, useTsConfig, draftComponents = []) {
     return new ExtractionProject(
-      parsedConfigState.configDir,
       this.createModuleContexts(
         parsedConfigState.configDir,
         parsedConfigState.resolvedConfig,
@@ -30946,10 +29677,10 @@ ${formatValidationErrors2(validationResult.errors)}`
   }
   resolveSourceFilePaths(parsedConfigState) {
     const sourceFilePaths = parsedConfigState.resolvedConfig.modules.flatMap(
-      (module) => globSync(posix4.join(module.path, module.glob), { cwd: parsedConfigState.configDir })
-    ).map((filePath) => resolve4(parsedConfigState.configDir, filePath));
+      (module) => globSync(posix.join(module.path, module.glob), { cwd: parsedConfigState.configDir })
+    ).map((filePath) => resolve5(parsedConfigState.configDir, filePath));
     if (sourceFilePaths.length === 0) {
-      const patterns = parsedConfigState.resolvedConfig.modules.map((module) => posix4.join(module.path, module.glob)).join(", ");
+      const patterns = parsedConfigState.resolvedConfig.modules.map((module) => posix.join(module.path, module.glob)).join(", ");
       throw new ConfigValidationError(
         "VALIDATION_ERROR" /* ValidationError */,
         `No files matched extraction patterns: ${patterns}
@@ -30964,25 +29695,25 @@ Config directory: ${parsedConfigState.configDir}`
     for (const warning of result.warnings) {
       console.error(warning);
     }
-    const changedAbsolute = new Set(result.files.map((filePath) => resolve4(filePath)));
+    const changedAbsolute = new Set(result.files.map((filePath) => resolve5(filePath)));
     return allSourceFiles.filter((filePath) => changedAbsolute.has(filePath));
   }
   resolveSelectedSourceFilePaths(allSourceFiles, requestedFiles) {
-    const missingFiles = requestedFiles.filter((filePath) => !existsSync4(resolve4(filePath)));
+    const missingFiles = requestedFiles.filter((filePath) => !existsSync5(resolve5(filePath)));
     if (missingFiles.length > 0) {
       throw new ConfigValidationError(
         "VALIDATION_ERROR" /* ValidationError */,
         `Files not found: ${missingFiles.join(", ")}`
       );
     }
-    const requestedAbsolute = new Set(requestedFiles.map((filePath) => resolve4(filePath)));
+    const requestedAbsolute = new Set(requestedFiles.map((filePath) => resolve5(filePath)));
     return allSourceFiles.filter((filePath) => requestedAbsolute.has(filePath));
   }
   createModuleContexts(configDir, resolvedConfig, sourceFilePaths, useTsConfig) {
     const sourceFileSet = new Set(sourceFilePaths);
     return resolvedConfig.modules.map((module) => {
-      const allModuleFiles = globSync(posix4.join(module.path, module.glob), { cwd: configDir }).map(
-        (filePath) => resolve4(configDir, filePath)
+      const allModuleFiles = globSync(posix.join(module.path, module.glob), { cwd: configDir }).map(
+        (filePath) => resolve5(configDir, filePath)
       );
       const moduleFiles = allModuleFiles.filter((filePath) => sourceFileSet.has(filePath));
       const moduleConfigDir = findModuleTsConfigDir(configDir, module.path);
@@ -31363,7 +30094,7 @@ function createExtractCommand(extractDraftComponents, enrichDraftComponents) {
 }
 
 // src/features/query/infra/persistence/riviere-query-repository.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 import { join as join2 } from "node:path";
 var DEFAULT_GRAPH_PATH3 = ".riviere/graph.json";
 var RiviereQueryRepository = class {
@@ -31372,7 +30103,7 @@ var RiviereQueryRepository = class {
     if (!fileExists(graphPath)) {
       throw new GraphNotFoundError(graphPath);
     }
-    const content = readFileSync4(graphPath, "utf-8");
+    const content = readFileSync5(graphPath, "utf-8");
     try {
       const parsed = JSON.parse(content);
       return RiviereQuery.fromJSON(parsed);
@@ -31466,7 +30197,7 @@ var TraceFlow = class {
       return {
         message: error48.message,
         success: false,
-        suggestions: matches.map((match2) => match2.component.id)
+        suggestions: matches.map((match) => match.component.id)
       };
     }
   }
@@ -31749,8 +30480,8 @@ export {
 /* istanbul ignore next -- @preserve: Methods in object literals have non-class parents; predicate correctly returns false */
 /* istanbul ignore else -- @preserve: false branch is unreachable; FindTarget is exhaustive */
 /* istanbul ignore next -- @preserve: unreachable with valid FindTarget type; defensive fallback */
-/* v8 ignore next -- @preserve: getExtends() !== undefined guarantees getBaseClass() returns a value */
 /* istanbul ignore next -- @preserve: defensive guard; resolvedCustomTypes.has guarantees config exists */
+/* v8 ignore next -- @preserve: getExtends() !== undefined guarantees getBaseClass() returns a value */
 /* v8 ignore next -- @preserve: decorators.length > 0 guarantees first decorator exists */
 /* istanbul ignore next -- @preserve: catch always receives Error instances from ExtractionError */
 /* v8 ignore start -- @preserve: default executor delegates to execFileSync; tested via CLI integration */