@sous-io/sous 0.2.32 → 0.2.33

package/src/lib/repos/catalog.ts

@@ -27,23 +27,23 @@ import type { IndexDependency, IndexFile } from "./formats/index-file.js";
 import type { Lockfile } from "./formats/lockfile.js";
 import type { ContentKind, RecipeManifest } from "./formats/recipe-manifest.js";
 import {
-  isNamedReading,
+  CachedIndexLookup,
+  RefResolveArguments,
+  describeRef,
+  isNamedRef,
+  locationOf,
+  namespaceOf,
   namespaceOfKey,
-  parseRef,
-  refKey,
+  repoOf,
+  settleDependency,
+  shortKey,
+  sharedRefResolver,
   splitRecipeKey,
-  type ParsedRef,
-} from "../refs/parse.js";
-import { settleDependency } from "../refs/settle.js";
+  type NamedRef,
+  type RefKind,
+  type SousRef,
+} from "../../services/ref-resolver/index.js";
 import { declarationFor, type DependencyLists } from "./declarations.js";
-import {
-  describeReference,
-  findNamespace,
-  findRecipe,
-  referenceReposFromIndexes,
-  type ReferenceContext,
-  type ReferenceMatch,
-} from "../refs/index.js";
 
 // --- What the catalog reads ---------------------------------------------------------------------
 
