@vzn/vx 0.0.0 → 0.0.12

package/src/orchestrator/wire.ts

@@ -0,0 +1,212 @@
+// JSON-RPC 2.0 envelope + OTel-LogRecord payload — the wire spec
+// committed by docs/design/wire-protocol-2026-06.md. Lives alongside
+// the existing protocol.ts (t-discriminated ServerMessage/ClientMessage)
+// so vx serve can speak both formats during the transition.
+//
+// One envelope, three transports (WS / SSE / NDJSON), four channels
+// (vx:events / vx:state / vx:rpc / vx:submit). Every external consumer
+// that already speaks JSON-RPC works against vx out of the box.
+//
+// Pure types + a small adapter pair. No transport here; the Hono
+// router in src/cli/serve.ts wires the byte frames.
+
+import type { RunRequest, RunResult, ServerMessage, ClientMessage } from './protocol.js'
+import type { WireEvent as InternalWireEvent } from './events.js'
+
+/** Protocol version returned by GET /version. */
+export const WIRE_PROTOCOL_VERSION = '1.0'
+
+/** The four channels we expose; clients pick the subset they care about. */
+export const WIRE_CHANNELS = ['vx:events', 'vx:state', 'vx:rpc', 'vx:submit'] as const
+export type WireChannel = (typeof WIRE_CHANNELS)[number]
+
+/** JSON-RPC 2.0 method names emitted by the server (notifications). */
+export type ServerNotificationMethod = 'events.append' | 'state.patch'
+
+/** JSON-RPC 2.0 method names dispatched from the client (request/response). */
+export type ClientRequestMethod = 'state.snapshot' | 'submit.run' | `rpc.${string}`
+
+/**
+ * The JSON-RPC 2.0 envelope. One of four shapes per the spec.
+ *
+ *   - request:      { jsonrpc, id, method, params? }
+ *   - response:     { jsonrpc, id, result }
+ *   - error:        { jsonrpc, id, error: { code, message, data? } }
+ *   - notification: { jsonrpc, method, params? }
+ */
+export type Envelope = Request | Response | ErrorResponse | Notification
+
+export interface Request {
+  jsonrpc: '2.0'
+  id: number | string
+  method: string
+  params?: unknown
+}
+
+export interface Response {
+  jsonrpc: '2.0'
+  id: number | string
+  result: unknown
+}
+
+export interface ErrorResponse {
+  jsonrpc: '2.0'
+  id: number | string
+  error: { code: number; message: string; data?: unknown }
+}
+
+export interface Notification {
+  jsonrpc: '2.0'
+  method: string
+  params?: unknown
+}
+
+/** JSON-RPC 2.0 error codes used by vx. The spec reserves -32000..-32099 for impl-defined. */
+export const ENVELOPE_ERRORS = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  USER_ERROR: -32000, // a vx UserError — clean message, no stack
+  TASK_HASH_UNKNOWN: -32001,
+  RUN_NOT_FOUND: -32002,
+  UNAUTHORIZED: -32003,
+  RATE_LIMITED: -32004,
+} as const
+
+/** Build a request envelope. */
+export function makeRequest(id: number | string, method: string, params?: unknown): Request {
+  const req: Request = { jsonrpc: '2.0', id, method }
+  if (params !== undefined) req.params = params
+  return req
+}
+
+/** Build a notification envelope. */
+export function makeNotification(method: string, params?: unknown): Notification {
+  const note: Notification = { jsonrpc: '2.0', method }
+  if (params !== undefined) note.params = params
+  return note
+}
+
+/** Build a success response envelope. */
+export function makeResponse(id: number | string, result: unknown): Response {
+  return { jsonrpc: '2.0', id, result }
+}
+
+/** Build an error response envelope. */
+export function makeError(
+  id: number | string,
+  code: number,
+  message: string,
+  data?: unknown,
+): ErrorResponse {
+  const err: ErrorResponse = { jsonrpc: '2.0', id, error: { code, message } }
+  if (data !== undefined) err.error.data = data
+  return err
+}
+
+/** Type-guard: does a parsed object look like an Envelope? */
+export function isEnvelope(value: unknown): value is Envelope {
+  if (value === null || typeof value !== 'object') return false
+  const v = value as { jsonrpc?: unknown }
+  return v.jsonrpc === '2.0'
+}
+
+/** Type-guard for a request envelope. */
+export function isRequest(env: Envelope): env is Request {
+  return 'method' in env && 'id' in env
+}
+
+/** Type-guard for a notification envelope (request without id). */
+export function isNotification(env: Envelope): env is Notification {
+  return 'method' in env && !('id' in env)
+}
+
+// ---------------------------------------------------------------------------
+// Bidirectional adapters between the legacy t-discriminated wire and the
+// JSON-RPC envelope. Lets vx serve accept both formats on the same WS
+// endpoint during the transition: parse one, fall back to the other.
+// ---------------------------------------------------------------------------
+
+/**
+ * Project a ServerMessage to an envelope. Events become `events.append`
+ * notifications; results become `submit.run` responses; errors become
+ * error responses. The distributed coordinator messages map to the
+ * `coord.*` namespace in a distribution plugin's own adapters.
+ */
+export function serverMessageToEnvelope(msg: ServerMessage, id?: number | string): Envelope {
+  switch (msg.t) {
+    case 'event':
+      return makeNotification('events.append', msg.event)
+    case 'result':
+      // submit.run's response. id required from the caller.
+      return makeResponse(id ?? 0, msg.result)
+    case 'error':
+      return makeError(id ?? 0, ENVELOPE_ERRORS.USER_ERROR, msg.message)
+  }
+}
+
+/**
+ * Project an envelope back to a ServerMessage where one exists. Returns
+ * null for envelopes that don't have a mapping (e.g. state.snapshot
+ * responses — pure JSON-RPC, no submitter form).
+ */
+export function envelopeToServerMessage(env: Envelope): ServerMessage | null {
+  if (isNotification(env) && env.method === 'events.append') {
+    return { t: 'event', event: env.params as InternalWireEvent }
+  }
+  if ('result' in env) {
+    return { t: 'result', result: env.result as RunResult }
+  }
+  if ('error' in env) {
+    return { t: 'error', message: env.error.message }
+  }
+  return null
+}
+
+/** Project a ClientMessage to an envelope. `run` becomes a `submit.run` request. */
+export function clientMessageToEnvelope(msg: ClientMessage, id?: number | string): Envelope {
+  return makeRequest(id ?? 1, 'submit.run', msg.request)
+}
+
+/** Project an envelope back to a ClientMessage. */
+export function envelopeToClientMessage(env: Envelope): ClientMessage | null {
+  if (isRequest(env) && env.method === 'submit.run') {
+    return { t: 'run', request: env.params as RunRequest }
+  }
+  return null
+}
+
+// ---------------------------------------------------------------------------
+// Transport encoders — single bus, one envelope, three byte framings.
+// Helpers exposed for the Hono mounts in src/cli/serve.ts.
+// ---------------------------------------------------------------------------
+
+/** Encode an envelope for a WebSocket frame (one JSON object per frame). */
+export function encodeForWS(env: Envelope): string {
+  return JSON.stringify(env)
+}
+
+/**
+ * Encode an envelope as an SSE event block. Each block is one
+ * `data: <json>\n\n` chunk so a `curl` or browser EventSource gets it
+ * cleanly.
+ */
+export function encodeForSSE(env: Envelope): string {
+  return `data: ${JSON.stringify(env)}\n\n`
+}
+
+/** Encode an envelope as a NDJSON line. One envelope per line. */
+export function encodeForNDJSON(env: Envelope): string {
+  return JSON.stringify(env) + '\n'
+}
+
+/** Parse a UTF-8 string back to an envelope (and validate the shape). */
+export function decodeEnvelope(raw: string): Envelope {
+  const value = JSON.parse(raw) as unknown
+  if (!isEnvelope(value)) {
+    throw new Error(`not a JSON-RPC 2.0 envelope: ${raw.slice(0, 100)}`)
+  }
+  return value
+}

