@suss/adapter-ruby 0.25.0 → 0.27.0

package/dist/index.js

@@ -15,6 +15,45 @@ function field(node, name) {
 function bodyStatements(body) {
   return body.namedChildren.filter((child) => child !== null);
 }
+var BRANCH_FIELDS = {
+  if: ["consequence", "alternative"],
+  unless: ["consequence", "alternative"],
+  elsif: ["consequence", "alternative"],
+  if_modifier: ["body"],
+  unless_modifier: ["body"],
+  while: ["body"],
+  until: ["body"],
+  while_modifier: ["body"],
+  until_modifier: ["body"],
+  when: ["body"],
+  rescue: ["body"]
+};
+var STATEMENT_LISTS = /* @__PURE__ */ new Set(["then", "else", "do", "ensure", "begin"]);
+var CLAUSE_TYPES = /* @__PURE__ */ new Set(["elsif", "else", "when", "rescue", "ensure"]);
+function nestedStatements(stmt) {
+  const branchFields = BRANCH_FIELDS[stmt.type];
+  if (branchFields !== void 0) {
+    return branchFields.flatMap((name) => {
+      const branch = field(stmt, name);
+      return branch === null ? [] : statementsRunBy(branch);
+    });
+  }
+  if (STATEMENT_LISTS.has(stmt.type)) {
+    return bodyStatements(stmt).flatMap(
+      (child) => CLAUSE_TYPES.has(child.type) ? nestedStatements(child) : [child]
+    );
+  }
+  if (stmt.type === "case") {
+    return bodyStatements(stmt).filter((child) => CLAUSE_TYPES.has(child.type)).flatMap(nestedStatements);
+  }
+  return [];
+}
+function statementsRunBy(branch) {
+  if (STATEMENT_LISTS.has(branch.type) || CLAUSE_TYPES.has(branch.type)) {
+    return nestedStatements(branch);
+  }
+  return [branch];
+}
 var OWN_BODY_TYPES = /* @__PURE__ */ new Set([
   "method",
   "singleton_method",
@@ -78,8 +117,8 @@ var VISIBILITY_KEYWORDS = /* @__PURE__ */ new Set([
   "protected",
   "public"
 ]);
-function visibilityKeyword(text) {
-  return VISIBILITY_KEYWORDS.has(text) ? text : null;
+function visibilityKeyword(text2) {
+  return VISIBILITY_KEYWORDS.has(text2) ? text2 : null;
 }
 function setVisibility(visibility, name, keyword) {
   if (keyword === "public") {
@@ -202,14 +241,31 @@ var NodeMap = class extends IdMap {
 // src/constantPath.ts
 import fs from "fs";
 import path from "path";
-function underscoreConstantPath(qualifiedName) {
-  return qualifiedName.replaceAll("::", "/").replace(/([A-Z\d]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase();
+function underscoreConstantPath(qualifiedName, acronyms = []) {
+  return lowerAcronyms(qualifiedName.replaceAll("::", "/"), acronyms).replace(/([A-Z\d]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase();
+}
+function lowerAcronyms(word, acronyms) {
+  if (acronyms.length === 0) {
+    return word;
+  }
+  const alternatives = acronyms.map(escapeRegExp).join("|");
+  const acronymRegex = new RegExp(
+    `(?:(?<=([A-Za-z\\d]))|\\b)(${alternatives})(?=\\b|[^a-z])`,
+    "g"
+  );
+  return word.replace(
+    acronymRegex,
+    (_match, before, acronym) => `${before === void 0 ? "" : "_"}${acronym.toLowerCase()}`
+  );
+}
+function escapeRegExp(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var PATH_CONVENTIONS = {
   railsUnderscore: underscoreConstantPath
 };
-function resolveConstantFile(root, qualifiedName, convention) {
-  const relative = `${PATH_CONVENTIONS[convention](qualifiedName)}.rb`;
+function resolveConstantFile(root, qualifiedName, convention, acronyms = []) {
+  const relative = `${PATH_CONVENTIONS[convention](qualifiedName, acronyms)}.rb`;
   for (const candidate of [root, ...autoloadDirectories(root)]) {
     const file = path.join(candidate, relative);
     if (fs.existsSync(file)) {
@@ -229,7 +285,7 @@ function autoloadDirectories(root) {
 // src/scope.ts
 function qualifyConstantRef(node, nesting) {
   if (node.type === "scope_resolution") {
-    return node.text;
+    return compoundName(node);
   }
   if (node.type === "constant") {
     const innermost = nesting[0] ?? null;
@@ -239,13 +295,16 @@ function qualifyConstantRef(node, nesting) {
 }
 function constantRefCandidates(node, nesting) {
   if (node.type === "scope_resolution") {
-    return [node.text];
+    return [compoundName(node)];
   }
   if (node.type === "constant") {
     return [...nesting.map((level) => `${level}::${node.text}`), node.text];
   }
   return [];
 }
+function compoundName(node) {
+  return node.text.replace(/^::/, "");
+}
 function shadowingClassFor(node, nesting, knownClasses) {
   if (node.type !== "constant") {
     return null;
@@ -280,12 +339,19 @@ function walkBody(statements, nesting, visit) {
   }
 }
 function ownIdentity(nameNode, outerNesting) {
-  const qualifiedName = qualifyConstantRef(nameNode, outerNesting);
+  const qualifiedName = definedName(nameNode, outerNesting);
   if (qualifiedName === null) {
     return null;
   }
   return { qualifiedName, bodyNesting: [qualifiedName, ...outerNesting] };
 }
+function definedName(nameNode, outerNesting) {
+  const innermost = outerNesting[0] ?? null;
+  if (nameNode.type === "scope_resolution" && innermost !== null && !nameNode.text.startsWith("::")) {
+    return `${innermost}::${nameNode.text}`;
+  }
+  return qualifyConstantRef(nameNode, outerNesting);
+}
 function visitClass(node, nesting, visit) {
   const nameNode = field(node, "name");
   const identity = nameNode !== null ? ownIdentity(nameNode, nesting) : null;
@@ -349,7 +415,8 @@ async function reachDefinition(qualifiedName, lookup) {
   const filePath = resolveConstantFile(
     lookup.root,
     qualifiedName,
-    lookup.pathConvention
+    lookup.pathConvention,
+    lookup.acronyms
   );
   if (filePath === null) {
     return null;
@@ -391,7 +458,10 @@ async function chainOf(self, lookup, active) {
 async function superclassChain(self, lookup, active) {
   const candidates = superclassCandidatesOf(self.blocks);
   for (const candidate of candidates) {
-    if (lookup.ancestryRootClassNames.includes(candidate) || active.has(candidate)) {
+    if (lookup.ancestryRootClassNames.includes(candidate)) {
+      return [{ type: "root", name: candidate }];
+    }
+    if (active.has(candidate)) {
       return [];
     }
     const blocks = await definitionOf(candidate, lookup);
@@ -469,6 +539,9 @@ function superclassCandidatesOf(blocks) {
 }
 function methodInAncestry(ancestry, name) {
   for (const entry of ancestry) {
+    if (entry.type === "root") {
+      return { type: "none" };
+    }
     if (entry.type === "unfollowed") {
       return {
         type: "unsettled",
@@ -775,7 +848,7 @@ var Lowerer = class {
     return [nested];
   }
   /**
-   * `unless ok` runs its body when `ok` is false, so it reads as an `if` on
+   * `unless ok` runs its body when `ok` is false, so it lowers to an `if` on
    * the same test with the two arms the other way around. Without the swap
    * a summary would say a branch runs on the test that skips it.
    */
@@ -791,7 +864,7 @@ var Lowerer = class {
       exitKind: exitKindOf(node)
     };
   }
-  /** `render :gone if expired?` gates one statement on one test, so it reads as an if with one arm, on whichever side the test puts it. */
+  /** `render :gone if expired?` gates one statement on one test, so it lowers to an if with one arm, on whichever side the test puts it. */
   lowerIfModifier(node) {
     const body = field(node, "body");
     const gated = body === null ? [] : [this.lower(body)];
@@ -1204,7 +1277,7 @@ function calledMethod(node) {
 
 // src/values/evaluator.ts
 import { nodeOfKey } from "@suss/resolution";
-import { Evaluator, force, literalOf as literalOf2 } from "@suss/values";
+import { Evaluator, force, literalOf as literalOf2, text } from "@suss/values";
 
 // src/facts/resolve.ts
 import {
@@ -2582,11 +2655,18 @@ function bindEvaluator(db, nodes) {
     )
   );
 }
-function evaluatedValue(node, db) {
-  return force(evaluatorFor(node, db).evaluate(node));
+function evaluatedValue(node, db, bindings) {
+  const evaluator = evaluatorFor(node, db);
+  if (bindings === void 0) {
+    return force(evaluator.evaluate(node));
+  }
+  const supplied = new Map(
+    [...bindings].map(([name, value]) => [name, text(value)])
+  );
+  return force(evaluator.evaluate(node, { bindings: supplied }));
 }
-function stringValueOf(node, db) {
-  return literalOf2(evaluatedValue(node, db));
+function stringValueOf(node, db, bindings) {
+  return literalOf2(evaluatedValue(node, db, bindings));
 }
 function methodDefinitionsIn(file, root) {
   const found = /* @__PURE__ */ new Map();
@@ -3006,8 +3086,11 @@ function receiverPrefix(receiver, method, root, pattern, options) {
 function trimmed(path7) {
   return path7 === "/" ? "" : path7.replace(/\/+$/, "");
 }
-function namesConstant(receiver, constantName) {
-  return (receiver.type === "constant" || receiver.type === "scope_resolution") && receiver.text === constantName;
+function namesConstant(receiver, constantName2) {
+  if (receiver.type === "constant") {
+    return receiver.text === constantName2;
+  }
+  return receiver.type === "scope_resolution" && compoundName(receiver) === constantName2;
 }
 function builtBy(name, method, root, pattern) {
   const builders = pattern.receiverBuilders ?? [];
@@ -3244,8 +3327,7 @@ function controllerFilters(pattern, ancestry) {
       skipNames.set(form.skippedBy, form.name);
     }
   }
-  const declared = [];
-  const skips = [];
+  let declared = [];
   for (const { statement } of inheritedStatements(ancestry)) {
     const called = calledName(statement);
     if (called === null) {
@@ -3253,16 +3335,21 @@ function controllerFilters(pattern, ancestry) {
     }
     const form = byName.get(called);
     if (form !== void 0) {
-      declared.push(...declarationsOf(statement, form));
+      for (const declaration of declarationsOf(statement, form)) {
+        declared = [
+          ...declared.filter((earlier) => !sameFilter(earlier, declaration)),
+          declaration
+        ];
+      }
       continue;
     }
     const skipped = skipNames.get(called);
     if (skipped !== void 0) {
-      skips.push(...skipsOf(statement, skipped));
+      declared = applySkips(declared, skipsOf(statement, skipped));
     }
   }
   const resolved = [];
-  for (const declaration of applySkips(declared, skips)) {
+  for (const declaration of declared) {
     const found = methodInAncestry(ancestry, declaration.methodName);
     if (found.type !== "found") {
       continue;
@@ -3375,6 +3462,9 @@ function skipsOf(statement, filterName) {
   const actions = namesUnder(args.keyword.only);
   return args.positional.map((arg) => symbolValue(arg)).filter((name) => name !== null).map((methodName) => ({ filterName, methodName, actions }));
 }
+function sameFilter(one, other) {
+  return one.filter.name === other.filter.name && one.methodName === other.methodName;
+}
 function applySkips(declared, skips) {
   const left = [];
   for (const declaration of declared) {
@@ -3443,6 +3533,12 @@ function rootConstant(node) {
   }
   return rootConstant(receiver);
 }
+function isConstant(node) {
+  return node.type === "constant" || node.type === "scope_resolution";
+}
+function constantName(constant2) {
+  return constant2.type === "constant" ? constant2.text : compoundName(constant2);
+}
 var ANCESTRY_PROGRAM = deriveOnDemand2(
   [...RESOLUTION_RULES2, ...RESOLUTION_QUESTIONS2],
   ANSWER_RELATIONS2
@@ -3452,13 +3548,22 @@ function reachesBase(facts, classKey, bases) {
   evaluate2(facts, ANCESTRY_PROGRAM.rules);
   return facts.lookup("wantedBaseName", 0, classKey).some((row) => bases.includes(String(row[1])));
 }
-function classBehind(facts, constant2) {
-  const wanted = `#${constant2.text}`;
+function classBehind(facts, file, constant2) {
+  const key = constant2.type === "constant" ? `${file}#${constant2.text}` : nodeId(file, constant2);
   const bound = new Set(
-    facts.facts("binds").filter((row) => String(row[0]).endsWith(wanted)).map((row) => String(row[1]))
+    facts.lookup("binds", 0, key).map((row) => String(row[1]))
   );
   return bound.size === 1 ? [...bound][0] : void 0;
 }
+function modelPattern(constant2, file, options) {
+  const classKey = classBehind(options.facts, file, constant2);
+  if (classKey === void 0) {
+    return void 0;
+  }
+  return options.patterns.find(
+    (candidate) => reachesBase(options.facts, classKey, candidate.baseClasses)
+  );
+}
 function selectorOf(node) {
   const picked = [];
   const walk = (current) => {
@@ -3480,7 +3585,87 @@ function selectorOf(node) {
   walk(node);
   return [...new Set(picked)];
 }
-function storageEffects(calls, options) {
+function storageEffect(call, model, pattern, kind, selector) {
+  const operation = methodOf(call);
+  return {
+    type: "interaction",
+    binding: storageBinding({
+      recognition: "ruby-storage",
+      storageSystem: pattern.storageSystem,
+      scope: "default",
+      container: constantName(model)
+    }),
+    callee: call.text,
+    interaction: {
+      class: "storage-access",
+      kind,
+      fields: [],
+      operation,
+      ...selector.length > 0 ? { selector } : {}
+    }
+  };
+}
+function modelCallEffects(call, file, options) {
+  const constant2 = rootConstant(call);
+  if (constant2 === null) {
+    return [];
+  }
+  const pattern = modelPattern(constant2, file, options);
+  if (pattern === void 0) {
+    return [];
+  }
+  const kind = pattern.writes.includes(methodOf(call)) ? "write" : "read";
+  return [storageEffect(call, constant2, pattern, kind, selectorOf(call))];
+}
+function isLoader(node, loader) {
+  if (node === null) {
+    return false;
+  }
+  if (node.type === "identifier") {
+    return node.text === loader.loader;
+  }
+  return node.type === "call" && receiverOf(node) === null && methodOf(node) === loader.loader;
+}
+function loaderPick(call, loader) {
+  const method = methodOf(call);
+  const receiver = receiverOf(call);
+  if (receiver === null) {
+    return loader.shortcuts.includes(method) ? call : null;
+  }
+  if (!loader.reads.includes(method) || receiver.type !== "call") {
+    return null;
+  }
+  const picks = methodOf(receiver) === loader.pick && isLoader(receiverOf(receiver), loader);
+  return picks ? receiver : null;
+}
+function loaderCallEffects(call, file, options) {
+  const effects = [];
+  for (const loader of options.loaders ?? []) {
+    const pick = loaderPick(call, loader);
+    if (pick === null) {
+      continue;
+    }
+    const args = field(pick, "arguments");
+    for (const argument of args === null ? [] : children3(args)) {
+      if (!isConstant(argument)) {
+        continue;
+      }
+      const pattern = modelPattern(argument, file, options);
+      if (pattern !== void 0) {
+        effects.push(storageEffect(call, argument, pattern, "read", []));
+      }
+    }
+  }
+  return effects;
+}
+function effectsOfCall(call, file, options) {
+  const onModel = modelCallEffects(call, file, options);
+  return onModel.length > 0 ? onModel : loaderCallEffects(call, file, options);
+}
+function storageClaims(call, file, options) {
+  return options.patterns.length > 0 && effectsOfCall(call, file, options).length > 0;
+}
+function storageEffects(calls, file, options) {
   if (options.patterns.length === 0) {
     return [];
   }
@@ -3496,39 +3681,7 @@ function storageEffects(calls, options) {
     if (partOfOne.has(call.id)) {
       continue;
     }
-    const constant2 = rootConstant(call);
-    if (constant2 === null) {
-      continue;
-    }
-    const classKey = classBehind(options.facts, constant2);
-    if (classKey === void 0) {
-      continue;
-    }
-    const pattern = options.patterns.find(
-      (candidate) => reachesBase(options.facts, classKey, candidate.baseClasses)
-    );
-    if (pattern === void 0) {
-      continue;
-    }
-    const operation = methodOf(call);
-    const picked = selectorOf(call);
-    effects.push({
-      type: "interaction",
-      binding: storageBinding({
-        recognition: "ruby-storage",
-        storageSystem: pattern.storageSystem,
-        scope: pattern.baseClasses[0] ?? "",
-        container: constant2.text
-      }),
-      callee: call.text,
-      interaction: {
-        class: "storage-access",
-        kind: pattern.writes.includes(operation) ? "write" : "read",
-        fields: [],
-        operation,
-        ...picked.length > 0 ? { selector: picked } : {}
-      }
-    });
+    effects.push(...effectsOfCall(call, file, options));
   }
   return effects;
 }
@@ -3570,7 +3723,7 @@ function typeShapeFromNode(node, ctx) {
     };
   }
   if (node.type === "scope_resolution") {
-    const qualified = node.text;
+    const qualified = compoundName(node);
     const scalar = ctx.scalars[scalarLookupName(qualified, ctx.scalarNamePrefixes)];
     if (scalar !== void 0) {
       return scalar;
@@ -3607,6 +3760,7 @@ function fieldReadContext(pattern, cache, fileBlocks, bodyRead) {
     lookup: {
       root: pattern.root,
       pathConvention: pattern.pathConvention,
+      acronyms: pattern.acronyms ?? [],
       ancestryRootClassNames: pattern.ancestryRootClassNames,
       parsedFile: (absPath) => cache.get(absPath),
       localDefinition: (name) => sameFileBlocks(name, fileBlocks)
@@ -3721,12 +3875,16 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
   const lookup = {
     root: pattern.root,
     pathConvention: pattern.pathConvention,
+    acronyms: pattern.acronyms ?? [],
     ancestryRootClassNames: pattern.ancestryRootClassNames,
     parsedFile: (absPath) => options.cache.get(absPath),
     localDefinition: (name) => sameFileBlocks(name, fileBlocks)
   };
   const ancestry = await ancestryOf(info.qualifiedName, ownBlocks, lookup);
-  if (!reachesConfiguredBase(ancestry, info.qualifiedName, pattern.baseClassNames)) {
+  if (!reachesConfiguredBase(ancestry, info.qualifiedName, [
+    ...pattern.baseClassNames,
+    ...pattern.ancestryRootClassNames
+  ])) {
     return [];
   }
   const filters = controllerFilters(pattern, ancestry);
@@ -3737,7 +3895,7 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       filter,
       pattern,
       displayPath,
-      bodyOfMethod(filter.method, options)
+      bodyOfMethod(filter.method, filter.file, options)
     );
     units.push(raw);
     options.onReachSeed?.(raw, {
@@ -3746,47 +3904,77 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       enclosingQualifiedName: filter.enclosingQualifiedName
     });
   }
-  for (const block of ownBlocks) {
-    if (block.info.bodyNode === null) {
+  const emitAction = (actionName, method, block) => {
+    const around = filters.filter((filter) => filterCoversAction(filter, actionName)).map(
+      (filter) => filterReference(
+        filter,
+        options.displayPathOf?.(filter.file) ?? filter.file
+      )
+    );
+    const raw = buildControllerActionUnit(
+      pack,
+      pattern,
+      info.qualifiedName,
+      actionName,
+      method,
+      {
+        display: block.file === (options.absoluteFile ?? options.filePath) ? options.filePath : options.displayPathOf?.(block.file) ?? block.file,
+        absolute: block.file
+      },
+      options,
+      around
+    );
+    units.push(raw);
+    options.onReachSeed?.(raw, {
+      file: block.file,
+      node: method,
+      enclosingQualifiedName: block.info.qualifiedName
+    });
+  };
+  const own = /* @__PURE__ */ new Set();
+  for (const [actionName, method, block] of publicInstanceMethods(ownBlocks)) {
+    own.add(actionName);
+    emitAction(actionName, method, block);
+  }
+  const seen = new Set(own);
+  for (const entry of ancestry) {
+    if (entry.type !== "bodies" || entry.name === info.qualifiedName) {
       continue;
     }
-    const visibility = instanceMethodVisibility(block.info.bodyNode);
-    for (const [actionName, method] of instanceMethodsByName(
-      block.info.bodyNode
+    for (const [actionName, method, block] of publicInstanceMethods(
+      entry.blocks
     )) {
-      if ((visibility.get(actionName) ?? "public") !== "public") {
+      if (seen.has(actionName)) {
         continue;
       }
-      const around = filters.filter((filter) => filterCoversAction(filter, actionName)).map(
-        (filter) => filterReference(
-          filter,
-          options.displayPathOf?.(filter.file) ?? filter.file
-        )
-      );
-      const raw = buildControllerActionUnit(
-        pack,
-        pattern,
-        info.qualifiedName,
-        actionName,
-        method,
-        options.filePath,
-        options,
-        around
-      );
-      units.push(raw);
-      options.onReachSeed?.(raw, {
-        file: block.file,
-        node: method,
-        enclosingQualifiedName: info.qualifiedName
-      });
+      seen.add(actionName);
+      if (pattern.routeFor(info.qualifiedName, actionName) === null) {
+        continue;
+      }
+      emitAction(actionName, method, block);
     }
   }
   return units;
 }
-function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actionName, method, filePath, bodyRead, wrappers = []) {
+function publicInstanceMethods(blocks) {
+  const found = [];
+  for (const block of blocks) {
+    if (block.info.bodyNode === null) {
+      continue;
+    }
+    const visibility = instanceMethodVisibility(block.info.bodyNode);
+    for (const [name, method] of instanceMethodsByName(block.info.bodyNode)) {
+      if ((visibility.get(name) ?? "public") === "public") {
+        found.push([name, method, block]);
+      }
+    }
+  }
+  return found;
+}
+function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actionName, method, file, bodyRead, wrappers = []) {
   const range = rangeOf(method);
   const route = pattern.routeFor(controllerQualifiedName, actionName);
-  const body = bodyOfMethod(method, bodyRead);
+  const body = bodyOfMethod(method, file.absolute, bodyRead);
   const perResponse = responseBranches(
     method,
     pattern,
@@ -3798,7 +3986,7 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
       name: actionName,
       nameKind: "binding",
       kind: "handler",
-      file: filePath,
+      file: file.display,
       range,
       span: spanOf(method),
       exportName: actionName,
@@ -3917,12 +4105,12 @@ function branchesFor(body, range) {
     }
   ];
 }
-function bodyOfMethod(method, bodyRead = {}) {
+function bodyOfMethod(method, file, bodyRead = {}) {
   const effects = invocationEffects(method, bodyRead.inheritedMethods);
   const storage = bodyRead.storage;
   const extra = [
     ...envReadEffects(method),
-    ...storage === void 0 ? [] : storageEffects(callsUnder2(method), storage)
+    ...storage === void 0 ? [] : storageEffects(callsUnder2(method), file, storage)
   ];
   return {
     bodyContent: methodHasStatements(method) ? "statements" : "empty",
@@ -3953,7 +4141,7 @@ function methodNotSettled(reason, range) {
 function bodyFromLookup(found, range, subject, nothingThere, bodyRead) {
   const table = {
     found: (lookup) => ({
-      ...bodyOfMethod(lookup.method, bodyRead),
+      ...bodyOfMethod(lookup.method, lookup.block.file, bodyRead),
       reachSeed: {
         file: lookup.block.file,
         node: lookup.method,
@@ -4317,11 +4505,10 @@ function collectFileConstants(filePath, root) {
     if ((node.type === "constant" || node.type === "scope_resolution") && !isDeclaration(node, parent)) {
       const written = writtenName(node);
       if (written !== null) {
-        references.push({
-          key: node.type === "constant" ? `${filePath}#${node.text}` : nodeId(filePath, node),
-          written,
-          nesting
-        });
+        const key = node.type === "constant" ? `${filePath}#${node.text}` : nodeId(filePath, node);
+        references.push(
+          written.startsWith("::") ? { key, written: written.slice(2), nesting: [] } : { key, written, nesting }
+        );
       }
     }
     for (const child of children4(node)) {
@@ -4913,7 +5100,8 @@ async function scanBody(source, ctx, options) {
     );
     if (outcome.kind === "stopped") {
       const stopKey = `${outcome.reason}:${callee}`;
-      if (!seen.has(stopKey) && worthRecording(outcome.reason)) {
+      const claimed = options.storage !== void 0 && storageClaims(call, source.file, options.storage);
+      if (!seen.has(stopKey) && !claimed && worthRecording(outcome.reason)) {
         seen.add(stopKey);
         stops.push({ callee, reason: outcome.reason });
       }
@@ -4944,7 +5132,7 @@ async function scanBody(source, ctx, options) {
 }
 function libraryUnit(target, options) {
   const { file, node, name, exportPath } = target;
-  const body = bodyOfMethod(node, options);
+  const body = bodyOfMethod(node, file, options);
   const range = rangeOf(node);
   return {
     identity: {
@@ -5037,7 +5225,8 @@ function inheritedMethodsIn(packs) {
   return found;
 }
 function alreadyDiscovered(seen, raw) {
-  const key = `${raw.identity.file}::${raw.identity.name}::${raw.identity.range.start}`;
+  const reported = raw.identity.exportPath?.join(".") ?? raw.identity.name;
+  const key = `${raw.identity.file}::${reported}::${raw.identity.range.start}`;
   if (seen.has(key)) {
     return true;
   }
@@ -5101,6 +5290,8 @@ async function extractRubyProject(options) {
     bindEvaluator(db, { files: parsed, definitions });
   });
   const storagePatterns = options.packs.flatMap((pack) => pack.storage ?? []);
+  const loaderPatterns = options.packs.flatMap((pack) => pack.loaders ?? []);
+  const storage = storagePatterns.length > 0 ? { facts: db, patterns: storagePatterns, loaders: loaderPatterns } : void 0;
   const inheritedMethods = inheritedMethodsIn(options.packs);
   const displayPathOf = (file) => options.workspaceRoot !== void 0 ? path4.relative(options.workspaceRoot, file) : file;
   const seeds = [];
@@ -5116,7 +5307,7 @@ async function extractRubyProject(options) {
         filePath: displayPath,
         absoluteFile: file,
         cache,
-        ...storagePatterns.length > 0 ? { storage: { facts: db, patterns: storagePatterns } } : {},
+        ...storage === void 0 ? {} : { storage },
         inheritedMethods,
         displayPathOf,
         facts: db,
@@ -5195,7 +5386,7 @@ async function extractRubyProject(options) {
     () => reachedFunctions(seeds, {
       files: parsed,
       displayPathOf,
-      ...storagePatterns.length > 0 ? { storage: { facts: db, patterns: storagePatterns } } : {},
+      ...storage === void 0 ? {} : { storage },
       inheritedMethods
     })
   );
@@ -5334,8 +5525,8 @@ function displayNameOf(node) {
   if (node.type === "class" || node.type === "module") {
     return field(node, "name")?.text ?? node.text;
   }
-  const text = node.text.split("\n")[0].trim();
-  return text.length > 40 ? `${text.slice(0, 40)}...` : text;
+  const text2 = node.text.split("\n")[0].trim();
+  return text2.length > 40 ? `${text2.slice(0, 40)}...` : text2;
 }
 function width(node) {
   return node.endIndex - node.startIndex;
@@ -5362,14 +5553,14 @@ var RubyWhySession = class {
    * The smallest expression on `line` of `file` whose text is exactly
    * `text`, or null.
    */
-  findExpression(file, line, text) {
+  findExpression(file, line, text2) {
     const root = this.rootOf(file);
     if (root === null) {
       return null;
     }
     let found = null;
     const visit = (node) => {
-      if (node.startPosition.row + 1 === line && node.text === text) {
+      if (node.startPosition.row + 1 === line && node.text === text2) {
         if (found === null || width(node) <= width(found)) {
           found = node;
         }
@@ -5539,6 +5730,7 @@ export {
   inheritedStatements,
   methodDefinitionsIn,
   methodInAncestry,
+  nestedStatements,
   nodeId,
   parseRuby,
   parseRubySync,