@sous-io/sous 0.2.32 → 0.2.33

package/src/lib/repos/recipe-memories.ts

@@ -0,0 +1,175 @@
+/**
+ * The memories the project's active recipes publish, listed for the `#memories`
+ * view and for the build's check that every one of them reached an output.
+ *
+ * A recipe is ACTIVE when the project holds it directly or a co-subscription
+ * does (its lockfile kind is `subscribes`); a recipe held only through
+ * `depends` is a library and contributes nothing. A memory is a file matched by
+ * an include pattern of a manifest `contents` entry of `kind: memories`, and its
+ * virtual path is `<namespace>/<recipe>/<path>`, the path being relative to the
+ * static base of that pattern.
+ *
+ * Order: a recipe comes after every pinned recipe it depends on or subscribes
+ * to, ties go to the recipe key (bytewise), and the recipes matching
+ * `recipes.memories.first` move to the front in that same relative order. Within
+ * a recipe, files are in bytewise path order. Recipes matching
+ * `recipes.memories.exclude` are not listed.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { globSync } from "glob";
+import { compareBytewise } from "../../services/ref-resolver/index.js";
+import { realPathInside } from "../include-resolver.js";
+import { inferGlobBase } from "../markdown-compiler.js";
+import { compileRecipeKeyMatcher } from "./recipe-key-matcher.js";
+import {
+  listLockedRecipes,
+  readRecipeManifestIn,
+  type LockedRecipeLocation,
+} from "./locked-recipes.js";
+
+/** One memory file an active recipe publishes. */
+export type MemoryFile = {
+  /** The recipe key, `namespace/recipe`. */
+  recipe: string;
+  /** The path inside the `#memories` view, without the `#memories/` prefix. */
+  path: string;
+  /** The real file's absolute path. */
+  file: string;
+  /** The file's path relative to its recipe's directory, for messages. */
+  relative: string;
+};
+
+/** What listing the memories needs. */
+export type MemoryListingOptions = {
+  /** The project's `.sous/` directory. */
+  sousDir: string;
+  /** The environment to read; decides where the store is. */
+  env?: NodeJS.ProcessEnv;
+  /** `recipes.memories.first`: recipes whose memories lead. */
+  first?: readonly string[] | undefined;
+  /** `recipes.memories.exclude`: recipes whose memories are left out. */
+  exclude?: readonly string[] | undefined;
+  /** The locked recipes, when the caller has already located them. */
+  locked?: LockedRecipeLocation[];
+  /**
+   * Receives a sentence for each memory skipped because its real path is
+   * outside its recipe's directory. Defaults to one line on stderr per file.
+   */
+  onWarning?: (message: string) => void;
+};
+
+/** Files already warned about by the default sink, so a repeated listing warns once. */
+const warnedFiles = new Set<string>();
+
+/** The default warning sink: one line on stderr, once per file. */
+function warnOnce(message: string): void {
+  if (warnedFiles.has(message)) return;
+  warnedFiles.add(message);
+  process.stderr.write(`Warning: ${message}\n`);
+}
+
+/**
+ * Orders recipe keys so each comes after every pinned recipe it depends on or
+ * subscribes to, ties by key. A lockfile entry's `requestedBy` names the recipes
+ * that asked for it, which is the dependency edge read backwards. A cycle (which
+ * a resolved lockfile should not hold) leaves its members in key order at the end.
+ *
+ * @param locked - Every pinned recipe.
+ */
+export function dependencyOrder(locked: readonly LockedRecipeLocation[]): string[] {
+  // A recipe waits for every pinned recipe that lists it among its holders.
+  const waitingOn = new Map<string, Set<string>>();
+  for (const recipe of locked) waitingOn.set(recipe.key, new Set());
+  for (const dependency of locked) {
+    for (const holder of dependency.requestedBy) {
+      if (holder !== dependency.key) waitingOn.get(holder)?.add(dependency.key);
+    }
+  }
+
+  const ordered: string[] = [];
+  const done = new Set<string>();
+  const remaining = [...waitingOn.keys()].sort(compareBytewise);
+  while (remaining.length > 0) {
+    const index = remaining.findIndex((key) => [...waitingOn.get(key)!].every((dep) => done.has(dep)));
+    if (index === -1) {
+      ordered.push(...remaining);
+      break;
+    }
+    const [key] = remaining.splice(index, 1);
+    ordered.push(key!);
+    done.add(key!);
+  }
+  return ordered;
+}
+
+/**
+ * Lists the memories of every active recipe, in view order, with the recipes
+ * that `exclude` names left out.
+ *
+ * @param options - The project, and the `first` and `exclude` lists.
+ */
+export function listMemories(options: MemoryListingOptions): MemoryFile[] {
+  const locked =
+    options.locked ??
+    listLockedRecipes({
+      sousDir: options.sousDir,
+      ...(options.env === undefined ? {} : { env: options.env }),
+    });
+  if (locked.length === 0) return [];
+
+  const isFirst = compileRecipeKeyMatcher(options.first, "recipes.memories.first");
+  const isExcluded = compileRecipeKeyMatcher(options.exclude, "recipes.memories.exclude");
+  const byKey = new Map(locked.map((recipe) => [recipe.key, recipe]));
+
+  const order = dependencyOrder(locked);
+  const leading = order.filter((key) => isFirst(key));
+  const rest = order.filter((key) => !isFirst(key));
+
+  const files: MemoryFile[] = [];
+  for (const key of [...leading, ...rest]) {
+    const recipe = byKey.get(key)!;
+    if (recipe.kind !== "subscribes" || !recipe.present || isExcluded(key)) continue;
+    const manifest = readRecipeManifestIn(recipe.dir);
+    if (manifest === undefined) continue;
+
+    const mine = new Map<string, MemoryFile>();
+    for (const content of manifest.contents) {
+      if (content.kind !== "memories") continue;
+      const ignore = (content.exclude ?? []).map((pattern) => path.join(recipe.dir, pattern));
+      for (const include of content.include) {
+        const pattern = path.join(recipe.dir, include);
+        const base = inferGlobBase(pattern);
+        for (const file of globSync(pattern, { absolute: true, ignore, dot: true })) {
+          if (!isFile(file)) continue;
+          if (!realPathInside(file, recipe.dir)) {
+            (options.onWarning ?? warnOnce)(
+              `The memory ${file} of the recipe ${key} was left out, because it is a link ` +
+                `that leads outside the recipe's directory. Replace the link with the file itself.`
+            );
+            continue;
+          }
+          const inside = path.relative(base, file).split(path.sep).join("/");
+          mine.set(file, {
+            recipe: key,
+            path: `${key}/${inside}`,
+            file,
+            relative: path.relative(recipe.dir, file).split(path.sep).join("/"),
+          });
+        }
+      }
+    }
+    files.push(...[...mine.values()].sort((a, b) => compareBytewise(a.path, b.path)));
+  }
+  return files;
+}
+
+/** True when the path is a regular file. */
+function isFile(candidate: string): boolean {
+  try {
+    return fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}

package/src/lib/repos/recipe-targets.ts

@@ -2,11 +2,12 @@
  * Turning subscribed recipes into compile targets.
  *
  * A recipe's manifest lists what it contributes: skills, memories, prompts and
- * config layers. Everything but the config layers is compiled exactly the way a
- * project's own `entryGlob` target is: the recipe's directory is the glob root,
- * the static part of each include pattern is the base the output tree mirrors,
- * and the `.tpl.` convention applies unchanged. Nothing about a recipe's files
- * is special once they are on disk.
+ * config layers. Only skills are copied into the project, compiled exactly the
+ * way a project's own `entryGlob` target is: the recipe's directory is the glob
+ * root, the static part of each include pattern is the base the output tree
+ * mirrors, and the `.tpl.` convention applies unchanged. Memories reach an agent
+ * through include lines, never as copied files, and config layers are loaded
+ * rather than written.
  *
  * Two rules decide what is compiled at all:
  *
@@ -14,10 +15,10 @@
  *     only through `depends` is fetched, pinned and addressable from the recipe
  *     that declared it, but its files never enter the project's output; that is
  *     the whole difference between the two dependency kinds.
- *   - A content kind with nowhere to go is skipped, with ONE warning naming the
- *     `recipeOutputs` config key. Only `skills` has a default, because
- *     `.claude/skills` is where every agent looks; sous cannot guess where a
- *     project wants its memories or its prompts.
+ *   - Skills go to `recipes.skills.outputs`, which defaults to
+ *     `.claude/skills` because that is where every agent looks. Prompts have no
+ *     destination yet, so a recipe that publishes them is skipped with ONE
+ *     warning naming the `recipes` config key.
  *
  * A recipe's `config` contents are not handled here. They are config layers, and
  * config layers are loaded before any of this runs; see
@@ -38,8 +39,11 @@ import {
   type LockedRecipeLocation,
 } from "./locked-recipes.js";
 
-/** The content kinds that produce files in a project. `config` is a layer, not a file. */
-export const WRITABLE_CONTENT_KINDS = ["skills", "memories", "prompts"] as const;
+/**
+ * The content kinds whose files are copied into a project. `config` is a layer,
+ * and `memories` are reached by include lines rather than copied.
+ */
+export const WRITABLE_CONTENT_KINDS = ["skills"] as const;
 
 /** One content kind whose files land somewhere in the project. */
 export type WritableContentKind = (typeof WRITABLE_CONTENT_KINDS)[number];
@@ -48,7 +52,7 @@ export type WritableContentKind = (typeof WRITABLE_CONTENT_KINDS)[number];
 export type RecipeTargetOptions = {
   /** The project's `.sous/` directory. */
   sousDir: string;
-  /** The merged project config, read for `recipeOutputs`. */
+  /** The merged project config, read for `recipes.skills.outputs`. */
   settings: Settings;
   /** The resolved settings scope, used to substitute `${var}` in destinations. */
   scope?: VarScope;
@@ -98,7 +102,7 @@ export function destinationsFor(
   kind: WritableContentKind,
   options: RecipeTargetOptions
 ): string[] {
-  const configured = options.settings.recipeOutputs?.[kind];
+  const configured = options.settings.recipes?.[kind]?.outputs;
 
   if (configured === undefined || configured.length === 0) {
     // `.claude/skills` is where every agent looks, so it is worth defaulting.
@@ -113,7 +117,7 @@ export function destinationsFor(
       substituteVarsStrict(
         destination,
         options.scope ?? {},
-        `recipeOutputs.${kind}[${index}]`
+        `recipes.${kind}.outputs[${index}]`
       )
     )
   );
@@ -143,7 +147,7 @@ export function buildRecipeTargets(options: RecipeTargetOptions): RecipeTargets
   if (locked.length === 0) return result;
 
   const destinationCache = new Map<WritableContentKind, string[]>();
-  const kindsWithNowhereToGo = new Set<WritableContentKind>();
+  let skippedPrompts = false;
   const destinations = new Set<string>();
   const watchDirs = new Set<string>();
 
@@ -158,6 +162,10 @@ export function buildRecipeTargets(options: RecipeTargetOptions): RecipeTargets
 
     for (const content of manifest.contents) {
       const kind = content.kind;
+      if (kind === "prompts") {
+        skippedPrompts = true;
+        continue;
+      }
       if (!isWritableKind(kind)) continue;
 
       if (!destinationCache.has(kind)) {
@@ -165,10 +173,7 @@ export function buildRecipeTargets(options: RecipeTargetOptions): RecipeTargets
       }
       const kindDestinations = destinationCache.get(kind)!;
 
-      if (kindDestinations.length === 0) {
-        kindsWithNowhereToGo.add(kind);
-        continue;
-      }
+      if (kindDestinations.length === 0) continue;
 
       for (const destination of kindDestinations) destinations.add(destination);
       if (recipe.linked) watchDirs.add(recipe.dir);
@@ -198,16 +203,10 @@ export function buildRecipeTargets(options: RecipeTargetOptions): RecipeTargets
     }
   }
 
-  if (kindsWithNowhereToGo.size > 0) {
-    const kinds = [...kindsWithNowhereToGo].sort();
+  if (skippedPrompts) {
     result.warnings.push(
-      `Some subscribed recipes contribute ${kinds.join(" and ")} files, and this ` +
-        `project has nowhere to put them, so they were skipped.\n` +
-        `Name a destination directory for each kind under the 'recipeOutputs' key of ` +
-        `your sous config, for example:\n` +
-        `  recipeOutputs: { ${kinds
-          .map((kind) => `${kind}: ["\${projectRoot}/${kind}"]`)
-          .join(", ")} }`
+      `Some subscribed recipes contribute prompts, and the 'recipes' key of your sous ` +
+        `config has no destination for prompts yet, so they were skipped.`
     );
   }
 

package/src/lib/repos/ref-search.ts

@@ -1,7 +1,7 @@
 /**
  * What was searched when a ref matched nothing.
  *
- * Resolving a ref itself lives in `src/lib/refs/`, which every command shares.
+ * Resolving a ref itself lives in `src/services/ref-resolver/`, which every command shares.
  * All that is left here is the one thing only a repository search can say: which
  * repositories were actually looked in, and which were trusted but unreadable,
  * so the reader can tell "the name is wrong" from "the repository holding it

package/src/lib/repos/release/index-builder.ts

@@ -75,8 +75,15 @@ import {
   type GatheredDeclaration,
 } from "../declarations.js";
 import type { DependencyKind } from "../formats/common.js";
-import { isNamedReading, namespaceOfKey, parseRef, refKey } from "../../refs/parse.js";
-import { RefSource } from "../../refs/scopes.js";
+import {
+  RefSource,
+  isNamedRef,
+  locationOf,
+  namespaceOfKey,
+  rangeOf,
+  sharedRefResolver,
+  shortKey,
+} from "../../../services/ref-resolver/index.js";
 import type { SettledDependency } from "./settle.js";
 
 /** A version that is ready to publish but has no tag yet. */
@@ -547,7 +554,7 @@ function declaredDependencies(
 
     let readings;
     try {
-      readings = parseRef(written, RefSource.Manifest);
+      readings = sharedRefResolver().parse(written, RefSource.Manifest).refs;
     } catch {
       // A dependency that does not parse is already reported by validation.
       continue;
@@ -555,32 +562,33 @@ function declaredDependencies(
     // Several readings, or a browser path, are settled above or reported by
     // the settling step; there is nothing more to record here.
     const parsed = readings[0]!;
-    if (readings.length !== 1 || !isNamedReading(parsed)) continue;
+    if (readings.length !== 1 || !isNamedRef(parsed)) continue;
 
-    if (parsed.location !== undefined) {
+    const location = locationOf(parsed);
+    if (location !== undefined) {
       // A whole namespace in another repository is read from that repository's
       // own index by the consumer; only a recipe has a key to record.
-      if (parsed.recipe !== undefined) {
-        byKey.set(refKey(parsed), {
+      if (parsed.kind === "recipe") {
+        byKey.set(shortKey(parsed), {
           where: "remote",
-          repo: parsed.location.identity,
-          range: parsed.range ?? "*",
+          repo: location.identity,
+          range: rangeOf(parsed) ?? "*",
         });
-        cover(refKey(parsed), { written, kind, named: true });
+        cover(shortKey(parsed), { written, kind, named: true });
       }
       continue;
     }
 
-    if (parsed.recipe !== undefined) {
-      addSibling(refKey(parsed), parsed.range, true);
-      cover(refKey(parsed), { written, kind, named: true });
+    if (parsed.kind === "recipe") {
+      addSibling(shortKey(parsed), rangeOf(parsed), true);
+      cover(shortKey(parsed), { written, kind, named: true });
       continue;
     }
 
     // A whole-namespace dependency means every recipe in that namespace.
-    namespaces.add(parsed.namespace);
+    namespaces.add(parsed.name);
     for (const entry of validation.recipes) {
-      if (entry.manifest.namespace !== parsed.namespace) continue;
+      if (entry.manifest.namespace !== parsed.name) continue;
       if (entry.key === recipe.key) continue;
       addSibling(entry.key, undefined, false);
       cover(entry.key, { written, kind, named: false });

package/src/lib/repos/release/plan.ts

@@ -24,8 +24,15 @@
 import path from "node:path";
 import semver from "semver";
 import { hashDirectory } from "../store/hash.js";
-import { isNamedReading, parseRef, splitRecipeKey } from "../../refs/parse.js";
-import { RefSource } from "../../refs/scopes.js";
+import {
+  RefSource,
+  isNamedRef,
+  locationOf,
+  namespaceOf,
+  sharedRefResolver,
+  shortKey,
+  splitRecipeKey,
+} from "../../../services/ref-resolver/index.js";
 import type { RunOptions } from "../providers/git.js";
 import { listRecipeTags, tagFor, withTaggedTree, type RecipeTag } from "./tags.js";
 import { nextVersion, type BumpLevel } from "./bump.js";
@@ -346,20 +353,20 @@ export function siblingKeysOf(validation: RepoValidation, key: string): string[]
   for (const written of declared) {
     let readings;
     try {
-      readings = parseRef(written, RefSource.Manifest);
+      readings = sharedRefResolver().parse(written, RefSource.Manifest).refs;
     } catch {
       continue;
     }
     const parsed = readings[0]!;
-    if (!isNamedReading(parsed) || parsed.location !== undefined) continue;
+    if (!isNamedRef(parsed) || locationOf(parsed) !== undefined) continue;
 
-    if (parsed.recipe !== undefined) {
-      keys.push(`${parsed.namespace}/${parsed.recipe}`);
+    if (parsed.kind === "recipe") {
+      keys.push(shortKey(parsed));
       continue;
     }
     // A whole-namespace dependency means every recipe in it.
     for (const entry of validation.recipes) {
-      if (entry.manifest.namespace === parsed.namespace && entry.key !== key) {
+      if (entry.manifest.namespace === namespaceOf(parsed)!.name && entry.key !== key) {
         keys.push(entry.key);
       }
     }

package/src/lib/repos/release/settle.ts

@@ -21,26 +21,17 @@
  * naming the spellings that read one way (the `/*` form for the namespace).
  */
 
-import { parseIndexFile, type IndexFile } from "../formats/index-file.js";
-import { INDEX_FILENAME } from "../formats/common.js";
+import type { ProviderOptions, RepoProvider } from "../providers/index.js";
 import {
-  builtInProviders,
-  providerById,
-  type ProviderOptions,
-  type RepoProvider,
-} from "../providers/index.js";
-import {
-  formatRef,
-  isBrowsedReading,
-  isNamedReading,
-  parseRef,
-  refKey,
-  type ParsedRef,
-  type RefLocation,
-  type RefReading,
-} from "../../refs/parse.js";
-import { settleInIndex } from "../../refs/settle.js";
-import { RefSource } from "../../refs/scopes.js";
+  FetchedIndexLookup,
+  RefSource,
+  locationOf,
+  namespaceOf,
+  rangeOf,
+  sharedRefResolver,
+  shortKey,
+  type SousRef,
+} from "../../../services/ref-resolver/index.js";
 import { describeError, type RepoValidation, type ValidationProblem } from "./validate.js";
 
 /** What one dependency settled on. */
@@ -78,8 +69,11 @@ export type SettleOptions = {
  *
  * @param readings - Every reading of the dependency.
  */
-export function needsSettling(readings: RefReading[]): boolean {
-  return readings.length > 1 || readings.some(isBrowsedReading);
+export function needsSettling(readings: SousRef[]): boolean {
+  return (
+    readings.length > 1 ||
+    readings.some((reading) => reading.kind === "repo" && reading.browsed !== undefined)
+  );
 }
 
 /**
@@ -95,19 +89,13 @@ export async function settleDependencyLocations(
   validation: RepoValidation,
   options: SettleOptions = {}
 ): Promise<SettleResult> {
-  const providers = options.providers ?? builtInProviders();
   const settled = new Map<string, SettledDependency>();
   const problems: ValidationProblem[] = [];
-  const indexes = new Map<string, Promise<IndexFile>>();
-
-  const indexOf = (location: RefLocation): Promise<IndexFile> => {
-    let pending = indexes.get(location.identity);
-    if (pending === undefined) {
-      pending = fetchIndexAt(location, providers, options.providerOptions ?? {});
-      indexes.set(location.identity, pending);
-    }
-    return pending;
-  };
+  const lookup = new FetchedIndexLookup({
+    subject: "dependency",
+    ...(options.providers === undefined ? {} : { providers: options.providers }),
+    ...(options.providerOptions === undefined ? {} : { providerOptions: options.providerOptions }),
+  });
 
   for (const recipe of validation.recipes) {
     const declared = [...(recipe.manifest.depends ?? []), ...(recipe.manifest.subscribes ?? [])];
@@ -115,9 +103,9 @@ export async function settleDependencyLocations(
       const trimmed = written.trim();
       if (settled.has(trimmed)) continue;
 
-      let readings: RefReading[];
+      let readings: SousRef[];
       try {
-        readings = parseRef(trimmed, RefSource.Manifest, providers);
+        readings = sharedRefResolver().parse(trimmed, RefSource.Manifest).refs;
       } catch {
         // Validation already reported a dependency that does not parse.
         continue;
@@ -126,7 +114,7 @@ export async function settleDependencyLocations(
 
       const where = `${recipe.path} ('${trimmed}')`;
       try {
-        settled.set(trimmed, await settleOne(trimmed, readings, indexOf, providers));
+        settled.set(trimmed, await settleOne(readings, lookup));
       } catch (error) {
         problems.push({ level: "error", where, message: describeError(error) });
       }
@@ -137,101 +125,30 @@ export async function settleDependencyLocations(
 }
 
 /**
- * Settles one dependency: fetches the index behind each reading, and keeps the
- * one reading that publishes what it names.
+ * Settles one dependency: the one reading whose repository's index publishes
+ * what it names.
  *
- * @param written - The dependency as written.
- * @param readings - Every reading of it.
- * @param indexOf - Fetches (once) the index at a location.
- * @param providers - The providers, for formatting.
+ * @param readings - Every reading of the dependency.
+ * @param lookup - The fetched indexes.
  */
 async function settleOne(
-  written: string,
-  readings: RefReading[],
-  indexOf: (location: RefLocation) => Promise<IndexFile>,
-  providers: RepoProvider[]
+  readings: SousRef[],
+  lookup: FetchedIndexLookup
 ): Promise<SettledDependency> {
-  const found: Array<{ reading: RefReading; settled: ParsedRef[]; index: IndexFile }> = [];
-
-  for (const reading of readings) {
-    const location = reading.location;
-    /* c8 ignore next */
-    if (location === undefined) continue;
-
-    let index: IndexFile;
-    try {
-      index = await indexOf(location);
-    } catch (error) {
-      throw new Error(
-        `the dependency reads ${readings.length === 1 ? "as a folder in" : "as something in"} ` +
-          `the repository at ${location.url}, and its index could not be read, so the release ` +
-          `cannot settle what it means. A release never guesses past an index it could not ` +
-          `read.\n  ${describeError(error)}`
-      );
-    }
-
-    const settled = settleInIndex(reading, {
-      namespaces: Object.keys(index.namespaces),
-      recipes: index.recipes,
-    });
-    if (settled.length > 0) found.push({ reading, settled, index });
-  }
-
-  if (found.length === 0) {
-    throw new Error(
-      `no repository it could name publishes what it names. It was read as:\n` +
-        readings.map((reading) => `    ${formatRef(reading, providers)}`).join("\n")
-    );
-  }
-
-  const choices = found.flatMap((entry) => entry.settled);
-  if (choices.length > 1) {
-    throw new Error(
-      `it names more than one thing, and each of these publishes it:\n` +
-        choices.map((choice) => `    ${formatRef(choice, providers)}`).join("\n") +
-        `\n  Write the one you mean. A namespace is written with '/*' after it, as in ` +
-        `'${spelledOut(choices.find((choice) => choice.recipe === undefined) ?? choices[0]!, providers)}', ` +
-        `and a recipe as its canonical locator above.`
-    );
-  }
-
-  const { index } = found[0]!;
-  const choice = choices[0]!;
+  const { ref: choice } = await lookup.settle(readings);
+  const location = locationOf(choice)!;
+  const index = await lookup.indexAt(location);
+  const namespace = namespaceOf(choice)?.name;
   const keys =
-    choice.recipe === undefined
+    choice.kind === "namespace"
       ? Object.keys(index.recipes)
-          .filter((key) => key.startsWith(`${choice.namespace}/`))
+          .filter((key) => key.startsWith(`${namespace}/`))
           .sort()
-      : [refKey(choice)];
-  const range = "range" in found[0]!.reading ? found[0]!.reading.range : undefined;
+      : [shortKey(choice)];
+  const range = readings.map(rangeOf).find((written) => written !== undefined);
   return {
-    identity: choice.location!.identity,
+    identity: location.identity,
     keys,
     ...(range === undefined ? {} : { range }),
   };
 }
-
-/** A reading spelled so it reads one way: a namespace with `/*` after it. */
-function spelledOut(reading: ParsedRef, providers: RepoProvider[]): string {
-  const written = formatRef(reading, providers);
-  return reading.recipe === undefined && isNamedReading(reading) ? `${written}/*` : written;
-}
-
-/**
- * Fetches and validates the index at a location, through its provider.
- *
- * @param location - Where the repository lives.
- * @param providers - The providers to fetch through.
- * @param options - Testing seams.
- */
-async function fetchIndexAt(
-  location: RefLocation,
-  providers: RepoProvider[],
-  options: ProviderOptions
-): Promise<IndexFile> {
-  const provider = providerById(location.provider, providers);
-  /* c8 ignore next */
-  if (provider === undefined) throw new Error(`sous has no '${location.provider}' provider.`);
-  const fetched = await provider.fetchIndex(provider.canonicalize(location.url), options);
-  return parseIndexFile(JSON.parse(fetched.text), `${location.url}/${INDEX_FILENAME}`);
-}