package/src/util/errors.ts

@@ -0,0 +1,11 @@
+// Shared error types used across modules to distinguish user-input
+// failures (clean message only) from internal bugs (full stack trace).
+//
+// `bin.ts` consults `instanceof UserError` to decide what to print.
+
+export class UserError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'UserError'
+  }
+}

package/src/util/hash.ts

@@ -0,0 +1,25 @@
+// Shared non-cryptographic hash helper. xxHash3 is ~5× faster than
+// SHA-256 on modern x86 and produces enough entropy (64 bits) for our
+// uses: cache-key derivation, file content fingerprinting, config-
+// load module cache-busting. None of those need collision resistance
+// against an adversary; they just need uniqueness across honest input.
+//
+// Hex output is a fixed 16-char string. Turbo uses the same shape
+// (xxh64 -> hex(to_be_bytes(u64))) — short enough to live in
+// filenames, recognizable when grepping logs.
+//
+// `Bun.hash.xxHash3` has no streaming Hasher API but takes a seed —
+// we use that seed to chain multiple updates: each `xxh3(part, prev)`
+// folds `part` into the running digest. Equivalent to the old
+// `CryptoHasher.update(...).update(...).digest()` pattern, without
+// allocating an intermediate buffer.
+
+/** xxHash3 bigint output. Use as the seed for the next chain step. */
+export function xxh3(input: string | Uint8Array, seed: bigint = 0n): bigint {
+  return Bun.hash.xxHash3(input, seed)
+}
+
+/** xxHash3 hex-encoded, fixed 16 chars (zero-padded). */
+export function xxh3hex(input: string | Uint8Array, seed: bigint = 0n): string {
+  return xxh3(input, seed).toString(16).padStart(16, '0')
+}

