@wairon/cli 5.1.1-dev.100 → 5.1.1-dev.101

package/dist/index.js

@@ -3828,6 +3828,7 @@ __export(src_exports, {
   resolveSubsystemExports: () => resolveSubsystemExports,
   resolveVariantGuidance: () => resolveVariantGuidance,
   retireSpecialists: () => retireSpecialists,
+  returnTypeOf: () => returnTypeOf,
   rewriteReferences: () => rewriteReferences2,
   runWithHostedLookup: () => runWithHostedLookup,
   runWithProjectBinding: () => runWithProjectBinding,
@@ -9344,8 +9345,14 @@ function languageOfSourcePath(sourcePath) {
 function dialectOf(facts) {
   return facts.language ? typeDialectFor(facts.language) : null;
 }
-function resolveImport(fromFile, specifier, knownPaths) {
-  if (!specifier.startsWith(".")) return void 0;
+function returnTypeOf(facts, fn) {
+  return ownEntry(facts.returnTypes, fn);
+}
+function resolveImport(fromFile, specifier, knownPaths, packages) {
+  if (!specifier.startsWith(".")) {
+    const mapped = ownEntry(packages, specifier);
+    return mapped !== void 0 && knownPaths.has(mapped) ? mapped : void 0;
+  }
   const joined = pathKey(path9.posix.normalize(path9.posix.join(path9.posix.dirname(fromFile), specifier)));
   const candidates = [
     joined,
@@ -15754,7 +15761,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.100";
+var WAIRON_VERSION = "5.1.1-dev.101";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -17666,12 +17673,12 @@ function packFiles(dir, prefix = "") {
 function computePackDigest(packDir) {
   const hash = crypto3.createHash("sha256");
   const abs = path16.resolve(packDir);
-  let isFile = false;
+  let isFile2 = false;
   try {
-    isFile = fs11.statSync(abs).isFile();
+    isFile2 = fs11.statSync(abs).isFile();
   } catch {
   }
-  const entries = isFile ? [[path16.basename(abs), abs]] : packFiles(abs).map((rel2) => [rel2, path16.join(abs, rel2)]);
+  const entries = isFile2 ? [[path16.basename(abs), abs]] : packFiles(abs).map((rel2) => [rel2, path16.join(abs, rel2)]);
   for (const [rel2, full] of entries) {
     hash.update(rel2);
     hash.update("\0");
@@ -18355,6 +18362,7 @@ function appendUnique(map, key, value, same) {
   list.push(value);
 }
 function buildCodeIndex(model) {
+  const packages = model.packages ?? {};
   const facts = /* @__PURE__ */ new Map();
   const paths = /* @__PURE__ */ new Set();
   const exactPaths = /* @__PURE__ */ new Set();
@@ -18387,7 +18395,7 @@ function buildCodeIndex(model) {
       const f = facts.get(from);
       if (f?.status !== "analyzed") continue;
       for (const specifier of f.reexports) {
-        const to = resolveImport(from, specifier, paths);
+        const to = resolveImport(from, specifier, paths, packages);
         if (to && !out.has(to)) {
           out.add(to);
           queue.push(to);
@@ -18399,7 +18407,7 @@ function buildCodeIndex(model) {
   };
   const NO_ORIGIN = /* @__PURE__ */ new Set();
   const landingFrom = (scope, specifier) => {
-    const to = resolveImport(scope, specifier, paths);
+    const to = resolveImport(scope, specifier, paths, packages);
     return to ? republishedFrom(to) : NO_ORIGIN;
   };
   const scopeOf2 = (site, from) => {
@@ -18429,7 +18437,7 @@ function buildCodeIndex(model) {
   };
   const possibleOriginsOf = (site, from) => {
     const proven = originOf2(site, from);
-    if (!site.field && !site.constructed && !site.via) return proven;
+    if (!site.field && !site.constructed && !site.via && !site.returnedBy && !site.enclosingClass) return proven;
     const resolved = scopeOf2(site, from);
     if (!resolved) return proven;
     const { path: scope, facts: f } = resolved;
@@ -18442,24 +18450,59 @@ function buildCodeIndex(model) {
     if (site.field) for (const typeName of fieldTypesOf(f, site.field)) widenThroughType(typeName);
     if (site.constructed) widenThrough(site.constructed, importBindingOf(f, site.constructed)?.from);
     if (site.via) for (const typeName of localTypesOf(f, site.via)) widenThroughType(typeName);
+    if (site.enclosingClass !== void 0 && holdsMemberBody(f, site.name, site.enclosingClass)) {
+      for (const candidate of republishedFrom(scope)) out.add(candidate);
+    }
+    if (site.returnedBy !== void 0) {
+      for (const fnFile of originOf2({ name: site.returnedBy, member: false }, scope)) {
+        const at = facts.get(fnFile);
+        if (at?.status !== "analyzed" || at.analysisGrade !== "exact") continue;
+        const typeName = returnTypeOf(at, site.returnedBy);
+        if (typeName === void 0) continue;
+        const specifier = typeBindingOf(at, typeName);
+        const landings = specifier !== void 0 ? landingFrom(fnFile, specifier) : declarationsAt(fnFile).has(typeName) ? republishedFrom(fnFile) : NO_ORIGIN;
+        for (const candidate of landings) {
+          const there = facts.get(candidate);
+          if (there && holdsMemberBody(there, site.name, typeName)) out.add(candidate);
+        }
+      }
+    }
     return out;
   };
+  const holdsMemberBody = (f, name, container) => f.status === "analyzed" && f.analysisGrade === "exact" && !!f.functionBodies && Object.prototype.hasOwnProperty.call(f.functionBodies, name) && f.functionBodies[name].some((b) => b.container === container);
   const declarationsAt = (path49) => namesAt(declarations, pathKey(path49), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
-  const forwardsOf = (start, name) => {
+  const forwardsOf = (start, name, container) => {
     const out = [];
+    const listed = /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
-    const queue = [{ file: pathKey(start), name }];
+    const queue = [{ file: pathKey(start), name, container }];
     while (queue.length) {
       const at = queue.shift();
-      const key = `${at.file}#${at.name}`;
+      const key = `${at.scope ? "s" : "p"}|${at.container ?? ""}|${at.file}#${at.name}`;
       if (seen.has(key)) continue;
       seen.add(key);
-      out.push(at);
-      for (const binding of facts.get(at.file)?.reexportBindings ?? []) {
+      if (!listed.has(`${at.file}#${at.name}`)) {
+        listed.add(`${at.file}#${at.name}`);
+        out.push({ file: at.file, name: at.name });
+      }
+      const f = facts.get(at.file);
+      if (at.scope) {
+        const binding = f ? importBindingOf(f, at.name) : void 0;
+        if (!binding || binding.namespace) continue;
+        const to = resolveImport(at.file, binding.from, paths, packages);
+        if (to) queue.push({ file: to, name: binding.imported ?? at.name });
+        continue;
+      }
+      for (const alias of f?.exportAliases ?? []) {
+        if (alias.exported !== at.name || alias.container !== at.container) continue;
+        queue.push({ file: at.file, name: alias.local, scope: true });
+      }
+      if (at.container !== void 0) continue;
+      for (const binding of f?.reexportBindings ?? []) {
         const star = binding.exported === "*";
         if (!star && binding.exported !== at.name) continue;
         if (star && at.name === "default") continue;
-        const to = resolveImport(at.file, binding.from, paths);
+        const to = resolveImport(at.file, binding.from, paths, packages);
         if (!to) continue;
         if (star && !facts.get(to)?.exportedNames.includes(at.name)) continue;
         queue.push({ file: to, name: star ? at.name : binding.local });
@@ -18470,6 +18513,7 @@ function buildCodeIndex(model) {
   return {
     paths,
     exactPaths,
+    packages,
     factsAt: (path49) => facts.get(pathKey(path49)),
     declarationsAt,
     anchorsAt: (path49) => namesAt(anchors, pathKey(path49), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
@@ -18523,7 +18567,7 @@ function buildImportGraph(index, universe) {
   const traces = /* @__PURE__ */ new Map();
   const resolveAll = (from, specifiers, into) => {
     for (const specifier of specifiers) {
-      const to = resolveImport(from, specifier, universe);
+      const to = resolveImport(from, specifier, universe, index.packages);
       if (to && to !== from) into.add(to);
     }
   };
@@ -23741,13 +23785,13 @@ function invokedAs(code, site, file) {
   if (!site.member) {
     const binding = importBindingOf(facts, site.name);
     if (!binding || binding.namespace) return [];
-    const module3 = resolveImport(scope, binding.from, code.paths);
+    const module3 = resolveImport(scope, binding.from, code.paths, code.packages);
     return module3 ? code.forwardsOf(module3, binding.imported ?? site.name) : [];
   }
   if (!site.via) return [];
   const receiver = importBindingOf(facts, site.via);
   if (!receiver?.namespace) return [];
-  const module2 = resolveImport(scope, receiver.from, code.paths);
+  const module2 = resolveImport(scope, receiver.from, code.paths, code.packages);
   return module2 ? code.forwardsOf(module2, site.name) : [];
 }
 function claimsOf(implMethod) {
@@ -23769,6 +23813,8 @@ function describeSite(site) {
   if (site.via) return `${site.via}.${site.name}(\u2026)`;
   if (site.field) return `this.${site.field}.${site.name}(\u2026)`;
   if (site.constructed) return `new ${site.constructed}(\u2026).${site.name}(\u2026)`;
+  if (site.returnedBy) return `${site.returnedBy}(\u2026).${site.name}(\u2026)`;
+  if (site.enclosingClass) return `this.${site.name}(\u2026)`;
   return `<receiver>.${site.name}(\u2026)`;
 }
 function describeMiss(m) {
@@ -23781,7 +23827,7 @@ function describeMiss(m) {
 var callConformanceRule = {
   name: "call-conformance",
   judges: "code",
-  description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from, and a plain `<name>.<method>()` receiver through the type the file ANNOTATES that name with \u2014 a parameter's, or an annotated variable's, which is how a module that wires its collaborators as closures writes every one of its calls. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
+  description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from, a plain `<name>.<method>()` receiver through the type the file ANNOTATES that name with \u2014 a parameter's, or an annotated variable's, which is how a module that wires its collaborators as closures writes every one of its calls \u2014 a `fn(...).<method>()` receiver through the type fn RETURNS where the code settles it, and a `this.<method>()` receiver through the class whose own method it sits in; a package specifier naming a package of this repository resolves like a relative one, and an export alias (`export { a as b }`, an adapter object property `{ b: a }`) forwards by identity like a re-export. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported; a function forwarding by identity to a modelled method written in another file IS that method, so what it calls is that method's subject. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
   codes: [
     { code: "CALL_STEP_UNREALIZED", defaultSeverity: "warning", summary: "Narrative call step or declared call realized by no call that resolves to the target method's own source file \u2014 the call is absent, or it lands in another module", carryable: true },
     { code: "CALL_ORIGIN_UNRESOLVED", defaultSeverity: "warning", summary: "Narrative call step or declared call whose target name IS called, but only from call sites written in a shape this analysis cannot resolve to a file \u2014 the claim was not checked, and is neither proven realized nor accused", carryable: true },
@@ -23824,7 +23870,7 @@ var callConformanceRule = {
         if (!ctx.componentMap.has(claim.component)) continue;
         const target = resolveCallTarget(ctx, claim.component, claim.method);
         if (target.accepted.has(fnSymbol)) continue;
-        if (isTarget(code.forwardsOf(file, fnSymbol), target)) continue;
+        if (isTarget(code.forwardsOf(file, fnSymbol, implMethod.exportedVia), target)) continue;
         const matching = sites.filter((s) => target.accepted.has(s.name));
         const ref = `${claim.component}.${claim.method}`;
         if (target.files.size === 0) {
@@ -23867,7 +23913,7 @@ var callConformanceRule = {
         ctx.addIssue(
           "warning",
           "CALL_ORIGIN_UNRESOLVED",
-          `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} ARE called by name inside the function "${fnSymbol}" in "${file}", but every site calling them is written in a shape this analysis cannot resolve to a file \u2014 ${unresolved.map(describeMiss).join("; ")}. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding, a \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does, and a receiver NAME the file annotates with a type that does. What does not: an import from a PACKAGE specifier, a receiver holding a value the module assembled, a receiver this model records no name for, and one the file annotates with nothing. This reports what was not checked, not what is wrong \u2014 the claim is neither proven realized nor accused of being missing, and no working call is asked to be rewritten to suit the reader.`,
+          `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} ARE called by name inside the function "${fnSymbol}" in "${file}", but every site calling them is written in a shape this analysis cannot resolve to a file \u2014 ${unresolved.map(describeMiss).join("; ")}. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding (a package of this repository included), a \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does, a receiver NAME the file annotates with a type that does, a \`fn(\u2026)\` receiver whose function's return the code settles on a type with that method's body, and \`this\` inside a class's own method that has it. What does not: an import from a third-party PACKAGE, a receiver holding a value the module assembled, a receiver this model records no name for, and one the file annotates with nothing. This reports what was not checked, not what is wrong \u2014 the claim is neither proven realized nor accused of being missing, and no working call is asked to be rewritten to suit the reader.`,
           impl.id,
           entry.draftContext,
           void 0,
@@ -23889,7 +23935,9 @@ var callConformanceRule = {
         reached.set(site, owner);
         return owner !== void 0;
       };
-      for (const site of closedCallSites(code, file, fnSymbol, stopAtModelled, implMethod.exportedVia) ?? []) {
+      const forwardsToModelled = code.forwardsOf(file, fnSymbol, implMethod.exportedVia).some((p) => p.file !== here && modelledAt.get(p.file)?.byName.has(p.name));
+      const conversed = forwardsToModelled ? [] : closedCallSites(code, file, fnSymbol, stopAtModelled, implMethod.exportedVia) ?? [];
+      for (const site of conversed) {
         const owner = reached.get(site);
         if (!owner || owner.component === component.id) continue;
         const ref = `${owner.component}.${owner.method}`;
@@ -25077,7 +25125,7 @@ var exportConformanceRule = {
       const facts = code.factsAt(file);
       if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
       for (const binding of facts.reexportBindings ?? []) {
-        const target = resolveImport(file, binding.from, code.paths);
+        const target = resolveImport(file, binding.from, code.paths, code.packages);
         const methods = target ? typeMethodsAt.get(target) : void 0;
         if (!methods) continue;
         if (binding.local === "*") {
@@ -25089,7 +25137,7 @@ var exportConformanceRule = {
     }
     const takenFrom = /* @__PURE__ */ new Map();
     const take = (consumer, writtenIn, specifier, names) => {
-      const target = resolveImport(writtenIn, specifier, code.paths);
+      const target = resolveImport(writtenIn, specifier, code.paths, code.packages);
       if (!target) return;
       let byName = takenFrom.get(target);
       if (!byName) takenFrom.set(target, byName = /* @__PURE__ */ new Map());
@@ -26823,6 +26871,9 @@ function walkExact(ts, sourceText, fileName) {
   const reexports = /* @__PURE__ */ new Set();
   const starExports = [];
   const namedReexports = [];
+  const exportAliases = [];
+  const propertyAliases = [];
+  const returnTypes = /* @__PURE__ */ new Map();
   const complexity = /* @__PURE__ */ new Map();
   const calls = /* @__PURE__ */ new Map();
   const bodies = /* @__PURE__ */ new Map();
@@ -26839,7 +26890,7 @@ function walkExact(ts, sourceText, fileName) {
   const mutableBindings = /* @__PURE__ */ new Set();
   const schemaConstants = /* @__PURE__ */ new Map();
   const derivedAliases = [];
-  const receiverKey = (site) => site.via ?? (site.field ? `this.${site.field}` : site.constructed ? `new ${site.constructed}` : "");
+  const receiverKey = (site) => site.via ?? (site.field ? `this.${site.field}` : site.constructed ? `new ${site.constructed}` : site.returnedBy ? `${site.returnedBy}()` : site.enclosingClass ? `this:${site.enclosingClass}` : "");
   const siteKey = (site) => `${site.member ? "m" : "b"}:${receiverKey(site)}:${site.name}`;
   const addBindingNames = (name) => {
     if (ts.isIdentifier(name)) declared.add(name.text);
@@ -26947,6 +26998,44 @@ function walkExact(ts, sourceText, fileName) {
     }
     return void 0;
   };
+  const enclosingClassOf = (node) => {
+    let at = node.parent;
+    while (at) {
+      if (ts.isFunctionExpression(at) || ts.isFunctionDeclaration(at) || ts.isClassExpression(at)) return void 0;
+      if ((ts.isMethodDeclaration(at) || ts.isGetAccessorDeclaration(at) || ts.isSetAccessorDeclaration(at)) && at.parent && ts.isObjectLiteralExpression(at.parent)) return void 0;
+      if (ts.isClassDeclaration(at)) {
+        return at.name && at.parent && ts.isSourceFile(at.parent) ? at.name.text : void 0;
+      }
+      at = at.parent;
+    }
+    return void 0;
+  };
+  const returnedTypeOf = (fn) => {
+    const annotated = fn.type;
+    if (annotated) {
+      if (!ts.isTypeReferenceNode(annotated)) return void 0;
+      if (ts.isIdentifier(annotated.typeName) && annotated.typeName.text === "Promise" && annotated.typeArguments?.length === 1) {
+        const inner2 = annotated.typeArguments[0];
+        return ts.isTypeReferenceNode(inner2) && !inner2.typeArguments ? typeReferenceName(inner2) : void 0;
+      }
+      return annotated.typeArguments ? void 0 : typeReferenceName(annotated);
+    }
+    const constructedClass = (expression) => {
+      let node = expression;
+      while (node && (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node))) node = node.expression;
+      return node && ts.isNewExpression(node) && ts.isIdentifier(node.expression) ? node.expression.text : void 0;
+    };
+    if (!fn.body) return void 0;
+    if (!ts.isBlock(fn.body)) return constructedClass(fn.body);
+    const returns = [];
+    const collect = (node) => {
+      if (ts.isFunctionLike(node)) return;
+      if (ts.isReturnStatement(node)) returns.push(node);
+      ts.forEachChild(node, collect);
+    };
+    ts.forEachChild(fn.body, collect);
+    return returns.length === 1 ? constructedClass(returns[0].expression) : void 0;
+  };
   const isTopLevelVariable = (decl) => ts.isVariableDeclaration(decl) && ts.isIdentifier(decl.name) && !!decl.parent && ts.isVariableDeclarationList(decl.parent) && !!decl.parent.parent && ts.isVariableStatement(decl.parent.parent) && !!decl.parent.parent.parent && ts.isSourceFile(decl.parent.parent.parent);
   const containerOf = (owner) => {
     if (!owner) return void 0;
@@ -27008,6 +27097,11 @@ function walkExact(ts, sourceText, fileName) {
             addSite({ name, member: true, field: receiver.name.text });
           } else if (ts.isNewExpression(receiver) && ts.isIdentifier(receiver.expression)) {
             addSite({ name, member: true, constructed: receiver.expression.text });
+          } else if (ts.isCallExpression(receiver) && ts.isIdentifier(receiver.expression)) {
+            addSite({ name, member: true, returnedBy: receiver.expression.text });
+          } else if (receiver.kind === ts.SyntaxKind.ThisKeyword) {
+            const owner = enclosingClassOf(node);
+            addSite(owner !== void 0 ? { name, member: true, enclosingClass: owner } : { name, member: true });
           } else addSite({ name, member: true });
         }
       }
@@ -27134,6 +27228,8 @@ function walkExact(ts, sourceText, fileName) {
       signatures.push(declaredParameters(node));
       functionParams.set(fnName, signatures);
       if (completesLater(node)) asyncFunctions.push(fnName);
+      const returned = returnedTypeOf(node) ?? null;
+      returnTypes.set(fnName, returnTypes.has(fnName) && returnTypes.get(fnName) !== returned ? null : returned);
       const routes = collectRoutes(node);
       if (routes.size > 0) {
         const known = functionRoutes.get(fnName) ?? /* @__PURE__ */ new Map();
@@ -27170,6 +27266,23 @@ function walkExact(ts, sourceText, fileName) {
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && !schemaConstants.has(node.name.text)) {
       schemaConstants.set(node.name.text, node.initializer);
     }
+    if (isTopLevelVariable(node) && node.initializer) {
+      let literal = node.initializer;
+      while (ts.isAsExpression(literal) || ts.isSatisfiesExpression(literal) || ts.isParenthesizedExpression(literal)) {
+        literal = literal.expression;
+      }
+      if (ts.isObjectLiteralExpression(literal)) {
+        const container = node.name.text;
+        for (const property of literal.properties) {
+          if (ts.isShorthandPropertyAssignment(property)) {
+            propertyAliases.push({ exported: property.name.text, local: property.name.text, container });
+          } else if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.initializer)) {
+            const key = propertyNameText(property.name);
+            if (key) propertyAliases.push({ exported: key, local: property.initializer.text, container });
+          }
+        }
+      }
+    }
     if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) {
       const name = node.name && ts.isIdentifier(node.name) ? node.name.text : void 0;
       if (name) {
@@ -27221,9 +27334,10 @@ function walkExact(ts, sourceText, fileName) {
         for (const el of node.exportClause.elements) {
           declared.add(el.name.text);
           exported.add(el.name.text);
-          if (spec && !node.isTypeOnly && !el.isTypeOnly) {
-            namedReexports.push({ exported: el.name.text, local: (el.propertyName ?? el.name).text, from: spec });
-          }
+          if (node.isTypeOnly || el.isTypeOnly) continue;
+          const local = (el.propertyName ?? el.name).text;
+          if (spec) namedReexports.push({ exported: el.name.text, local, from: spec });
+          else exportAliases.push({ exported: el.name.text, local });
         }
       } else if (!node.exportClause && spec) {
         starExports.push(spec);
@@ -27298,7 +27412,13 @@ function walkExact(ts, sourceText, fileName) {
     if (values && schemaConstants.has(alias.constant)) enumValues.set(alias.name, values);
   }
   const reexportOnly = sf.statements.length > 0 && sf.statements.every((st) => ts.isExportDeclaration(st) && !!st.moduleSpecifier);
-  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, complexity, calls, bodies, importBindings, typeOnlyBindings, fieldTypes, localTypes, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
+  for (const alias of propertyAliases) if (exported.has(alias.container)) exportAliases.push(alias);
+  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, exportAliases, returnTypes, complexity, calls, bodies, importBindings, typeOnlyBindings, fieldTypes, localTypes, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
+}
+var NO_PACKAGES = /* @__PURE__ */ new Map();
+function resolveModule(fromFile, specifier, packages) {
+  if (!specifier.startsWith(".")) return packages.get(specifier) ?? null;
+  return resolveRelativeModule(fromFile, specifier);
 }
 function resolveRelativeModule(fromFile, specifier) {
   if (!specifier.startsWith(".")) return null;
@@ -27321,8 +27441,8 @@ function resolveRelativeModule(fromFile, specifier) {
   }
   return null;
 }
-function reexportTarget(ts, filePath, specifier, projectRoot, visited, exactCache) {
-  const target = resolveRelativeModule(filePath, specifier);
+function reexportTarget(ts, filePath, specifier, projectRoot, visited, exactCache, packages) {
+  const target = resolveModule(filePath, specifier, packages);
   if (!target || path18.relative(projectRoot, target).startsWith("..")) return null;
   let targetFacts = exactCache.get(target);
   if (targetFacts === void 0) {
@@ -27336,7 +27456,7 @@ function reexportTarget(ts, filePath, specifier, projectRoot, visited, exactCach
   if (!targetFacts) return null;
   if (!visited.has(target)) {
     visited.add(target);
-    chaseReexports(ts, targetFacts, target, projectRoot, visited, exactCache);
+    chaseReexports(ts, targetFacts, target, projectRoot, visited, exactCache, packages);
   }
   return { path: target, facts: targetFacts };
 }
@@ -27359,13 +27479,33 @@ function carryBody(facts, target, targetPath, local, exported, projectRoot) {
   }
   facts.bodies.set(exported, carried);
 }
-function chaseReexports(ts, facts, filePath, projectRoot, visited, exactCache) {
+function carryAliasBody(facts, source, from, local, alias) {
+  const sourceBodies = source.bodies.get(local) ?? [];
+  if (!sourceBodies.length || sourceBodies.some((b) => b.nested)) return;
+  const moduleScope = sourceBodies.filter((b) => b.container === void 0);
+  if (!moduleScope.length) return;
+  const score = source.complexity.get(local);
+  if (score !== void 0) {
+    facts.complexity.set(alias.exported, Math.max(facts.complexity.get(alias.exported) ?? 0, score));
+  }
+  const relocate2 = (site) => from !== void 0 ? { ...site, from: site.from ?? from } : site;
+  const sites = facts.calls.get(alias.exported) ?? /* @__PURE__ */ new Map();
+  const carried = facts.bodies.get(alias.exported) ?? [];
+  for (const body of moduleScope) {
+    const moved = body.sites.map(relocate2);
+    for (const site of moved) sites.set(`${from ?? ""}|${alias.container ?? ""}|${JSON.stringify(site)}`, site);
+    carried.push(alias.container !== void 0 ? { container: alias.container, sites: moved } : { sites: moved });
+  }
+  facts.calls.set(alias.exported, sites);
+  facts.bodies.set(alias.exported, carried);
+}
+function chaseReexports(ts, facts, filePath, projectRoot, visited, exactCache, packages = NO_PACKAGES) {
   for (const re of facts.namedReexports) {
-    const target = reexportTarget(ts, filePath, re.from, projectRoot, visited, exactCache);
+    const target = reexportTarget(ts, filePath, re.from, projectRoot, visited, exactCache, packages);
     if (target) carryBody(facts, target.facts, target.path, re.local, re.exported, projectRoot);
   }
   for (const spec of facts.starExports) {
-    const target = reexportTarget(ts, filePath, spec, projectRoot, visited, exactCache);
+    const target = reexportTarget(ts, filePath, spec, projectRoot, visited, exactCache, packages);
     if (!target) continue;
     for (const name of target.facts.exported) {
       facts.exported.add(name);
@@ -27373,6 +27513,150 @@ function chaseReexports(ts, facts, filePath, projectRoot, visited, exactCache) {
       carryBody(facts, target.facts, target.path, name, name, projectRoot);
     }
   }
+  for (const alias of facts.exportAliases) {
+    const binding = facts.importBindings.get(alias.local);
+    if (binding) {
+      if (binding.namespace) continue;
+      const target = reexportTarget(ts, filePath, binding.from, projectRoot, visited, exactCache, packages);
+      if (!target) continue;
+      const from = pathKey(path18.relative(projectRoot, target.path));
+      carryAliasBody(facts, target.facts, from, binding.imported ?? alias.local, alias);
+    } else if (alias.container !== void 0 || alias.local !== alias.exported) {
+      carryAliasBody(facts, facts, void 0, alias.local, alias);
+    }
+  }
+}
+var BUILD_EXTENSIONS = [".d.mts", ".d.cts", ".d.ts", ".mjs", ".cjs", ".jsx", ".js"];
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var ENTRY_CONDITIONS = ["types", "import", "require", "default"];
+function isOwnFile(projectRoot, absolute) {
+  const rel2 = path18.relative(projectRoot, absolute);
+  if (rel2.startsWith("..") || path18.isAbsolute(rel2)) return false;
+  return !pathKey(rel2).split("/").includes("node_modules");
+}
+function isFile(absolute) {
+  try {
+    return fs13.statSync(absolute).isFile();
+  } catch {
+    return false;
+  }
+}
+function readJsonFile2(file, ts) {
+  let text3;
+  try {
+    text3 = fs13.readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text3);
+  } catch {
+    if (!ts) return void 0;
+    const parsed = ts.parseConfigFileTextToJson(file, text3);
+    return parsed.error ? void 0 : parsed.config;
+  }
+}
+function conditionTargets(value) {
+  if (typeof value === "string") return [value];
+  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+  const record = value;
+  const keys = [...ENTRY_CONDITIONS.filter((k) => k in record), ...Object.keys(record).filter((k) => !ENTRY_CONDITIONS.includes(k))];
+  return keys.flatMap((k) => conditionTargets(record[k]));
+}
+function packageEntries(pkg) {
+  const entries = /* @__PURE__ */ new Map();
+  const exportsField = pkg.exports;
+  if (exportsField !== void 0 && exportsField !== null) {
+    const isSubpathMap = typeof exportsField === "object" && !Array.isArray(exportsField) && Object.keys(exportsField).some((k) => k.startsWith("."));
+    if (isSubpathMap) {
+      for (const [subpath, value] of Object.entries(exportsField)) {
+        if (!subpath.startsWith(".") || subpath.includes("*")) continue;
+        const targets = conditionTargets(value);
+        if (targets.length) entries.set(subpath, targets);
+      }
+    } else {
+      const targets = conditionTargets(exportsField);
+      if (targets.length) entries.set(".", targets);
+    }
+    return entries;
+  }
+  const fallbacks = ["module", "main", "types"].map((k) => pkg[k]).filter((v) => typeof v === "string");
+  if (fallbacks.length) entries.set(".", fallbacks);
+  return entries;
+}
+function entrySource(packageDir, target, compiler, projectRoot) {
+  const absolute = path18.resolve(packageDir, target);
+  if (!isOwnFile(projectRoot, absolute)) return null;
+  const isDeclaration = /\.d\.[cm]?ts$/.test(absolute);
+  if (!isDeclaration && languageOfSourcePath(absolute) && isFile(absolute) && !(compiler.outDir && !path18.relative(compiler.outDir, absolute).startsWith(".."))) {
+    return absolute;
+  }
+  if (!compiler.outDir || !compiler.rootDir) return null;
+  const inOut = path18.relative(compiler.outDir, absolute);
+  if (inOut.startsWith("..") || path18.isAbsolute(inOut)) return null;
+  const extension = BUILD_EXTENSIONS.find((ext) => inOut.endsWith(ext));
+  const stem = extension ? inOut.slice(0, -extension.length) : inOut;
+  for (const ext of SOURCE_EXTENSIONS) {
+    const candidate = path18.join(compiler.rootDir, stem + ext);
+    if (isOwnFile(projectRoot, candidate) && isFile(candidate)) return candidate;
+  }
+  return null;
+}
+function readLocalPackages(projectRoot) {
+  const out = /* @__PURE__ */ new Map();
+  const ts = resolveTypeScript(projectRoot);
+  const root = readJsonFile2(path18.join(projectRoot, "package.json"), null);
+  if (!root || typeof root !== "object" || Array.isArray(root)) return out;
+  const rootPkg = root;
+  const declared = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces && typeof rootPkg.workspaces === "object" && Array.isArray(rootPkg.workspaces.packages) ? rootPkg.workspaces.packages : [];
+  const dirs = [projectRoot];
+  for (const entry of declared) {
+    if (typeof entry !== "string") continue;
+    const key = pathKey(entry).replace(/\/+$/, "");
+    if (!key || path18.isAbsolute(key)) continue;
+    if (key.endsWith("/*")) {
+      const base = path18.resolve(projectRoot, key.slice(0, -2));
+      if (base.includes("*") || !isOwnFile(projectRoot, base)) continue;
+      let children;
+      try {
+        children = fs13.readdirSync(base, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const child of children.slice().sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+        if (child.isDirectory() && child.name !== "node_modules" && !child.name.startsWith(".")) {
+          dirs.push(path18.join(base, child.name));
+        }
+      }
+    } else if (!key.includes("*")) {
+      const dir = path18.resolve(projectRoot, key);
+      if (isOwnFile(projectRoot, dir)) dirs.push(dir);
+    }
+  }
+  for (const dir of dirs) {
+    const pkg = dir === projectRoot ? rootPkg : readJsonFile2(path18.join(dir, "package.json"), null);
+    if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) continue;
+    const name = pkg.name;
+    if (typeof name !== "string" || !name) continue;
+    const tsconfig = readJsonFile2(path18.join(dir, "tsconfig.json"), ts);
+    const options = tsconfig?.compilerOptions ?? {};
+    const compiler = {
+      outDir: typeof options.outDir === "string" ? path18.resolve(dir, options.outDir) : void 0,
+      rootDir: typeof options.rootDir === "string" ? path18.resolve(dir, options.rootDir) : void 0
+    };
+    for (const [subpath, targets] of packageEntries(pkg)) {
+      const specifier = subpath === "." ? name : `${name}/${subpath.replace(/^\.\//, "")}`;
+      if (out.has(specifier)) continue;
+      for (const target of targets) {
+        const source = entrySource(dir, target, compiler, projectRoot);
+        if (source) {
+          out.set(specifier, source);
+          break;
+        }
+      }
+    }
+  }
+  return out;
 }
 function looksBinary(buffer) {
   const probe = buffer.subarray(0, Math.min(buffer.length, 4096));
@@ -27430,6 +27714,9 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
   const seen = /* @__PURE__ */ new Set();
   const exactCache = /* @__PURE__ */ new Map();
   const rootFiles = walkDeclaredRoots(sourceRoots, exclude, projectRoot);
+  const localPackages = readLocalPackages(projectRoot);
+  const packages = {};
+  for (const [specifier, absolute] of localPackages) packages[specifier] = pathKey(path18.relative(projectRoot, absolute));
   const declaredPaths = [];
   for (const impl of implementations) {
     declaredPaths.push(...implementationSourceFiles(impl));
@@ -27475,7 +27762,7 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
       if (ts) {
         try {
           const facts = walkExact(ts, text3, absolute);
-          chaseReexports(ts, facts, absolute, projectRoot, /* @__PURE__ */ new Set([absolute]), exactCache);
+          chaseReexports(ts, facts, absolute, projectRoot, /* @__PURE__ */ new Set([absolute]), exactCache, localPackages);
           analyzed = {
             analysisGrade: "exact",
             declaredNames: [...facts.declared],
@@ -27487,6 +27774,10 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
               ...facts.namedReexports.map(({ exported, local, from }) => ({ exported, local, from })),
               ...facts.starExports.map((from) => ({ exported: "*", local: "*", from }))
             ],
+            exportAliases: facts.exportAliases.map((alias) => ({ ...alias })),
+            returnTypes: Object.fromEntries(
+              [...facts.returnTypes].filter((entry) => entry[1] !== null)
+            ),
             functionComplexity: Object.fromEntries(facts.complexity),
             functionCallSites: Object.fromEntries([...facts.calls].map(([k, v]) => [k, [...v.values()]])),
             functionBodies: Object.fromEntries(facts.bodies),
@@ -27516,7 +27807,7 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
     }
     files.push({ path: sourcePath, status: "analyzed", language, ...analyzed });
   }
-  return { files, projectRoot, rootFiles };
+  return { files, projectRoot, rootFiles, packages };
 }
 var IMPORT_FROM_RE = /(?:^|;)[ \t]*import\s+(?!\()([^'";]*?)\s*from\s*['"]([^'"]+)['"]/gm;
 var DYNAMIC_IMPORT_RE = /\{([^{}]*)\}\s*=\s*await\s+import\(\s*['"]([^'"]+)['"]\s*\)/g;
@@ -46462,6 +46753,7 @@ function loadProjectConfig3() {
   resolveSubsystemExports,
   resolveVariantGuidance,
   retireSpecialists,
+  returnTypeOf,
   rewriteReferences,
   runWithHostedLookup,
   runWithProjectBinding,