@sous-io/sous 0.2.28 → 0.2.29

package/src/lib/refs/scopes.ts

@@ -23,6 +23,40 @@ export enum SousScope {
   EnvVarName = "envVarName",
 }
 
+/**
+ * Where a ref was written. `parseRef` reads every form wherever a ref comes
+ * from, and the place decides which of those forms it allows: a refused form
+ * is an error saying what to write there instead.
+ */
+export enum RefSource {
+  /**
+   * A ref typed on the command line. Every form is allowed: a bare name, a
+   * namespace and recipe, a `repo:` qualifier, a version range, a
+   * provider-scheme locator, an HTTPS, SSH or scheme-less URL, and a browser
+   * URL copied from a host's file view. Names may be written in any case.
+   */
+  CommandLine = "commandLine",
+  /**
+   * A subscription key in a config layer. Only the stored form is allowed:
+   * `namespace` or `namespace/recipe`, lowercase. The repository a
+   * subscription resolves into is recorded in the lockfile, and its range in
+   * the entry's own `range` field.
+   */
+  Config = "config",
+  /**
+   * An entry of a recipe manifest's `depends` or `subscribes` list. A bare ref
+   * names a recipe in the same repository; every locator and URL form names
+   * one in another repository. A `repo:` qualifier is refused, because it is
+   * one project's private name for a repository, and so is a local path.
+   */
+  Manifest = "manifest",
+  /**
+   * A key sous wrote itself: the lockfile, the index and the store. Only the
+   * canonical `namespace` or `namespace/recipe` is allowed.
+   */
+  Lockfile = "lockfile",
+}
+
 /**
  * Every scope, in the order matches of equal specificity are listed in. It is
  * the order the one-word ref search has always used (a whole namespace before

package/src/lib/refs/settle.ts

@@ -0,0 +1,219 @@
+/**
+ * Settling what a ref means, once the index that can say is at hand.
+ *
+ * `parseRef` returns every reading of a written ref. Some readings are settled
+ * the moment they are read (`workflow/alpha`), and some need the index of the
+ * repository they point at: a browser URL names a folder, and only the `path`
+ * each recipe's index entry records says which recipe that folder is; a GitLab
+ * URL with nested groups can be read as several repositories, and only their
+ * indexes say which one publishes what was named.
+ *
+ * Names are matched the same way everywhere: the exact spelling first, then
+ * ignoring case. A name that still matches several things is a question for
+ * `pickReference`.
+ */
+
+import {
+  isBrowsedReading,
+  isNamedReading,
+  namespaceOfKey,
+  parseRef,
+  refKey,
+  splitRecipeKey,
+  type ParsedRef,
+  type RefReading,
+} from "./parse.js";
+import { RefSource } from "./scopes.js";
+
+/**
+ * The names that match a written one: those spelled exactly as written, or,
+ * when there is none, those that differ only in case.
+ *
+ * matchNames("Workflow", ["workflow", "tooling"]); // -> ["workflow"]
+ * matchNames("workflow", ["workflow", "Workflow"]); // -> ["workflow"]
+ *
+ * @param written - The name as written.
+ * @param names - The names it could mean.
+ */
+export function matchNames(written: string, names: Iterable<string>): string[] {
+  const all = [...names];
+  const exact = all.filter((name) => name === written);
+  if (exact.length > 0) return exact;
+  const folded = written.toLowerCase();
+  return all.filter((name) => name.toLowerCase() === folded);
+}
+
+/** What settling needs to know about one repository's index. */
+export type SettleIndex = {
+  /** Every namespace the index publishes. */
+  namespaces: Iterable<string>;
+  /** Every recipe it publishes, keyed `namespace/recipe`, with the folder it lives in. */
+  recipes: Record<string, { path: string }>;
+};
+
+/**
+ * What a reading names in one repository's index, spelled the way the index
+ * spells it. A named reading that the index does not publish settles to
+ * nothing; a browsed path settles through the recipe paths.
+ *
+ * settleInIndex({ namespace: "Workflow", recipe: "alpha" }, index);
+ * // -> [{ namespace: "workflow", recipe: "alpha" }]
+ *
+ * @param reading - One reading of a written ref.
+ * @param index - The index of the repository the reading points at.
+ */
+export function settleInIndex(reading: RefReading, index: SettleIndex): ParsedRef[] {
+  const carried = {
+    ...(reading.location === undefined ? {} : { location: reading.location }),
+    ...("range" in reading && reading.range !== undefined ? { range: reading.range } : {}),
+    ...("repo" in reading && reading.repo !== undefined ? { repo: reading.repo } : {}),
+  };
+
+  if (isBrowsedReading(reading)) {
+    return settleBrowsed(reading.browsed, index).map((settled) => ({ ...settled, ...carried }));
+  }
+  if (!isNamedReading(reading)) return [];
+
+  if (reading.recipe === undefined) {
+    return matchNames(reading.namespace, index.namespaces).map((namespace) => ({
+      namespace,
+      ...carried,
+    }));
+  }
+
+  return matchNames(refKey(reading), Object.keys(index.recipes)).map((key) => {
+    const { namespace, name } = splitRecipeKey(key);
+    return { namespace, recipe: name, ...carried };
+  });
+}
+
+/**
+ * What a browser path names, through the folder each recipe's index entry
+ * records. The path still carries the branch in front (which may itself hold
+ * slashes), so every split is tried: the folder of a recipe, or anything inside
+ * it, names that recipe; a folder holding recipes of exactly one namespace
+ * names that namespace.
+ *
+ * settleBrowsed("main/recipes/workflow/alpha/SKILL.md", index);
+ * // -> [{ namespace: "workflow", recipe: "alpha" }]
+ *
+ * @param browsed - The path after `tree/` or `blob/`, branch included.
+ * @param index - The repository's index.
+ */
+export function settleBrowsed(browsed: string, index: SettleIndex): ParsedRef[] {
+  const segments = browsed.split("/").filter((segment) => segment.length > 0);
+  const recipes = Object.entries(index.recipes).map(([key, entry]) => ({
+    key,
+    path: entry.path.replace(/^\.?\/+|\/+$/g, ""),
+  }));
+
+  const found = new Map<string, ParsedRef>();
+
+  // A recipe's folder, or a file inside it. The deepest recipe wins, so a
+  // recipe nested inside another's folder is named by its own path.
+  for (let start = 1; start < segments.length; start++) {
+    const folder = segments.slice(start).join("/");
+    const holding = recipes
+      .filter((recipe) => folder === recipe.path || folder.startsWith(`${recipe.path}/`))
+      .sort((left, right) => right.path.length - left.path.length);
+    const deepest = holding[0];
+    if (deepest !== undefined) {
+      const { namespace, name } = splitRecipeKey(deepest.key);
+      found.set(deepest.key, { namespace, recipe: name });
+    }
+  }
+  if (found.size > 0) return [...found.values()];
+
+  // A folder above recipes: a namespace, when everything under it is one.
+  for (let start = 1; start < segments.length; start++) {
+    const folder = segments.slice(start).join("/");
+    const under = recipes.filter((recipe) => recipe.path.startsWith(`${folder}/`));
+    const namespaces = new Set(under.map((recipe) => namespaceOfKey(recipe.key)));
+    if (namespaces.size === 1) {
+      const namespace = [...namespaces][0]!;
+      found.set(namespace, { namespace });
+    }
+  }
+  return [...found.values()];
+}
+
+/** What a repository's index recorded about one dependency, as far as settling needs. */
+export type RecordedDependencies = Record<string, { repo?: string } | undefined>;
+
+/**
+ * The readings of a manifest dependency that the declaring recipe's index
+ * confirms. A release settles a dependency that reads more than one way (a
+ * GitLab URL with nested groups, a browser URL) and records the repository it
+ * settled on beside each key it resolved; a consumer reads that record and never
+ * probes. A dependency that reads one way needs no record and comes back as it
+ * is.
+ *
+ * A named reading is confirmed by a record under its own key (or, for a whole
+ * namespace, under a key inside it) carrying its repository; a browsed reading
+ * by any record carrying its repository.
+ *
+ * @param readings - Every reading of the dependency, from `parseRef`.
+ * @param recorded - What the declaring version's index entry records, keyed `namespace/recipe`.
+ * @returns The confirmed readings: one is the answer; none or several leave it unsettled.
+ */
+export function confirmedReadings(
+  readings: RefReading[],
+  recorded: RecordedDependencies | undefined
+): RefReading[] {
+  if (readings.length === 1) return readings;
+  const records = Object.entries(recorded ?? {});
+
+  return readings.filter((reading) => {
+    const identity = reading.location?.identity;
+    if (identity === undefined) return false;
+    return records.some(([key, record]) => {
+      if (record?.repo !== identity) return false;
+      if (isBrowsedReading(reading)) return true;
+      if (!isNamedReading(reading)) return false;
+      return reading.recipe === undefined
+        ? key.startsWith(`${reading.namespace}/`)
+        : key === refKey(reading);
+    });
+  });
+}
+
+/** What `settleDependency` may consult, beyond the dependency itself. */
+export type SettleDependencyOptions = {
+  /** What the declaring version's index entry records about its dependencies. */
+  recorded?: RecordedDependencies;
+  /**
+   * Whether a reading is already known to be right from what is on this
+   * machine: its repository is trusted and its cached index publishes what it
+   * names. Used only when the index recorded nothing, and it never fetches.
+   */
+  known?: (reading: RefReading) => boolean;
+};
+
+/**
+ * The one reading a manifest dependency settles on, or undefined when it reads
+ * more than one way and nothing at hand says which: the declaring recipe's
+ * index recorded no answer, and what this machine already knows does not pick
+ * exactly one.
+ *
+ * settleDependency("workflow/alpha");
+ * // -> { namespace: "workflow", recipe: "alpha" }
+ *
+ * @param written - The dependency as the manifest wrote it.
+ * @param options - The index's record, and what is known locally.
+ */
+export function settleDependency(
+  written: string,
+  options: SettleDependencyOptions = {}
+): RefReading | undefined {
+  const readings = parseRef(written, RefSource.Manifest);
+  if (readings.length === 1) return readings[0];
+
+  const confirmed = confirmedReadings(readings, options.recorded);
+  if (confirmed.length === 1) return confirmed[0];
+
+  if (options.known !== undefined) {
+    const known = readings.filter(options.known);
+    if (known.length === 1) return known[0];
+  }
+  return undefined;
+}