package/src/util/index.ts

@@ -0,0 +1,7 @@
+// Module contract. Cross-module imports must come through here; see
+// docs/design/module-isolation-2026-06.md and tests/module-boundaries.test.ts.
+
+export { UserError } from './errors.js'
+export { xxh3, xxh3hex } from './hash.js'
+export { relPosix } from './paths.js'
+export { ulid } from './ulid.js'

package/src/util/paths.ts

@@ -0,0 +1,16 @@
+import path from 'node:path'
+
+const IS_POSIX = path.sep === '/'
+
+/** Convert a path to POSIX-style for cross-platform stable cache keys. */
+export function toPosix(p: string): string {
+  // Fast path: on Linux/macOS the separator is already '/'. This
+  // function is called for every input file on every cache-key
+  // derivation; skipping the split+join is free perf on the dominant
+  // dev platform.
+  return IS_POSIX ? p : p.split(path.sep).join('/')
+}
+
+export function relPosix(from: string, to: string): string {
+  return toPosix(path.relative(from, to))
+}

package/src/util/ulid.ts

@@ -0,0 +1,15 @@
+// Run-id generator. Thin wrapper over `Bun.randomUUIDv7()` so the
+// `runId` column on `runs` carries a timestamp-ordered identifier —
+// `vx stats --since` queries can range-scan without an index on the
+// time column, and the IDs lexicographically sort by creation time
+// for grouping.
+//
+// UUIDv7 layout: 48-bit ms-epoch timestamp + 74 bits of randomness
+// across the remaining bytes (RFC 9562). Standard format, hex with
+// hyphens, 36 chars. Previously a hand-rolled 26-char Crockford-
+// base32 ULID — Bun's built-in covers the same guarantees with zero
+// custom code.
+
+export function ulid(): string {
+  return Bun.randomUUIDv7()
+}

package/src/version.ts

@@ -0,0 +1,10 @@
+// Leaf module so orchestrator/cli can read the version without
+// importing the public façade (index.ts imports the orchestrator —
+// that edge must stay one-directional).
+//
+// Single source of truth is package.json — Bun resolves the JSON
+// import natively (and inlines it under `bun build --compile`), so
+// a release bump can never drift from what the banner prints.
+import pkg from '../package.json'
+
+export const VERSION: string = pkg.version

package/src/workspace/affected.ts

