@vzn/vx 0.0.31 → 0.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.31",
-    "@vzn/vx-linux-arm64": "0.0.31",
-    "@vzn/vx-darwin-x64": "0.0.31",
-    "@vzn/vx-darwin-arm64": "0.0.31"
+    "@vzn/vx-linux-x64": "0.0.33",
+    "@vzn/vx-linux-arm64": "0.0.33",
+    "@vzn/vx-darwin-x64": "0.0.33",
+    "@vzn/vx-darwin-arm64": "0.0.33"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/orchestrator/prepare.ts

@@ -9,7 +9,7 @@
 
 import path from 'node:path'
 import type { WorkspaceConfig } from '../config.js'
-import { mark, UserError } from '../util/index.js'
+import { mark, nearest, UserError } from '../util/index.js'
 import {
   Cache,
   noteSchemaReset,
@@ -408,6 +408,30 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),
     )
   }
+  // An `--exclude-dependencies` name no project declares drops nothing:
+  // `=biuld` planned the whole chain and ran it, exit 0 (item 1026). Every
+  // other name the user types must resolve; so must this one. After the
+  // graph, so a config error (`^biuld` nobody declares) is named first.
+  const excludeNames = options.excludeDependencies
+  if (Array.isArray(excludeNames) && excludeNames.length > 0) {
+    const declared = new Set<string>()
+    for (const p of projects.values())
+      for (const t of Object.keys(p.config.tasks ?? {})) declared.add(t)
+    let unknown = excludeNames.filter((n) => !declared.has(n))
+    if (unknown.length > 0 && projects.size < projectsWithConfigs.length) {
+      unknown = await declaredNowhere(unknown, () =>
+        loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),
+      )
+    }
+    if (unknown.length > 0) {
+      cache.close()
+      const hints = new Set(unknown.flatMap((n) => nearest(n, declared) ?? []))
+      const hint = hints.size === 0 ? '' : ` Did you mean ${[...hints].join(', ')}?`
+      throw new UserError(
+        `--exclude-dependencies names a task no project declares: ${unknown.join(', ')}.${hint}`,
+      )
+    }
+  }
   // The graph is built; what follows is the plugins' (graph, key,
   // schedule). Two rows, so a plugin's key stage reads as its own cost
   // and not as graph building — a lockfile plugin's 1000 stats per run

package/src/orchestrator/telemetry-host.ts

@@ -70,6 +70,7 @@ export async function subscribeTelemetry(
   extraSinks?: readonly TelemetrySink[],
 ): Promise<TelemetryHandle | undefined> {
   const sinks: TelemetrySink[] = extraSinks === undefined ? [] : [...extraSinks]
+  const owners = new Map<TelemetrySink, string>()
   for (const plugin of plugins) {
     if (plugin.telemetry === undefined) continue
     // A plugin's return value is user input, so it is checked here rather
@@ -100,12 +101,15 @@ export async function subscribeTelemetry(
       )
       continue
     }
+    for (const [i, sink] of accepted.entries()) {
+      owners.set(sink, accepted.length === 1 ? plugin.name : `${plugin.name} #${i + 1}`)
+    }
     sinks.push(...accepted)
   }
 
   if (sinks.length === 0) return undefined
 
-  const source = createTelemetrySource({ sinks, run, warn: (m) => ctx.warn(m) })
+  const source = createTelemetrySource({ sinks, run, warn: (m) => ctx.warn(m), owners })
   // The bus's unsubscribe is idempotent, so it is the handle's dispose as
   // is (a once-flag here survived item 654).
   const dispose = bus.subscribe(source.subscriber)

package/src/orchestrator/telemetry.ts

@@ -364,9 +364,15 @@ export function createTelemetrySource(args: {
   run: RunContextRecord
   /** Where a dropped-flush notice goes; absent = stay silent. */
   warn?: (message: string) => void
+  /** What a sink with no `name` of its own is called: its plugin's (the host's map). */
+  owners?: ReadonlyMap<TelemetrySink, string>
 }): TelemetrySource {
   const { sinks, run, warn } = args
   const runId = run.runId
+  // `name` is optional, and a nameless sink was reported as 'undefined'
+  // (item 1027): it goes by its plugin's name, else its place in the list.
+  const label = (sink: TelemetrySink): string =>
+    sink.name ?? args.owners?.get(sink) ?? `#${sinks.indexOf(sink) + 1}`
   // A sink is disabled the first time it throws — its name (or index) goes
   // here and it's skipped for the rest of the run, FLUSH INCLUDED. Flushing a
   // disabled sink would write a buffer that is incomplete by construction: it
@@ -381,7 +387,7 @@ export function createTelemetrySource(args: {
   const disable = (sink: TelemetrySink, hook: string, err: unknown): void => {
     disabled.add(sink)
     warn?.(
-      `[vx] telemetry sink '${sink.name}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
+      `[vx] telemetry sink '${label(sink)}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
     )
   }
   // Precompute which sinks want each kind, so per-event fan-out is a plain
@@ -500,7 +506,7 @@ export function createTelemetrySource(args: {
               // A flush failure can never break the run — but it still costs
               // this sink its export, so say so rather than dropping it.
               warn?.(
-                `[vx] telemetry sink '${sink.name}' failed to flush: ${err instanceof Error ? err.message : String(err)}`,
+                `[vx] telemetry sink '${label(sink)}' failed to flush: ${err instanceof Error ? err.message : String(err)}`,
               )
             }
           }),