@@ -305,8 +305,11 @@ export function listRecipes(inputs: CatalogInputs): RecipeListing[] {
  * @param inputs - The cached indexes, the lockfile and the project's subscriptions.
  * @param ref - The namespace, optionally qualified with `repo:`.
  */
-export function describeNamespace(inputs: CatalogInputs, ref: string): NamespaceDetail {
-  const found = resolveNamespaceRef(inputs, ref);
+export async function describeNamespace(
+  inputs: CatalogInputs,
+  ref: string
+): Promise<NamespaceDetail> {
+  const found = await resolveNamespaceRef(inputs, ref);
   const subscriptions = new Set(inputs.subscriptions);
   const declared = found.repo.index.namespaces[found.namespace]!;
 
@@ -329,8 +332,11 @@ export function describeNamespace(inputs: CatalogInputs, ref: string): Namespace
  * @param inputs - The cached indexes, the lockfile, the subscriptions and the manifest reader.
  * @param ref - The recipe, as `namespace/recipe`, a bare recipe name, or either qualified with `repo:`.
  */
-export function describeRecipe(inputs: CatalogInputs, ref: string): RecipeDetail {
-  const found = resolveRecipeRef(inputs, ref);
+export async function describeRecipe(
+  inputs: CatalogInputs,
+  ref: string
+): Promise<RecipeDetail> {
+  const found = await resolveRecipeRef(inputs, ref);
   const subscriptions = new Set(inputs.subscriptions);
   const listing = recipeListing(found.key, found.repo, inputs, subscriptions);
   const entry = found.repo.index.recipes[found.key]!;
@@ -412,18 +418,18 @@ export function narrowToInstalled(inputs: CatalogInputs): CatalogInputs {
  * @param describe - The lookup to run: `describeNamespace` or `describeRecipe`.
  * @param what - What the ref names, for the error.
  */
-export function describeInstalled<T>(
+export async function describeInstalled<T>(
   inputs: CatalogInputs,
   ref: string,
-  describe: (inputs: CatalogInputs, ref: string) => T,
+  describe: (inputs: CatalogInputs, ref: string) => Promise<T>,
   what: "namespace" | "recipe"
-): T {
+): Promise<T> {
   try {
-    return describe(narrowToInstalled(inputs), ref);
+    return await describe(narrowToInstalled(inputs), ref);
   } catch {
     // The full lookup either explains the ref better (ambiguous, unknown) or
     // proves it is published and simply not installed.
-    describe(inputs, ref);
+    await describe(inputs, ref);
     throw what === "namespace"
       ? new ConfigError(
           `This project has installed no recipe from the namespace '${ref}', so there is ` +
@@ -464,35 +470,39 @@ export type ResolvedRecipeRef = {
  * @param inputs - The cached indexes.
  * @param ref - The namespace, optionally qualified with `repo:`.
  */
-export function resolveNamespaceRef(inputs: CatalogInputs, ref: string): ResolvedNamespace {
-  const { parsed, search } = readCommandLineRef(ref);
+export async function resolveNamespaceRef(
+  inputs: CatalogInputs,
+  ref: string
+): Promise<ResolvedNamespace> {
+  const parsed = readShortRef(ref);
 
-  if (parsed?.recipe !== undefined) {
+  if (parsed?.kind === "recipe") {
     throw new ConfigError(
-      `'${ref}' names the recipe '${parsed.recipe}', not a namespace.\n` +
-        `  The namespace it belongs to is '${parsed.namespace}'.`
+      `'${ref}' names the recipe '${parsed.name}', not a namespace.\n` +
+        `  The namespace it belongs to is '${parsed.namespace!.name}'.`
     );
   }
 
-  const matches = findNamespace(search, referenceContext(inputs));
+  const matches = await findIn(inputs, ref, ["namespace"]);
 
   if (matches.length === 1) {
-    return { repo: repoNamed(inputs, matches[0]!.repo!), namespace: matches[0]!.namespace! };
+    const match = matches[0]!;
+    return { repo: repoNamed(inputs, repoOf(match)!.name!), namespace: namespaceOf(match)!.name };
   }
 
   if (matches.length > 1) throw ambiguousError(ref, "namespace", matches);
 
-  const asRecipe = findRecipe(search, referenceContext(inputs));
-  if (parsed !== undefined && parsed.repo === undefined && asRecipe.length > 0) {
+  const asRecipe = await findIn(inputs, ref, ["recipe"]);
+  if (parsed !== undefined && repoOf(parsed) === undefined && asRecipe.length > 0) {
     throw new ConfigError(
       `No repository this project trusts publishes a namespace called ` +
-        `'${parsed.namespace}'.\n` +
+        `'${parsed.name}'.\n` +
         `  It is the name of a recipe:\n` +
-        asRecipe.map((candidate) => `    ${describeReference(candidate)}`).join("\n")
+        asRecipe.map((candidate) => `    ${describeRef(candidate)}`).join("\n")
     );
   }
 
-  throw unknownError(inputs, ref, "namespace", parsed?.repo);
+  throw unknownError(inputs, ref, "namespace", parsed === undefined ? undefined : repoOf(parsed)?.name);
 }
 
 /**
@@ -503,35 +513,39 @@ export function resolveNamespaceRef(inputs: CatalogInputs, ref: string): Resolve
  * @param inputs - The cached indexes.
  * @param ref - The recipe, as `namespace/recipe`, a bare recipe name, or either qualified with `repo:`.
  */
-export function resolveRecipeRef(inputs: CatalogInputs, ref: string): ResolvedRecipeRef {
-  const { parsed, search } = readCommandLineRef(ref);
-  const context = referenceContext(inputs);
+export async function resolveRecipeRef(
+  inputs: CatalogInputs,
+  ref: string
+): Promise<ResolvedRecipeRef> {
+  const parsed = readShortRef(ref);
 
-  const matches = findRecipe(search, context);
+  const matches = await findIn(inputs, ref, ["recipe"]);
 
   if (matches.length === 1) {
     const match = matches[0]!;
+    const namespace = namespaceOf(match)!.name;
+    const name = (match as { name: string }).name;
     return {
-      repo: repoNamed(inputs, match.repo!),
-      key: `${match.namespace}/${match.recipe}`,
-      namespace: match.namespace!,
-      name: match.recipe!,
+      repo: repoNamed(inputs, repoOf(match)!.name!),
+      key: `${namespace}/${name}`,
+      namespace,
+      name,
     };
   }
 
   if (matches.length > 1) throw ambiguousError(ref, "recipe", matches);
 
-  const asNamespace = findNamespace(search, context);
+  const asNamespace = await findIn(inputs, ref, ["namespace"]);
   if (asNamespace.length > 0) {
     throw new ConfigError(
       `No repository this project trusts publishes a recipe called ` +
-        `'${parsed?.namespace ?? ref}'.\n` +
+        `'${parsed === undefined ? ref : namespaceNameOf(parsed)}'.\n` +
         `  It is the name of a namespace:\n` +
-        asNamespace.map((candidate) => `    ${describeReference(candidate)}`).join("\n")
+        asNamespace.map((candidate) => `    ${describeRef(candidate)}`).join("\n")
     );
   }
 
-  throw unknownError(inputs, ref, "recipe", parsed?.repo);
+  throw unknownError(inputs, ref, "recipe", parsed === undefined ? undefined : repoOf(parsed)?.name);
 }
 
 // --- The pieces ---------------------------------------------------------------------------------
@@ -711,7 +725,7 @@ function dependencyListings(
         const reading = settleDependency(written, {
           ...(resolved === undefined ? {} : { recorded: resolved }),
         });
-        if (reading !== undefined && isNamedReading(reading)) key = refKey(reading);
+        if (reading !== undefined && isNamedRef(reading)) key = shortKey(reading);
       } catch {
         key = written;
       }
@@ -733,45 +747,57 @@ function repoNamed(inputs: CatalogInputs, name: string): CatalogRepo {
   return inputs.repos.find((repo) => repo.name === name)!;
 }
 
-/** This catalog's repositories, in the shape a reference searches. */
-function referenceContext(inputs: CatalogInputs): ReferenceContext {
-  return {
-    repos: referenceReposFromIndexes(
-      inputs.repos.map((repo) => repo.name),
-      new Map(inputs.repos.map((repo) => [repo.name, repo.index])),
-      Object.fromEntries(inputs.repos.map((repo) => [repo.name, repo.url]))
-    ),
-  };
+/**
+ * Every ref in this catalog's repositories that a ref written on the command
+ * line names, of the kinds given, best match first.
+ *
+ * @param inputs - The cached indexes.
+ * @param ref - The ref as typed.
+ * @param kinds - The kinds of ref the caller accepts.
+ */
+async function findIn(
+  inputs: CatalogInputs,
+  ref: string,
+  kinds: readonly RefKind[]
+): Promise<SousRef[]> {
+  const lookup = new CachedIndexLookup(
+    new Map(inputs.repos.map((repo) => [repo.name, repo.index])),
+    {
+      order: inputs.repos.map((repo) => repo.name),
+      urls: Object.fromEntries(inputs.repos.map((repo) => [repo.name, repo.url])),
+    }
+  );
+  const result = await sharedRefResolver().resolve(new RefResolveArguments({ input: ref, lookup, kinds }));
+  return result.refs;
 }
 
 /**
- * A ref from the command line, checked by the one parser, and the spelling to
- * search for: a short ref written back without its version range (the range
- * says which version to use, never which thing is meant), or a location
- * exactly as written, which the search settles through the repository's index.
+ * The namespace or recipe a ref from the command line names by its short form,
+ * checked by the one parser: undefined when the ref names a location instead.
  *
  * @param ref - The ref as typed.
- * @returns The short reading, when the ref was short, and the search term.
  */
-function readCommandLineRef(ref: string): { parsed?: ParsedRef; search: string } {
-  const readings = parseRef(ref);
-  const first = readings[0]!;
-  if (first.location !== undefined || !isNamedReading(first)) return { search: ref.trim() };
-  return {
-    parsed: first,
-    search: first.repo === undefined ? refKey(first) : `${first.repo}:${refKey(first)}`,
-  };
+function readShortRef(ref: string): NamedRef | undefined {
+  const { refs } = sharedRefResolver().parse(ref);
+  return refs.find(
+    (candidate): candidate is NamedRef => isNamedRef(candidate) && locationOf(candidate) === undefined
+  );
+}
+
+/** The name a short ref was written with: its namespace for a namespace, its recipe name otherwise. */
+function namespaceNameOf(ref: NamedRef): string {
+  return ref.kind === "namespace" ? ref.name : ref.namespace!.name;
 }
 
 /** The error a ref that could have meant several things raises. */
 function ambiguousError(
   ref: string,
   what: "namespace" | "recipe",
-  candidates: ReferenceMatch[]
+  candidates: SousRef[]
 ): ConfigError {
   return new ConfigError(
     `'${ref}' names a ${what} in more than one repository this project trusts:\n` +
-      candidates.map((candidate) => `    ${describeReference(candidate)}`).join("\n") +
+      candidates.map((candidate) => `    ${describeRef(candidate)}`).join("\n") +
       `\n  Name the repository as well, as 'repository:${ref}', to say which one you mean.`
   );
 }

package/src/lib/repos/declarations.ts

@@ -14,9 +14,16 @@
 
 import type { DependencyKind } from "./formats/common.js";
 import type { IndexVersion } from "./formats/index-file.js";
-import { isNamedReading, namespaceOfKey, parseRef, refKey } from "../refs/parse.js";
-import { RefSource } from "../refs/scopes.js";
-import { settleDependency, type RecordedDependencies } from "../refs/settle.js";
+import {
+  RefSource,
+  isNamedRef,
+  locationOf,
+  namespaceOfKey,
+  settleDependency,
+  shortKey,
+  sharedRefResolver,
+  type RecordedDependencies,
+} from "../../services/ref-resolver/index.js";
 
 /** A manifest's two dependency lists, each entry exactly as it was written. */
 export type DependencyLists = {
@@ -112,10 +119,12 @@ export function declarationFor(
         // validated; here it simply covers nothing.
         continue;
       }
-      if (reading === undefined || !isNamedReading(reading)) continue;
+      if (reading === undefined || !isNamedRef(reading)) continue;
 
-      const named = reading.recipe !== undefined;
-      const covers = named ? refKey(reading) === key : namespaceOfKey(key) === reading.namespace;
+      const named = reading.kind === "recipe";
+      const covers = named
+        ? shortKey(reading) === key
+        : namespaceOfKey(key) === reading.name;
       if (covers) gathered = foldDeclaration(gathered, { written, kind, named });
     }
   }
@@ -152,12 +161,13 @@ export function indexDependencyLists(
  */
 export function describeDeclaration(declared: string): string {
   try {
-    const readings = parseRef(declared, RefSource.Manifest);
-    const only = readings[0]!;
-    if (readings.length === 1 && isNamedReading(only) && only.recipe === undefined) {
-      return only.location === undefined
-        ? `the whole '${only.namespace}' namespace`
-        : `the whole '${only.namespace}' namespace of ${only.location.identity}`;
+    const { refs } = sharedRefResolver().parse(declared, RefSource.Manifest);
+    const only = refs[0]!;
+    if (refs.length === 1 && only.kind === "namespace") {
+      const location = locationOf(only);
+      return location === undefined
+        ? `the whole '${only.name}' namespace`
+        : `the whole '${only.name}' namespace of ${location.identity}`;
     }
   } catch {
     // Shown as it was written; the reader sees the bad entry.

package/src/lib/repos/formats/index-file.ts

@@ -33,7 +33,7 @@ import {
   stableJsonStringify,
 } from "./common.js";
 import { publishedVariableDefinitionSchema } from "./variable-definition.js";
-import { namespaceOfKey } from "../../refs/parse.js";
+import { namespaceOfKey } from "../../../services/ref-resolver/index.js";
 
 /**
  * One dependency of one published version, as the release resolved it.

package/src/lib/repos/formats/recipe-manifest.ts

@@ -22,7 +22,7 @@
  *
  * Every other location form works too (an HTTPS or SSH URL, a browser URL); a
  * short name such as `sous-recipes:` is a consuming project's own label, so it
- * never appears in a published manifest. See `parseRef` with
+ * never appears in a published manifest. See `RefResolverService.parse` with
  * `RefSource.Manifest`.
  */
 
@@ -37,8 +37,7 @@ import {
   semverVersionSchema,
   submissionsSchema,
 } from "./common.js";
-import { parseRef } from "../../refs/parse.js";
-import { RefSource } from "../../refs/scopes.js";
+import { RefSource, sharedRefResolver } from "../../../services/ref-resolver/index.js";
 import { variableDefinitionSchema } from "./variable-definition.js";
 
 // Variable definitions live in their own module, so the index can read them
@@ -56,7 +55,7 @@ export * from "./variable-definition.js";
  */
 const dependencyRefSchema = z.string().superRefine((value, ctx) => {
   try {
-    parseRef(value, RefSource.Manifest);
+    sharedRefResolver().parse(value, RefSource.Manifest);
   } catch (error) {
     ctx.addIssue({ code: "custom", message: (error as Error).message });
   }

package/src/lib/repos/lock-service.ts

@@ -34,7 +34,7 @@ import type { ResolvedRecipe } from "./resolver.js";
 import type { RecipeStoreLike, StoreKey } from "./store/contract.js";
 import { builtInProviders, requireProvider } from "./providers/index.js";
 import { repoIdentity } from "./identity.js";
-import { splitRecipeKey } from "../refs/parse.js";
+import { splitRecipeKey } from "../../services/ref-resolver/index.js";
 import type { ProviderOptions, RepoProvider } from "./providers/provider.js";
 
 /** What the lockfile needs to know about a repository. */

package/src/lib/repos/locked-namespace-resolver.ts

@@ -24,15 +24,19 @@
  * can tell.
  *
  * A project with no lockfile entries gets no resolver at all, so a project that
- * uses no repositories behaves exactly as it did before: `~` in an include line
- * means an alias and nothing else.
+ * uses no repositories behaves exactly as it did before: a `~` reference in an
+ * include line is just a relative path.
  */
 
 import semver from "semver";
 import type { Settings } from "../settings.js";
 import { resolveStoreRoot } from "../sous-home.js";
-import { RefSource } from "../refs/scopes.js";
-import { namespaceOfKey, parseShortRef, refKey } from "../refs/parse.js";
+import {
+  RefSource,
+  namespaceOfKey,
+  parseNamedRef,
+  shortKey,
+} from "../../services/ref-resolver/index.js";
 import {
   StaticNamespaceResolver,
   type DroppedRecipe,
@@ -64,7 +68,8 @@ export type ProjectNamespaceResolverOptions = {
  * locks no recipes at all.
  *
  * createProjectNamespaceResolver({ sousDir, settings })
- * // -> resolves "@~workflow/task-files/_partials/resume.md" to the pinned
+ * // -> resolves "@~workflow/task-files/_partials/resume.md" (or a glob such as
+ * //    "@~*" + "/*" + "/memories/*.md") to the pinned
  * //    recipe directory, when the project (or the including recipe) may address it
  *
  * @param options - The project's `.sous/` directory, its config and the environment.
@@ -82,10 +87,12 @@ export function createProjectNamespaceResolver(
   if (locked.length === 0) return undefined;
 
   const recipes: Record<string, string> = {};
+  const repos: Record<string, string> = {};
   const dependencies: Record<string, string[]> = {};
 
   for (const recipe of locked) {
     recipes[recipe.key] = recipe.dir;
+    repos[recipe.key] = recipe.repo;
 
     // Every recipe holding this one declared it, in `depends` or `subscribes`,
     // and the lockfile records the key that declaration resolved to.
@@ -98,6 +105,7 @@ export function createProjectNamespaceResolver(
   // lockfile pins, and those are exactly the recipes this resolver knows.
   return new StaticNamespaceResolver({
     recipes,
+    repos,
     dependencies,
     explainMissing: (recipe) => explainUnpinnedRecipe(recipe, options),
   });
@@ -131,7 +139,7 @@ export function explainUnpinnedRecipe(
     if (entry?.enabled !== false) continue;
     let ref: string;
     try {
-      ref = refKey(parseShortRef(key, RefSource.Config));
+      ref = shortKey(parseNamedRef(key, RefSource.Config));
     } catch {
       // The config schema already refuses a key that is not a ref.
       continue;

package/src/lib/repos/locked-recipe-lookup.ts

@@ -0,0 +1,123 @@
+/**
+ * What an include line may name: the recipes the lockfile pins.
+ *
+ * A `RefLookup` over the pinned recipes, answering a `recipeFile` reading (the
+ * namespace and recipe names, and the path inside the recipe) with every pinned
+ * recipe whose names match it. Names are compared as the ref service compares
+ * every name: exact spelling first, ignoring case as the fallback, and a name
+ * may be a glob (`*`, `**`, `?`, `[..]`, `{a,b}`). The path inside the recipe
+ * is carried through as written; expanding it into files is the include
+ * resolver's job, because only it knows which directory each recipe lives in.
+ */
+
+import {
+  compareBytewise,
+  matchName,
+  repoOf,
+  type NameMatch,
+  type RefMatch,
+  type SousRef,
+  type SyncRefLookup,
+} from "../../services/ref-resolver/index.js";
+
+/** One pinned recipe, as far as a lookup needs to know it. */
+export type RecipeFileEntry = {
+  /** The recipe's namespace. */
+  namespace: string;
+  /** The recipe's name. */
+  name: string;
+  /** The short name of the repository it came from, when known. */
+  repo?: string;
+};
+
+/** The weakest of two matches: a name that matched only ignoring case spoils an exact one. */
+function combine(left: NameMatch, right: NameMatch): NameMatch {
+  if (left === undefined || right === undefined) return undefined;
+  return left === "exact" && right === "exact" ? "exact" : "folded";
+}
+
+/** Answers which pinned recipes an include reading names. */
+export class LockedRecipeFileLookup implements SyncRefLookup {
+  /**
+   * @param entries - Every recipe the lockfile pins.
+   */
+  constructor(private readonly entries: readonly RecipeFileEntry[]) {}
+
+  /** The distinct namespaces of the pinned recipes, sorted. */
+  namespaces(): string[] {
+    return [...new Set(this.entries.map((entry) => entry.namespace))].sort(compareBytewise);
+  }
+
+  /**
+   * The pinned recipes of the namespaces a written namespace matches, sorted
+   * by key: those whose spelling matches exactly, or, when none does, those
+   * that differ only in case.
+   *
+   * @param written - The namespace as written, possibly a glob.
+   */
+  recipesInNamespace(written: string): string[] {
+    const matched = this.entries
+      .map((entry) => ({ entry, match: matchName(written, entry.namespace) }))
+      .filter((hit) => hit.match !== undefined);
+    const exact = matched.filter((hit) => hit.match === "exact");
+    return (exact.length > 0 ? exact : matched)
+      .map((hit) => `${hit.entry.namespace}/${hit.entry.name}`)
+      .sort(compareBytewise);
+  }
+
+  /**
+   * True when a written namespace matches a pinned one in some spelling.
+   *
+   * @param written - The namespace as written, possibly a glob.
+   */
+  knowsNamespace(written: string): boolean {
+    return this.entries.some((entry) => matchName(written, entry.namespace) !== undefined);
+  }
+
+  findSync(candidate: SousRef): RefMatch[] {
+    if (candidate.kind !== "recipeFile") return [];
+    const written = candidate.recipe;
+    const namespaceName = written.namespace?.name;
+    if (namespaceName === undefined) return [];
+    const repoName = repoOf(candidate)?.name;
+
+    const found: RefMatch[] = [];
+    for (const entry of this.entries) {
+      let match = combine(
+        matchName(namespaceName, entry.namespace),
+        matchName(written.name, entry.name)
+      );
+      if (repoName !== undefined) {
+        match = combine(
+          match,
+          entry.repo === undefined ? undefined : matchName(repoName, entry.repo)
+        );
+      }
+      if (match === undefined) continue;
+      found.push({
+        ref: {
+          kind: "recipeFile",
+          path: candidate.path,
+          recipe: {
+            kind: "recipe",
+            name: entry.name,
+            namespace: { kind: "namespace", name: entry.namespace },
+          },
+          ...(candidate.glob === undefined ? {} : { glob: true as const }),
+          ...(candidate.vars === undefined ? {} : { vars: candidate.vars }),
+        },
+        exactSpelling: match === "exact",
+      });
+    }
+    return found.sort((left, right) => compareBytewise(keyOf(left.ref), keyOf(right.ref)));
+  }
+
+  async find(candidate: SousRef): Promise<RefMatch[]> {
+    return this.findSync(candidate);
+  }
+}
+
+/** The `namespace/recipe` key of a recipe file ref, for ordering. */
+function keyOf(ref: SousRef): string {
+  return ref.kind === "recipeFile" ? `${ref.recipe.namespace?.name}/${ref.recipe.name}` : "";
+}

package/src/lib/repos/locked-recipes.ts

@@ -33,7 +33,7 @@ import {
 } from "./load-manifest.js";
 import { readEffectiveLinks } from "./links.js";
 import { identitySegments } from "./identity.js";
-import { splitRecipeKey } from "../refs/parse.js";
+import { splitRecipeKey } from "../../services/ref-resolver/index.js";
 import { PROJECT_HOLDER } from "./formats/lockfile.js";
 
 /** One locked recipe, together with the directory its files are read from. */

package/src/lib/repos/memories-hash-name.ts

@@ -0,0 +1,33 @@
+/**
+ * The built-in `#memories` view: every memory an active recipe publishes, at
+ * `#memories/<namespace>/<recipe>/<path>`. See `recipe-memories.ts` for what is
+ * listed and in which order.
+ */
+
+import { makeInjectable } from "../../services/ref-resolver/injectable.js";
+import type { HashName, HashViewContext, ViewFile } from "../../services/ref-resolver/hash-names.js";
+import { listMemories } from "./recipe-memories.js";
+
+/** The `#memories` view. */
+export class MemoriesHashName implements HashName {
+  readonly name = "memories";
+  readonly registeredBy = "sous";
+  readonly description =
+    "the memories of every active recipe, listed in dependency order as #memories/<namespace>/<recipe>/<path>.";
+
+  bases(): string[] {
+    return [];
+  }
+
+  view(context: HashViewContext): ViewFile[] {
+    const memories = context.settings.recipes?.memories;
+    return listMemories({
+      sousDir: context.sousDir,
+      ...(context.env === undefined ? {} : { env: context.env }),
+      first: memories?.first,
+      exclude: memories?.exclude,
+    }).map((memory) => ({ path: memory.path, file: memory.file }));
+  }
+}
+
+makeInjectable(MemoriesHashName);