perf: concurrent render via a worker pool (remove process chdir)

[vercel-eddie]

Summary

veil render now renders its resources through a bounded goroutine pool (--jobs, default runtime.NumCPU()) instead of one at a time, and drops the process-global os.Chdir that previously made concurrency unsafe.

The chdir removal (the enabler)

The render pipeline used to os.Chdir(projectRoot) before running hooks so QuickJS's built-in std/os modules resolved paths (loadFile, readdir, …) against the project root — qjs mounts the process cwd at / when no root is given. That chdir is process-global, so it can't be shared safely across concurrent renders.

QuickJS already accepts the filesystem root per runtime via qjs.Option.CWD (mounted at /). So each hook runtime now mounts the project root directly through a new hook.WithCwd(root) option — the host process never changes its own working directory. The root is the directory housing veil.json/veil.yaml (a session constant), threaded from render.Options.Root.

The pool

• runRender runs the paths through a bounded worker pool sized by --jobs (default NumCPU).
• Results land in a fixed-index slice, so the JSON response order is deterministic regardless of completion order.
• Per-resource path resolution stays relative to the user's cwd (no chdir to confuse it).

Shared state is already concurrency-safe: the kind registry and resource catalog both cache via sync.OnceValues, and each qjs runtime is independent.

Verification

• Byte-identical output vs the chdir implementation (re-rendered api-devbox through render.sh, no diff).
• 0 data races rendering 300 services at --jobs 16 under go build -race (and go test -race ./pkg/render ./pkg/commands).
• Full suite + go vet green.

Scale results (300 services, 14 cores)

Mode	Time	vs old
300 separate veil invocations (pre-batching)	139s	1×
batched, --jobs 1 (registry parsed once)	44s	3.2×
--jobs 4	15s	9.3×
--jobs 8	11s	12.6×
--jobs 14 (= default NumCPU)	~9s	~15×

Two compounding wins: batching one invocation (3.2×) and then the pool (~5× more), ~15× overall, tapering once CPU-bound on qjs hook execution past the core count.

🤖 Generated with Claude Code