package/src/lib/repos/catalog.ts

@@ -29,7 +29,15 @@ import type {
   RecipeManifest,
   VariableDefinition,
 } from "./formats/recipe-manifest.js";
-import { dependencyRefKey, parseDependencyRef, parseRef, type ParsedRef } from "./ref.js";
+import {
+  isNamedReading,
+  namespaceOfKey,
+  parseRef,
+  refKey,
+  splitRecipeKey,
+  type ParsedRef,
+} from "../refs/parse.js";
+import { settleDependency } from "../refs/settle.js";
 import { bareName } from "../vars/names.js";
 import {
   describeReference,
@@ -390,7 +398,7 @@ export function narrowToInstalled(inputs: CatalogInputs): CatalogInputs {
         ([key]) => inputs.lock.recipes[key]?.repo === repo.name
       )
     );
-    const held = new Set(Object.keys(recipes).map((key) => key.slice(0, key.indexOf("/"))));
+    const held = new Set(Object.keys(recipes).map(namespaceOfKey));
     const namespaces = Object.fromEntries(
       Object.entries(repo.index.namespaces).filter(([namespace]) => held.has(namespace))
     );
@@ -468,16 +476,16 @@ export type ResolvedRecipeRef = {
  * @param ref - The namespace, optionally qualified with `repo:`.
  */
 export function resolveNamespaceRef(inputs: CatalogInputs, ref: string): ResolvedNamespace {
-  const parsed = parseRef(ref);
+  const { parsed, search } = readCommandLineRef(ref);
 
-  if (parsed.recipe !== undefined) {
+  if (parsed?.recipe !== undefined) {
     throw new ConfigError(
       `'${ref}' names the recipe '${parsed.recipe}', not a namespace.\n` +
         `  The namespace it belongs to is '${parsed.namespace}'.`
     );
   }
 
-  const matches = findNamespace(refSearchString(parsed), referenceContext(inputs));
+  const matches = findNamespace(search, referenceContext(inputs));
 
   if (matches.length === 1) {
     return { repo: repoNamed(inputs, matches[0]!.repo!), namespace: matches[0]!.namespace! };
@@ -485,8 +493,8 @@ export function resolveNamespaceRef(inputs: CatalogInputs, ref: string): Resolve
 
   if (matches.length > 1) throw ambiguousError(ref, "namespace", matches);
 
-  const asRecipe = findRecipe(refSearchString(parsed), referenceContext(inputs));
-  if (parsed.repo === undefined && asRecipe.length > 0) {
+  const asRecipe = findRecipe(search, referenceContext(inputs));
+  if (parsed !== undefined && parsed.repo === undefined && asRecipe.length > 0) {
     throw new ConfigError(
       `No repository this project trusts publishes a namespace called ` +
         `'${parsed.namespace}'.\n` +
@@ -495,7 +503,7 @@ export function resolveNamespaceRef(inputs: CatalogInputs, ref: string): Resolve
     );
   }
 
-  throw unknownError(inputs, ref, "namespace", parsed.repo);
+  throw unknownError(inputs, ref, "namespace", parsed?.repo);
 }
 
 /**
@@ -507,8 +515,7 @@ export function resolveNamespaceRef(inputs: CatalogInputs, ref: string): Resolve
  * @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 = parseRef(ref);
-  const search = refSearchString(parsed);
+  const { parsed, search } = readCommandLineRef(ref);
   const context = referenceContext(inputs);
 
   const matches = findRecipe(search, context);
@@ -529,13 +536,13 @@ export function resolveRecipeRef(inputs: CatalogInputs, ref: string): ResolvedRe
   if (asNamespace.length > 0) {
     throw new ConfigError(
       `No repository this project trusts publishes a recipe called ` +
-        `'${parsed.namespace}'.\n` +
+        `'${parsed?.namespace ?? ref}'.\n` +
         `  It is the name of a namespace:\n` +
         asNamespace.map((candidate) => `    ${describeReference(candidate)}`).join("\n")
     );
   }
 
-  throw unknownError(inputs, ref, "recipe", parsed.repo);
+  throw unknownError(inputs, ref, "recipe", parsed?.repo);
 }
 
 // --- The pieces ---------------------------------------------------------------------------------
@@ -543,7 +550,7 @@ export function resolveRecipeRef(inputs: CatalogInputs, ref: string): ResolvedRe
 /** Every recipe key one index publishes in one namespace, sorted. */
 function recipeKeysIn(index: IndexFile, namespace: string): string[] {
   return Object.keys(index.recipes)
-    .filter((key) => key.slice(0, key.indexOf("/")) === namespace)
+    .filter((key) => namespaceOfKey(key) === namespace)
     .sort();
 }
 
@@ -583,8 +590,7 @@ function recipeListing(
 ): RecipeListing {
   const lock = inputs.lock;
   const entry = repo.index.recipes[key]!;
-  const namespace = key.slice(0, key.indexOf("/"));
-  const name = key.slice(namespace.length + 1);
+  const { namespace, name } = splitRecipeKey(key);
   const latest = latestVersion(Object.keys(entry.versions), entry.versions);
 
   // A locked entry pins one recipe from one repository. Two repositories can
@@ -689,12 +695,17 @@ function dependencyListings(
     ["subscribes", manifest?.subscribes ?? []],
   ] as Array<["depends" | "subscribes", string[]]>) {
     for (const written of declared) {
-      let key: string;
+      // A dependency that reads more than one way is listed under the key the
+      // index recorded for it. One sous cannot parse or settle is still worth
+      // showing; it is listed under what it was written as, so the reader sees
+      // the entry as it stands.
+      let key = written;
       try {
-        key = dependencyRefKey(parseDependencyRef(written));
+        const reading = settleDependency(written, {
+          ...(resolved === undefined ? {} : { recorded: resolved }),
+        });
+        if (reading !== undefined && isNamedReading(reading)) key = refKey(reading);
       } catch {
-        // A manifest sous cannot parse is still worth showing; it is listed
-        // under what it was written as, so the reader sees the bad entry.
         key = written;
       }
       rows.set(key, { ...(rows.get(key) ?? { key }), declared: written, kind });
@@ -746,14 +757,22 @@ function referenceContext(inputs: CatalogInputs): ReferenceContext {
 }
 
 /**
- * A parsed ref written back out as a reference, without its version range: the
- * range says which version to use, never which thing is meant.
+ * 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.
  *
- * @param parsed - The parsed ref.
+ * @param ref - The ref as typed.
+ * @returns The short reading, when the ref was short, and the search term.
  */
-function refSearchString(parsed: ParsedRef): string {
-  const path = parsed.recipe === undefined ? parsed.namespace : `${parsed.namespace}/${parsed.recipe}`;
-  return parsed.repo === undefined ? path : `${parsed.repo}:${path}`;
+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)}`,
+  };
 }
 
 /** The error a ref that could have meant several things raises. */

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

@@ -31,6 +31,7 @@ import {
   semverVersionSchema,
   stableJsonStringify,
 } from "./common.js";
+import { namespaceOfKey } from "../../refs/parse.js";
 
 /**
  * One dependency of one published version, as the release resolved it.
@@ -142,7 +143,7 @@ export const indexFileSchema = forwardCompatibleObject({
   // A recipe whose namespace is not declared could never be resolved, so a
   // release that produced one is broken; say which recipe and which namespace.
   for (const key of Object.keys(index.recipes)) {
-    const namespace = key.slice(0, key.indexOf("/"));
+    const namespace = namespaceOfKey(key);
     if (!Object.hasOwn(index.namespaces, namespace)) {
       ctx.addIssue({
         code: "custom",

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

@@ -15,13 +15,15 @@
  *   its files DO enter the output. A curated bundle is simply a recipe made
  *   mostly of `subscribes` entries.
  *
- * Both lists name their targets BY LOCATION, in one of two spellings:
+ * Both lists name their targets BY LOCATION:
  *
  *     workflow/sat                                  a sibling in this repository
  *     github://sous-io/sous-recipes/workflow/sat    a recipe in another one
  *
- * A short name such as `sous-recipes:` is a consuming project's own label, so
- * it never appears in a published manifest; see `parseDependencyRef`.
+ * 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
+ * `RefSource.Manifest`.
  */
 
 import { z } from "zod";
@@ -37,20 +39,20 @@ import {
   submissionsSchema,
   variableNameSchema,
 } from "./common.js";
-import { parseDependencyRef } from "../ref.js";
+import { parseRef } from "../../refs/parse.js";
+import { RefSource } from "../../refs/scopes.js";
 
 // --- Dependency refs ----------------------------------------------------------------------------
 
 /**
- * A dependency in `depends` or `subscribes`, in either of the two spellings a
- * manifest may use: a bare ref naming a recipe in this same repository, or a
- * locator URL naming one in another repository. Parsed with the real parser so
+ * A dependency in `depends` or `subscribes`: a bare ref naming a recipe in this
+ * same repository, or a location naming one in another repository. Parsed with the real parser so
  * a manifest and the rest of sous never disagree about what a dependency means;
  * the parser's message is carried through as the zod issue message.
  */
 const dependencyRefSchema = z.string().superRefine((value, ctx) => {
   try {
-    parseDependencyRef(value);
+    parseRef(value, RefSource.Manifest);
   } catch (error) {
     ctx.addIssue({ code: "custom", message: (error as Error).message });
   }

package/src/lib/repos/index.ts

@@ -18,7 +18,6 @@ export * from "./formats/lockfile.js";
 export * from "./formats/store-entry.js";
 export * from "./formats/links-map.js";
 export * from "./load-manifest.js";
-export * from "./ref.js";
 export * from "./identity.js";
 
 // Phase 2a: the machine-wide recipe store, under the user-level sous directory.

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

@@ -34,6 +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 type { ProviderOptions, RepoProvider } from "./providers/provider.js";
 
 /** What the lockfile needs to know about a repository. */
@@ -382,11 +383,11 @@ export class LockService {
     const report: RestoreReport = { restored: [], alreadyPresent: [] };
 
     for (const [key, entry] of Object.entries(lock.recipes)) {
-      const namespace = key.slice(0, key.indexOf("/"));
+      const { namespace, name } = splitRecipeKey(key);
       const storeKey: StoreKey = {
         identity: lock.repos[entry.repo]!.identity,
         namespace,
-        name: key.slice(namespace.length + 1),
+        name,
         version: entry.version,
       };
 

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

@@ -4,14 +4,17 @@
  * Phase 4 defined the `NamespaceResolver` contract and shipped an in-memory
  * implementation for tests. This is the implementation backed by the project's
  * actual state: the lockfile says which recipes are in play and at what version,
- * the links map and the store say where each one's files are, and each recipe's
- * own manifest says what it is allowed to address.
+ * the links map and the store say where each one's files are, and the
+ * lockfile's holder lists say what each recipe is allowed to address.
  *
  * The scoping rule is the whole point, and it is enforced by handing
  * `StaticNamespaceResolver` the right two maps:
  *
  *   - a file inside a recipe may address only that recipe's own declared
- *     dependencies (`depends` plus `subscribes`), at their pinned versions;
+ *     dependencies (`depends` plus `subscribes`), at their pinned versions. The
+ *     lockfile records which keys each recipe holds, however its manifest wrote
+ *     them (a sibling ref, a locator, a URL copied from the browser), so that
+ *     record is what decides it;
  *   - a file in the project's own templates may address every recipe the
  *     lockfile pins, whatever holds it: the project, a set it subscribes to,
  *     or another recipe's `depends`.
@@ -28,16 +31,16 @@
 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 {
   StaticNamespaceResolver,
-  normalizeRef,
   type DroppedRecipe,
   type NamespaceResolver,
 } from "./namespace-resolver.js";
 import {
   listLockedRecipes,
   readProjectLockfile,
-  readRecipeManifestIn,
   type LockedRecipeLocation,
 } from "./locked-recipes.js";
 import { createIndexCache } from "./providers/index.js";
@@ -84,14 +87,11 @@ export function createProjectNamespaceResolver(
   for (const recipe of locked) {
     recipes[recipe.key] = recipe.dir;
 
-    // A recipe declares what it may address in its own manifest. A recipe whose
-    // files are not on disk yet declares nothing, which is the conservative
-    // answer: it cannot be including anything either.
-    const manifest = recipe.present ? readRecipeManifestIn(recipe.dir) : undefined;
-    if (manifest === undefined) continue;
-
-    const declared = [...(manifest.depends ?? []), ...(manifest.subscribes ?? [])];
-    if (declared.length > 0) dependencies[recipe.key] = declared;
+    // Every recipe holding this one declared it, in `depends` or `subscribes`,
+    // and the lockfile records the key that declaration resolved to.
+    for (const holder of recipe.requestedBy) {
+      (dependencies[holder] ??= []).push(recipe.key);
+    }
   }
 
   // No `projectScope`: a project template may address every recipe the
@@ -126,10 +126,16 @@ export function explainUnpinnedRecipe(
   recipe: string,
   options: Pick<ProjectNamespaceResolverOptions, "sousDir" | "settings" | "env">
 ): DroppedRecipe | undefined {
-  const namespace = recipe.slice(0, recipe.indexOf("/"));
+  const namespace = namespaceOfKey(recipe);
   for (const [key, entry] of Object.entries(options.settings.subscriptions ?? {})) {
     if (entry?.enabled !== false) continue;
-    const ref = normalizeRef(key);
+    let ref: string;
+    try {
+      ref = refKey(parseShortRef(key, RefSource.Config));
+    } catch {
+      // The config schema already refuses a key that is not a ref.
+      continue;
+    }
     if (ref === recipe || ref === namespace) {
       return { by: "disabled-subscription", subscription: key };
     }

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

@@ -33,6 +33,7 @@ import {
 } from "./load-manifest.js";
 import { readEffectiveLinks } from "./links.js";
 import { identitySegments } from "./identity.js";
+import { splitRecipeKey } from "../refs/parse.js";
 import { PROJECT_HOLDER } from "./formats/lockfile.js";
 
 /** One locked recipe, together with the directory its files are read from. */
@@ -164,8 +165,7 @@ export function listLockedRecipes(
 
   for (const key of keys.sort()) {
     const entry = lock.recipes[key]!;
-    const namespace = key.slice(0, key.indexOf("/"));
-    const name = key.slice(namespace.length + 1);
+    const { namespace, name } = splitRecipeKey(key);
 
     let dir: string | undefined;
     let linked = false;