@@ -0,0 +1,118 @@
+// `--affected` — git-relative project selection.
+//
+// Resolves the set of project names whose files have changed since a
+// given git ref. The diff is `<since>...HEAD` plus working-tree
+// changes (uncommitted edits), so it captures everything you've
+// touched on the current branch.
+//
+// We use `git diff --name-only <since>` which by default compares the
+// `<since>` commit to the working tree — i.e. commits-from-`<since>`
+// + index + unstaged. Matches Turbo's `[<since>]` filter semantics.
+
+import path from 'node:path'
+import { UserError } from '../util/index.js'
+import { LOCKFILE_NAME } from './lockfile.js'
+import type { ProjectMeta } from './workspace.js'
+
+export interface AffectedArgs {
+  workspaceRoot: string
+  /** Git ref / commit / branch to compare against. Required. */
+  since: string
+  projects: readonly ProjectMeta[]
+}
+
+/**
+ * Return the set of project names whose files changed between
+ * `<since>` and the current working tree. Errors if `git` is missing
+ * or `<since>` doesn't resolve to a commit.
+ */
+export async function affectedProjects(args: AffectedArgs): Promise<Set<string>> {
+  await verifyRef(args.workspaceRoot, args.since)
+
+  const proc = Bun.spawn({
+    // `--no-renames` is crucial for project-affected detection: with
+    // git's auto rename-detection on (the default in modern git), a
+    // cross-project `git mv` collapses to a single rename entry that
+    // surfaces only the destination path. We'd then miss flagging the
+    // source project as affected. Treating renames as delete+add gives
+    // us both halves so both projects get correctly marked.
+    cmd: ['git', 'diff', '--no-renames', '--name-only', args.since],
+    cwd: args.workspaceRoot,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+  const stdout = await new Response(proc.stdout).text()
+  const stderr = await new Response(proc.stderr).text()
+  const exit = await proc.exited
+  if (exit !== 0) {
+    throw new UserError(`git diff failed (exit ${exit}): ${stderr.trim()}`)
+  }
+
+  // vx-lock.json (workspace-root metadata) is excluded like a gitignored
+  // file: re-running `vx lock` must not mark every project affected.
+  const changed = stdout.split('\n').filter((s) => s.length > 0 && s !== LOCKFILE_NAME)
+  return projectsContaining(args.workspaceRoot, changed, args.projects)
+}
+
+/**
+ * Resolve the default base for `--affected` with no explicit value.
+ * Tries the remote's HEAD branch first (`origin/main`, `origin/master`,
+ * etc.), then falls back to `HEAD~1` which always exists once there
+ * are at least two commits.
+ */
+export async function defaultAffectedBase(workspaceRoot: string): Promise<string> {
+  const probe = Bun.spawnSync({
+    cmd: ['git', 'symbolic-ref', '--short', '-q', 'refs/remotes/origin/HEAD'],
+    cwd: workspaceRoot,
+    stdout: 'pipe',
+    stderr: 'ignore',
+  })
+  const out = new TextDecoder().decode(probe.stdout).trim()
+  if (probe.exitCode === 0 && out.length > 0) return out
+  return 'HEAD~1'
+}
+
+async function verifyRef(workspaceRoot: string, ref: string): Promise<void> {
+  const proc = Bun.spawnSync({
+    cmd: ['git', 'rev-parse', '--verify', '--quiet', ref],
+    cwd: workspaceRoot,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+  if (proc.exitCode !== 0) {
+    throw new UserError(
+      `git ref "${ref}" did not resolve. Pass a branch or commit you have locally.`,
+    )
+  }
+}
+
+function projectsContaining(
+  workspaceRoot: string,
+  changedRelPaths: readonly string[],
+  projects: readonly ProjectMeta[],
+): Set<string> {
+  // Index projects by their (canonical) dir, then for each changed path walk
+  // its ancestor dirs bottom-up until one is a project dir. The FIRST hit is
+  // the DEEPEST containing project — so a nested project still wins over its
+  // parent, exactly as the prior longest-dir sort did — but this is
+  // O(files · path-depth) instead of O(files · projects): independent of the
+  // project count, which is what a big --affected diff on a 1000-project repo
+  // pays for.
+  const dirToName = new Map<string, string>()
+  for (const p of projects) dirToName.set(p.dir, p.name)
+  const out = new Set<string>()
+  for (const rel of changedRelPaths) {
+    let dir = path.resolve(workspaceRoot, rel)
+    for (;;) {
+      const name = dirToName.get(dir)
+      if (name !== undefined) {
+        out.add(name)
+        break
+      }
+      const parent = path.dirname(dir)
+      if (parent === dir) break // reached the filesystem root
+      dir = parent
+    }
+  }
+  return out
+}

package/src/workspace/filter.ts

@@ -0,0 +1,155 @@
+// Filter DSL — pnpm-style selectors for `-F / --filter`.
+//
+//   <pattern>        name glob (e.g. foo, @scope/*)
+//   ./<dir>          packages whose dir is at or under <dir> (relative to workspace root)
+//   {<dir>}          same as ./<dir>
+//   <pattern>...     pattern + its transitive workspace dependencies
+//   ...<pattern>     pattern + its transitive workspace dependents
+//   <pattern>^...    only the transitive deps of pattern (excluding the matched package)
+//   !<pattern>       exclude packages matching pattern from the selection
+//   [<since>]        projects affected since the given git ref
+//                    (Turbo-style; resolved upstream of applyFilters via
+//                    `affectedProjects` since it needs FS + git access)
+//
+// Filters are evaluated in order. If any include filter is present, the base
+// set is empty and matched/expanded packages are added. If only excludes are
+// given, the base set is "all projects" and excluded packages are removed.
+
+import path from 'node:path'
+import type { PackageGraph } from './package-graph.js'
+import type { ProjectMeta } from './workspace.js'
+
+export interface ParsedFilter {
+  raw: string
+  negate: boolean
+  withDeps: boolean
+  withDependents: boolean
+  onlyDeps: boolean
+  isPath: boolean
+  /** Glob pattern (for name match) or absolute path (for path match). */
+  matcher: string
+  /**
+   * When non-undefined, this filter is a git-relative `[<since>]`
+   * selector. The matcher field is unused; the CLI resolves the ref
+   * to a concrete set of project names before calling applyFilters.
+   */
+  gitSince?: string
+}
+
+export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
+  let s = raw
+  const negate = s.startsWith('!')
+  if (negate) s = s.slice(1)
+
+  const withDependents = s.startsWith('...')
+  if (withDependents) s = s.slice(3)
+
+  let onlyDeps = false
+  let withDeps = false
+  if (s.endsWith('^...')) {
+    onlyDeps = true
+    s = s.slice(0, -4)
+  } else if (s.endsWith('...')) {
+    withDeps = true
+    s = s.slice(0, -3)
+  }
+
+  // `[<since>]` git-relative selector. Suffix walks already ran above,
+  // so `[main]...` parses as `[main]` with withDeps=true.
+  if (s.startsWith('[') && s.endsWith(']')) {
+    return {
+      raw,
+      negate,
+      withDeps,
+      withDependents,
+      onlyDeps,
+      isPath: false,
+      matcher: '',
+      gitSince: s.slice(1, -1),
+    }
+  }
+
+  let isPath = false
+  let matcher = s
+  if (s.startsWith('./') || s === '.') {
+    isPath = true
+    matcher = path.resolve(workspaceRoot, s)
+  } else if (s.startsWith('{') && s.endsWith('}')) {
+    isPath = true
+    matcher = path.resolve(workspaceRoot, s.slice(1, -1))
+  }
+
+  return { raw, negate, withDeps, withDependents, onlyDeps, isPath, matcher }
+}
+
+function matchProjects(
+  filter: ParsedFilter,
+  projects: ProjectMeta[],
+  affectedByFilter: Map<ParsedFilter, Set<string>> | undefined,
+): string[] {
+  // `[<since>]` selectors are pre-resolved by the caller (the parser
+  // is pure; git access happens upstream). Use the provided set as
+  // the match set for this filter.
+  if (filter.gitSince !== undefined) {
+    return [...(affectedByFilter?.get(filter) ?? new Set())]
+  }
+  const out: string[] = []
+  if (filter.isPath) {
+    const prefix = filter.matcher + path.sep
+    for (const p of projects) {
+      if (p.dir === filter.matcher || p.dir.startsWith(prefix)) out.push(p.name)
+    }
+    return out
+  }
+  if (!filter.matcher.includes('*')) {
+    for (const p of projects) {
+      if (p.name === filter.matcher) out.push(p.name)
+    }
+    return out
+  }
+  const glob = new Bun.Glob(filter.matcher)
+  for (const p of projects) {
+    if (glob.match(p.name)) out.push(p.name)
+  }
+  return out
+}
+
+export interface ApplyFiltersOptions {
+  filters: ParsedFilter[]
+  projects: ProjectMeta[]
+  graph: PackageGraph
+  /**
+   * Pre-resolved affected-project sets for each `[<since>]` filter.
+   * The caller (CLI / programmatic embedder) runs the git work and
+   * stuffs results in this map before calling applyFilters, which
+   * stays pure + sync.
+   */
+  affectedByFilter?: Map<ParsedFilter, Set<string>>
+}
+
+export function applyFilters(opts: ApplyFiltersOptions): Set<string> {
+  const allNames = opts.projects.map((p) => p.name)
+  const hasInclude = opts.filters.some((f) => !f.negate)
+  const selected = new Set<string>(hasInclude ? [] : allNames)
+
+  for (const f of opts.filters) {
+    const matched = matchProjects(f, opts.projects, opts.affectedByFilter)
+    const expanded = new Set<string>()
+    for (const name of matched) {
+      if (!f.onlyDeps) expanded.add(name)
+      if (f.withDeps || f.onlyDeps) {
+        for (const d of opts.graph.transitiveDeps(name)) expanded.add(d)
+      }
+      if (f.withDependents) {
+        for (const d of opts.graph.transitiveDependents(name)) expanded.add(d)
+      }
+    }
+    if (f.negate) {
+      for (const name of expanded) selected.delete(name)
+    } else {
+      for (const name of expanded) selected.add(name)
+    }
+  }
+
+  return selected
+}

package/src/workspace/fingerprint.ts

@@ -0,0 +1,41 @@
+import path from 'node:path'
+import { xxh3 } from '../util/index.js'
+
+// Every package-manager lockfile we know about, plus the workspace
+// definition files. Whichever ones exist get folded into the
+// fingerprint; missing ones are skipped. Hashed in declaration order
+// for determinism — adding a new entry here changes the fingerprint
+// for projects that have that file present, which is fine: that's the
+// whole point of bumping CACHE_VERSION when the fingerprint surface
+// expands.
+const WORKSPACE_FINGERPRINT_FILES = [
+  // Lockfiles
+  'pnpm-lock.yaml',
+  'package-lock.json',
+  'npm-shrinkwrap.json',
+  'yarn.lock',
+  'bun.lock',
+  'bun.lockb',
+  // Workspace definition (pnpm); package.json is hashed per-project
+  // via projectPackageJsonHash, not here.
+  'pnpm-workspace.yaml',
+]
+
+/**
+ * One hash for the workspace as a whole, derived from whichever
+ * lockfile + workspace-definition files exist at the root. Folded
+ * into every task's cache key so any lockfile bump (`pnpm update`,
+ * `npm install`, `bun install`, …) or a workspace-shape change
+ * invalidates every cached entry. Coarse but correct.
+ */
+export async function computeWorkspaceFingerprint(workspaceRoot: string): Promise<string> {
+  let h = 0n
+  for (const f of WORKSPACE_FINGERPRINT_FILES) {
+    const full = path.join(workspaceRoot, f)
+    const file = Bun.file(full)
+    if (!(await file.exists())) continue
+    h = xxh3(`${f}\0`, h)
+    h = xxh3(await file.bytes(), h)
+  }
+  return h.toString(16).padStart(16, '0')
+}

package/src/workspace/index.ts

@@ -0,0 +1,27 @@
+// Module contract. Cross-module imports must come through here; see
+// docs/design/module-isolation-2026-06.md and tests/module-boundaries.test.ts.
+
+export { affectedProjects, defaultAffectedBase } from './affected.js'
+export { applyFilters, parseFilter } from './filter.js'
+export { computeWorkspaceFingerprint } from './fingerprint.js'
+export { computeNestedProjectDirs } from './nested-dirs.js'
+export { buildPackageGraph, type PackageGraph } from './package-graph.js'
+export {
+  frozenProjectConfig,
+  LOCKFILE_NAME,
+  LOCKFILE_VERSION,
+  lockfilePath,
+  readLockfile,
+  writeLockfile,
+  type Lockfile,
+  type LockfileEntry,
+} from './lockfile.js'
+export { loadProjectConfig, loadWorkspaceConfig } from './project-loader.js'
+export {
+  findWorkspaceRoot,
+  listProjects,
+  loadWorkspace,
+  resolveCacheDir,
+  type ProjectEntry,
+  type ProjectMeta,
+} from './workspace.js'