@vzn/vx 0.0.16 → 0.0.21

package/src/workspace/workspace.ts

@@ -1,7 +1,8 @@
-import { readdir } from 'node:fs/promises'
+import type { Dirent } from 'node:fs'
+import { readdir, stat } from 'node:fs/promises'
 import path from 'node:path'
 import type { ProjectConfig, WorkspaceConfig } from '../config.js'
-import { UserError } from '../util/index.js'
+import { relPosix, UserError, normalizeGlob } from '../util/index.js'
 
 export interface PackageJson {
   name: string
@@ -40,29 +41,149 @@ export interface ProjectEntry {
 const CONFIG_FILENAMES = ['vx.config.ts', 'vx.config.mts', 'vx.config.js', 'vx.config.mjs']
 
 /**
- * Walk up from `start` to find the workspace root. A directory is a
- * workspace root if it contains either:
- *   - `pnpm-workspace.yaml`, OR
- *   - a `package.json` (with or without a `workspaces` field).
+ * Walk up from `start` to find the workspace root. A directory is a root
+ * CANDIDATE when it contains `pnpm-workspace.yaml` or a `package.json`.
  *
- * The first match wins. A bare `package.json` without `workspaces`
- * means a single-project workspace (the root itself IS the project).
- * Throws a `UserError` if neither signal is found before `/`.
+ * The nearest candidate that CLAIMS `start` wins — one of the directories
+ * between it and `start` matches one of its package globs. Every workspace
+ * member has its own `package.json`, so stopping at the first candidate would
+ * make a run from inside a package treat that package as the whole workspace:
+ * `^task` edges vanish, upstream hashes drop out of the cache key (stale
+ * hits), and a second cache dir appears under the member. Claiming is decided
+ * with the same globs `loadWorkspace` applies, so "the root that claims me"
+ * and "the root that lists me as a project" cannot diverge.
+ *
+ * When no candidate claims `start` — a standalone package, or a subdirectory
+ * of a single-project repo — the nearest candidate wins (the root itself IS
+ * the project). Throws a `UserError` when there is no candidate before `/`.
  */
 export async function findWorkspaceRoot(start: string): Promise<string> {
   let dir = path.resolve(start)
+  const below: string[] = []
+  let nearest: string | null = null
   while (true) {
-    if (await Bun.file(path.join(dir, 'pnpm-workspace.yaml')).exists()) return dir
-    if (await Bun.file(path.join(dir, 'package.json')).exists()) return dir
-    const parent = path.dirname(dir)
-    if (parent === dir) {
-      throw new UserError(
-        `Could not find a workspace root in any parent of ${start} ` +
-          `(looked for pnpm-workspace.yaml or package.json)`,
-      )
+    let globs: string[] | null
+    try {
+      globs = await readPackageGlobs(dir)
+    } catch {
+      // An unparseable manifest is still a root SIGNAL (the pre-existing
+      // behaviour probed only for existence); it just can't claim members.
+      // `loadWorkspace` surfaces the parse error if this dir is chosen.
+      globs = []
+    }
+    if (globs !== null) {
+      nearest ??= dir
+      if (claimsMember(dir, below, globs)) return dir
     }
+    const parent = path.dirname(dir)
+    if (parent === dir) break
+    below.push(dir)
     dir = parent
   }
+  if (nearest !== null) return nearest
+  throw new UserError(
+    `Could not find a workspace root in any parent of ${start} ` +
+      `(looked for pnpm-workspace.yaml or package.json)`,
+  )
+}
+
+/** True when one of `below` (dirs under `root`, toward `start`) is a member. */
+function claimsMember(root: string, below: readonly string[], globs: readonly string[]): boolean {
+  if (below.length === 0 || globs.length === 0) return false
+  const { positive, negative } = splitPackageGlobs(globs)
+  const rels = below.map((d) => relPosix(root, d)).filter((rel) => !excludedBy(rel, negative))
+  for (const pattern of positive) {
+    const normalized = pattern.replace(/\/+$/, '')
+    // `.` means the root itself is the project — never a directory below it.
+    if (normalized === '' || normalized === '.') continue
+    const glob = new Bun.Glob(normalized)
+    if (rels.some((rel) => glob.match(rel))) return true
+  }
+  return false
+}
+
+/**
+ * pnpm, npm, yarn and Bun all take `!packages/fixtures` in the package
+ * list. Handed to `Bun.Glob` raw, a leading `!` negates the WHOLE pattern,
+ * so `!packages/fixtures/package.json` matched every manifest in the tree
+ * and every directory holding one became a project — the excluded package
+ * ran under `--all`, and a fixture repeating a name killed the run with
+ * "Duplicate package name". Negations subtract from what the positive
+ * globs found; a literal one excludes its tree.
+ */
+function splitPackageGlobs(globs: readonly string[]): { positive: string[]; negative: string[] } {
+  const positive: string[] = []
+  const negative: string[] = []
+  // `!./packages/legacy` and `!packages//legacy` excluded nothing, silently
+  // (2026-09-10): the same spellings the input globs normalize.
+  for (const raw of globs) {
+    const g = normalizeGlob(raw)
+    if (g.startsWith('!')) negative.push(g.slice(1).replace(/\/+$/, ''))
+    else positive.push(g)
+  }
+  return { positive, negative }
+}
+
+function excludedBy(rel: string, negative: readonly string[]): boolean {
+  for (const neg of negative) {
+    if (neg.length === 0) continue
+    if (rel === neg || rel.startsWith(`${neg}/`)) return true
+    if (/[*?[\]{}]/.test(neg) && new Bun.Glob(neg).match(rel)) return true
+  }
+  return false
+}
+
+/**
+ * Package globs declared by `dir`, or `null` when `dir` is not a root
+ * candidate. A bare `package.json` (no `workspaces`) is single-project mode:
+ * the root itself is the only project, hence `['.']`.
+ */
+async function readPackageGlobs(dir: string): Promise<string[] | null> {
+  const yamlPath = path.join(dir, 'pnpm-workspace.yaml')
+  if (await Bun.file(yamlPath).exists()) {
+    const parsed = (parseManifest(await Bun.file(yamlPath).text(), yamlPath, Bun.YAML.parse) ??
+      {}) as { packages?: unknown }
+    return assertGlobList(parsed.packages ?? [], yamlPath, 'packages')
+  }
+  const pkgPath = path.join(dir, 'package.json')
+  if (!(await Bun.file(pkgPath).exists())) return null
+  const pkg = parseManifest(await Bun.file(pkgPath).text(), pkgPath, JSON.parse) as PackageJson
+  const ws = pkg.workspaces as unknown
+  if (ws === undefined || ws === null) return ['.']
+  if (ws && typeof ws === 'object' && !Array.isArray(ws) && 'packages' in ws) {
+    return assertGlobList(
+      (ws as { packages?: unknown }).packages ?? [],
+      pkgPath,
+      'workspaces.packages',
+    )
+  }
+  return assertGlobList(ws, pkgPath, 'workspaces')
+}
+
+/**
+ * Parse a workspace manifest, naming the FILE on failure. The raw parser
+ * errors (`Failed to parse JSON`) carry no path, so in a 1000-package
+ * monorepo they say nothing about which manifest is broken.
+ */
+function parseManifest(text: string, file: string, parse: (t: string) => unknown): unknown {
+  try {
+    return parse(text)
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    throw new UserError(`failed to parse ${file}: ${msg}`)
+  }
+}
+
+/**
+ * A glob list is user input from a manifest: `packages: "packages/*"`
+ * (a bare string instead of a list) is an easy YAML slip, and without
+ * this it surfaces as `workspace.packageGlobs.map is not a function`.
+ */
+function assertGlobList(value: unknown, file: string, field: string): string[] {
+  if (!Array.isArray(value) || value.some((p) => typeof p !== 'string')) {
+    throw new UserError(`${file}: \`${field}\` must be an array of glob strings`)
+  }
+  return value as string[]
 }
 
 /**
@@ -86,83 +207,185 @@ export function resolveCacheDir(root: string, config: WorkspaceConfig | null): s
  * itself is treated as a single-project workspace.
  */
 export async function loadWorkspace(root: string): Promise<Workspace> {
-  const yamlPath = path.join(root, 'pnpm-workspace.yaml')
-  if (await Bun.file(yamlPath).exists()) {
-    const parsed = (Bun.YAML.parse(await Bun.file(yamlPath).text()) ?? {}) as {
-      packages?: string[]
+  const packageGlobs = await readPackageGlobs(root)
+  if (packageGlobs === null) {
+    // Should be unreachable: findWorkspaceRoot only returns dirs that
+    // pass at least one of the two existence checks.
+    throw new UserError(`workspace root ${root} has neither pnpm-workspace.yaml nor package.json`)
+  }
+  return { root, packageGlobs }
+}
+
+// `<dir>/*` — the shape of nearly every workspace glob. Anything with another
+// glob character (`**`, `{a,b}`, `?`, `[`) or a negation takes the general
+// path.
+const SIMPLE_STAR_RE = /^[^*?{}[\]!]+\/\*$/
+
+/**
+ * The directory each `<dir>/*` package glob names — where a member comes
+ * and goes as one directory entry, so `vx watch` can hear a package added
+ * or removed without walking anything. A glob of another shape (`apps/**`)
+ * has no such directory and contributes none.
+ */
+export function memberBaseDirs(workspace: Workspace): string[] {
+  const bases = new Set<string>()
+  for (const pattern of splitPackageGlobs(workspace.packageGlobs).positive) {
+    const normalized = pattern === '.' ? '' : pattern.replace(/\/$/, '')
+    if (SIMPLE_STAR_RE.test(normalized)) {
+      bases.add(path.resolve(workspace.root, normalized.slice(0, -2)))
+    }
+  }
+  return [...bases]
+}
+
+/**
+ * The directories a workspace glob names. For the `<dir>/*` shape this is
+ * one readdir of `<dir>` — the same answer `Bun.Glob` gives, at a third of
+ * the cost (measured 2026-09-02: 25 ms → ~2 ms for 1000 members). A
+ * symlinked member is followed when it points at a directory, as the glob
+ * did. Dot-directories are skipped (`dot: false`), so are `node_modules`.
+ */
+async function memberDirs(root: string, pattern: string): Promise<string[]> {
+  // Normalize: `"."` -> the root itself; `"foo/"` -> `"foo"`.
+  const normalized = pattern === '.' ? '' : pattern.replace(/\/$/, '')
+  if (SIMPLE_STAR_RE.test(normalized)) {
+    const base = path.resolve(root, normalized.slice(0, -2))
+    let entries: import('node:fs').Dirent[]
+    try {
+      entries = await readdir(base, { withFileTypes: true })
+    } catch {
+      return []
+    }
+    const dirs: string[] = []
+    for (const e of entries) {
+      if (e.name.startsWith('.') || e.name === 'node_modules') continue
+      if (e.isDirectory()) dirs.push(path.join(base, e.name))
+      else if (e.isSymbolicLink()) {
+        try {
+          if ((await stat(path.join(base, e.name))).isDirectory())
+            dirs.push(path.join(base, e.name))
+        } catch {
+          // dangling link: not a member
+        }
+      }
     }
-    return { root, packageGlobs: parsed.packages ?? [] }
+    return dirs
+  }
+  const globPattern = normalized === '' ? 'package.json' : `${normalized}/package.json`
+  const glob = new Bun.Glob(globPattern)
+  const dirs: string[] = []
+  for await (const rel of glob.scan({ cwd: root, onlyFiles: true, dot: false })) {
+    // Skip nested node_modules — workspace package globs shouldn't
+    // ever reach into them, but a pathological pattern like `**`
+    // would. Avoid splitting the path on the hot loop.
+    if (rel.includes(`${path.sep}node_modules${path.sep}`)) continue
+    if (rel.startsWith(`node_modules${path.sep}`)) continue
+    dirs.push(path.dirname(path.resolve(root, rel)))
   }
+  return dirs
+}
 
-  const pkgPath = path.join(root, 'package.json')
-  if (await Bun.file(pkgPath).exists()) {
-    const pkg = (await Bun.file(pkgPath).json()) as PackageJson
-    const ws = pkg.workspaces
-    if (Array.isArray(ws)) return { root, packageGlobs: ws }
-    if (ws && typeof ws === 'object' && Array.isArray(ws.packages)) {
-      return { root, packageGlobs: ws.packages }
+/**
+ * The project's config file, by `CONFIG_FILENAMES` precedence, or null.
+ *
+ * Two shapes, one per platform, each the measured winner there across
+ * 1,000 projects with the manifest read in flight alongside:
+ *   - macOS stats the candidates in order: a readdir each cost 9.6 ms
+ *     against 6.3 ms of stats even with the config at the LAST name
+ *     (2026-09-03), and a `.ts` config — the first name — pays one stat.
+ *   - Linux lists the directory once: a readdir each is 12 ms against
+ *     43 ms of stats at the last name and ties the one-stat case
+ *     (2026-09-09, a `vx.config.mjs` workspace; stats there cost a
+ *     thread-pool round trip apiece).
+ * Both answer identically: a directory or dangling link under a config
+ * name is skipped for the next name, a symlink to a file counts.
+ */
+async function findConfigFile(dir: string): Promise<string | null> {
+  if (process.platform === 'linux') {
+    let entries: Dirent[]
+    try {
+      entries = await readdir(dir, { withFileTypes: true })
+    } catch {
+      return null
     }
-    // Bare package.json with no `workspaces` — single-project mode.
-    // Treat the root itself as the only project.
-    return { root, packageGlobs: ['.'] }
+    const byName = new Map(entries.map((e) => [e.name, e]))
+    for (const name of CONFIG_FILENAMES) {
+      const entry = byName.get(name)
+      if (entry === undefined) continue
+      const candidate = path.join(dir, name)
+      if (entry.isFile()) return candidate
+      if (entry.isSymbolicLink() && (await isFile(candidate))) return candidate
+    }
+    return null
+  }
+  for (const name of CONFIG_FILENAMES) {
+    const candidate = path.join(dir, name)
+    if (await isFile(candidate)) return candidate
   }
+  return null
+}
 
-  // Should be unreachable: findWorkspaceRoot only returns dirs that
-  // pass at least one of the two existence checks.
-  throw new UserError(`workspace root ${root} has neither pnpm-workspace.yaml nor package.json`)
+async function isFile(p: string): Promise<boolean> {
+  try {
+    return (await stat(p)).isFile()
+  } catch {
+    return false
+  }
 }
 
 export async function listProjects(workspace: Workspace): Promise<ProjectMeta[]> {
   // Run all package globs concurrently. Disk-bound walks parallelize
   // well; serializing them just stretches the discovery phase by N×.
+  const { positive, negative } = splitPackageGlobs(workspace.packageGlobs)
   const perPattern = await Promise.all(
-    workspace.packageGlobs.map(async (pattern) => {
-      // Normalize: `"."` -> the root itself; `"foo/"` -> `"foo"`.
-      const normalized = pattern === '.' ? '' : pattern.replace(/\/$/, '')
-      const globPattern = normalized === '' ? 'package.json' : `${normalized}/package.json`
-      const glob = new Bun.Glob(globPattern)
-      const hits: string[] = []
-      for await (const rel of glob.scan({
-        cwd: workspace.root,
-        onlyFiles: true,
-        dot: false,
-      })) {
-        // Skip nested node_modules — workspace package globs shouldn't
-        // ever reach into them, but a pathological pattern like `**`
-        // would. Avoid splitting the path on the hot loop.
-        if (rel.includes(`${path.sep}node_modules${path.sep}`)) continue
-        if (rel.startsWith(`node_modules${path.sep}`)) continue
-        hits.push(path.resolve(workspace.root, rel))
-      }
-      return hits
-    }),
+    positive.map((pattern) => memberDirs(workspace.root, pattern)),
   )
   const matches = new Set<string>()
-  for (const arr of perPattern) for (const m of arr) matches.add(m)
+  for (const arr of perPattern) {
+    for (const m of arr) {
+      if (negative.length > 0 && excludedBy(relPosix(workspace.root, m), negative)) continue
+      matches.add(m)
+    }
+  }
 
-  // Per-project I/O (manifest read + config discovery) is independent
-  // — run it all concurrently, then a deterministic sequential pass
-  // for the duplicate-name check. One readdir per project replaces
-  // up to four exists() probes (CONFIG_FILENAMES has 4 candidates):
-  // ~5440 awaited syscalls → ~2180 concurrent ones at 1090 projects.
+  // Per-project discovery: the manifest read answers "is there a
+  // package.json" (an ENOENT is the "not a member" answer, at the cost of
+  // one failed open) and `findConfigFile` answers "which config file", both
+  // in flight together. All async and all in flight at once — the thread
+  // pool runs them in parallel, and a sync read here measured 2× slower on
+  // a 1000-member workspace.
   const loaded = await Promise.all(
-    [...matches].map(async (pkgJsonPath) => {
-      const dir = path.dirname(pkgJsonPath)
-      const [pkg, entries] = await Promise.all([
-        Bun.file(pkgJsonPath).json() as Promise<PackageJson>,
-        readdir(dir).catch(() => [] as string[]),
+    [...matches].map(async (dir) => {
+      const pkgJsonPath = path.join(dir, 'package.json')
+      const [configPath, text] = await Promise.all([
+        findConfigFile(dir),
+        Bun.file(pkgJsonPath)
+          .text()
+          .catch(() => null),
       ])
-      const names = new Set(entries)
-      const configName = CONFIG_FILENAMES.find((f) => names.has(f))
-      const configPath = configName !== undefined ? path.join(dir, configName) : null
+      if (text === null) return null
+      const pkg = parseManifest(text, pkgJsonPath, JSON.parse) as PackageJson
       return { dir, pkg, configPath }
     }),
   )
 
   const projects: ProjectMeta[] = []
   const seenName = new Map<string, string>()
-  for (const { dir, pkg, configPath } of loaded) {
-    if (!pkg.name) continue
+  for (const entry of loaded) {
+    if (entry === null) continue
+    const { dir, pkg, configPath } = entry
+    if (!pkg.name) {
+      // A nameless manifest can't be addressed, filtered, or made affected —
+      // and vx identifies projects by name, so it simply vanishes. Silent is
+      // fine for a dir that declares no tasks; a dir with a vx config was
+      // meant to run.
+      if (configPath !== null) {
+        process.stderr.write(
+          `vx: ${relPosix(workspace.root, dir)} has a vx config but its package.json has no "name" — skipped\n`,
+        )
+      }
+      continue
+    }
     const previous = seenName.get(pkg.name)
     if (previous) {
       throw new UserError(
@@ -172,5 +395,8 @@ export async function listProjects(workspace: Workspace): Promise<ProjectMeta[]>
     seenName.set(pkg.name, dir)
     projects.push({ name: pkg.name, dir, packageJson: pkg, configPath })
   }
-  return projects.sort((a, b) => a.name.localeCompare(b.name))
+  // Code-unit order, not `localeCompare`: ICU collation cost 28 ms of a
+  // 300 ms warm run at 1000 projects, and a stable deterministic order is
+  // all any consumer needs.
+  return projects.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
 }

package/src/cache/cas-backend.ts

@@ -1,97 +0,0 @@
-// CASBackend — pluggable content-addressed storage beneath the cache.
-//
-// Today's Cache + LayeredCache both bundle "where do the bytes live"
-// with "how do we look up entries metadata + key derivation."
-// CASBackend separates the former so a future R2/S3 backend
-// or REAPI CAS bridge can drop in without touching the
-// orchestrator or the SQL entries index.
-//
-// Two reference implementations in this file:
-//   - MemoryCASBackend — testing + in-memory builds. Holds raw bytes.
-//   - FsCASBackend     — writes bytes to a directory; mirrors what
-//                        Cache.save does today. Bun-native using Bun.file
-//                        for the read path so big artifacts stream
-//                        without slurping into memory.
-//
-// Cache.ts has NOT yet been rewired to use a CASBackend — that's a
-// follow-up (Phase 1b). This file ships the abstraction + the two
-// reference impls so downstream work (R2, otel-bridge, distributed-ci)
-// can rely on the type. Byte-identical behaviour today.
-
-import { rm } from 'node:fs/promises'
-import path from 'node:path'
-import type { Digest } from './digest.js'
-
-export interface CASBackend {
-  /** Write bytes under `digest`. Idempotent — putting the same digest twice is a no-op. */
-  put(digest: Digest, bytes: Uint8Array): Promise<void>
-  /** Read bytes under `digest`, or null if absent. */
-  get(digest: Digest): Promise<Uint8Array | null>
-  /** Cheap existence probe — no bytes round-tripped if possible. */
-  has(digest: Digest): Promise<boolean>
-  /** Drop one entry (eviction). No-op if absent. */
-  remove(digest: Digest): Promise<void>
-}
-
-/** In-memory backend, useful for tests and ephemeral runs. */
-export class MemoryCASBackend implements CASBackend {
-  private readonly store = new Map<string, Uint8Array>()
-
-  async put(digest: Digest, bytes: Uint8Array): Promise<void> {
-    if (bytes.byteLength !== digest.sizeBytes) {
-      throw new Error(
-        `MemoryCASBackend.put: sizeBytes mismatch (digest=${digest.sizeBytes}, actual=${bytes.byteLength})`,
-      )
-    }
-    this.store.set(digest.hash, bytes)
-  }
-
-  async get(digest: Digest): Promise<Uint8Array | null> {
-    return this.store.get(digest.hash) ?? null
-  }
-
-  async has(digest: Digest): Promise<boolean> {
-    return this.store.has(digest.hash)
-  }
-
-  async remove(digest: Digest): Promise<void> {
-    this.store.delete(digest.hash)
-  }
-
-  /** Test-only: how many entries are held. */
-  size(): number {
-    return this.store.size
-  }
-}
-
-/** Filesystem-backed backend writing `<rootDir>/<hash>.tar.zst` files. */
-export class FsCASBackend implements CASBackend {
-  constructor(private readonly rootDir: string) {}
-
-  private pathFor(digest: Digest): string {
-    return path.join(this.rootDir, `${digest.hash}.tar.zst`)
-  }
-
-  async put(digest: Digest, bytes: Uint8Array): Promise<void> {
-    if (bytes.byteLength !== digest.sizeBytes) {
-      throw new Error(
-        `FsCASBackend.put: sizeBytes mismatch (digest=${digest.sizeBytes}, actual=${bytes.byteLength})`,
-      )
-    }
-    await Bun.write(this.pathFor(digest), bytes)
-  }
-
-  async get(digest: Digest): Promise<Uint8Array | null> {
-    const file = Bun.file(this.pathFor(digest))
-    if (!(await file.exists())) return null
-    return new Uint8Array(await file.arrayBuffer())
-  }
-
-  async has(digest: Digest): Promise<boolean> {
-    return Bun.file(this.pathFor(digest)).exists()
-  }
-
-  async remove(digest: Digest): Promise<void> {
-    await rm(this.pathFor(digest), { force: true })
-  }
-}

package/src/cache/digest.ts

@@ -1,47 +0,0 @@
-// Digest — the explicit content-address used by every cache layer.
-//
-// Lifted as a first-class type (architecture-review-2026-06.md §4.3)
-// so storage backends become pluggable beneath CacheLayer: local FS,
-// R2, S3, or a future REAPI CAS bridge all speak (hash, sizeBytes).
-//
-// Two practical wins from making this explicit:
-//   1. sizeBytes is the truncation check at transport boundaries (HTTP
-//      Content-Length, R2 ETag-by-size). Free correctness, free corrupt-
-//      artifact-early-fail.
-//   2. CASBackend.has(digest) can answer with just the metadata, no
-//      bytes round-trip — what existence probes want.
-//
-// Why sizeBytes is `number` and not `bigint`: Bun.file().size returns
-// number; JS Number safely represents integers to 2^53-1 (~9 PB); no
-// real cache artifact gets there. Bigint would create the same
-// JSON.stringify-throws nuisance we already navigated for ns timestamps.
-
-export interface Digest {
-  readonly hash: string
-  readonly sizeBytes: number
-}
-
-export function makeDigest(hash: string, sizeBytes: number): Digest {
-  if (!/^[0-9a-f]+$/i.test(hash)) {
-    throw new Error(`invalid digest hash: ${JSON.stringify(hash)}`)
-  }
-  if (!Number.isInteger(sizeBytes) || sizeBytes < 0) {
-    throw new Error(`invalid digest sizeBytes: ${sizeBytes}`)
-  }
-  return { hash, sizeBytes }
-}
-
-export function digestEqual(a: Digest, b: Digest): boolean {
-  return a.hash === b.hash && a.sizeBytes === b.sizeBytes
-}
-
-/** Stable wire format for logging / RPC: `hash/sizeBytes`. */
-export function digestString(d: Digest): string {
-  return `${d.hash}/${d.sizeBytes}`
-}
-
-export function parseDigest(s: string): Digest {
-  const slash = s.indexOf('/')
-  if (slash === -1) throw new Error(`invalid digest string: ${JSON.stringify(s)}`)
-  return makeDigest(s.slice(0, slash), Number(s.slice(slash + 1)))
-}