@vibgrate/cli 1.0.79 → 1.0.80

package/DOCS.md

@@ -59,12 +59,13 @@ For a quick overview, see the [README](./README.md). This document covers everyt
 - [Privacy & Security](#privacy--security)
 - [Exit Codes](#exit-codes)
 - [Programmatic API](#programmatic-api)
+- [HCS Extract Runtime Prerequisites](#hcs-extract-runtime-prerequisites)
 
 ---
 
 ## How It Works
 
-Vibgrate recursively scans your repository for `package.json` (Node/TypeScript), `.sln`/`.csproj` (.NET), Python manifests, and Java build manifests. For each project it discovers, it:
+Vibgrate recursively scans your repository for `package.json` (Node/TypeScript), `.sln`/`.csproj`/`.vbproj` (.NET), Python manifests, and Java build manifests. For each project it discovers, it:
 
 1. **Detects** the runtime version, target framework, and all dependencies
 2. **Queries** the npm/NuGet registry for latest stable versions (with built-in caching and concurrency control)
@@ -101,7 +102,7 @@ This section summarizes what the CLI supports today and how to use each capabili
 Vibgrate currently discovers and evaluates projects in:
 
 - **Node.js / TypeScript** (`package.json`, lockfiles)
-- **.NET** (`.sln`, `.csproj`)
+- **.NET** (`.sln`, `.csproj`, `.vbproj`)
 - **Python** (`requirements.txt`, `pyproject.toml`-style manifests)
 - **Java** (`pom.xml`, Gradle-style manifests)
 
@@ -704,7 +705,7 @@ Vibgrate is built with a privacy-first architecture. Here's what it **never** do
 
 What it **does** collect:
 
-- Package names and version numbers (from `package.json`, `.csproj`, lockfiles)
+- Package names and version numbers (from `package.json`, `.csproj`/`.vbproj`, lockfiles)
 - Config structure flags (e.g. `strict: true` from `tsconfig.json`)
 - File names and sizes (paths and metadata, never contents)
 - Public npm/NuGet registry metadata (latest versions, deprecation flags)
@@ -752,3 +753,13 @@ import type {
 ---
 
 Copyright © 2026 Vibgrate. All rights reserved. See [LICENSE](https://vibgrate.com/license) for terms.
+
+## HCS Extract Runtime Prerequisites
+
+When using `vibgrate extract`, language workers run as subprocesses.
+
+- Swift currently uses the Node worker (text extraction), so no Swift/Xcode install is required for HCS extract at this time.
+- Go/Python/Java/.NET may require local runtimes (`go`, `python3`, `java`, `dotnet`) when platform-native workers are not bundled.
+- The CLI now emits install hints when these commands are missing on PATH.
+
+For OS-specific setup and packaging strategy, see [`HCS-RUNTIME-SETUP.md`](./HCS-RUNTIME-SETUP.md).

package/HCS-EXTRACT.md

@@ -0,0 +1,442 @@
+# HCS Extract — Architecture & Interface Guide
+
+How `vibgrate extract` discovers source code, spawns HCS workers, validates
+facts, and renders progress.
+
+---
+
+## Command synopsis
+
+```
+vibgrate extract [path] [options]
+
+Options:
+  -o, --out <file>         Write NDJSON to file (default: stdout)
+  --language <langs>       Comma-separated languages (default: auto-detect)
+  --include-tests          Include test files in analysis
+  --push                   Stream validated facts to dashboard API
+  --dsn <dsn>              DSN token for push (or VIBGRATE_DSN env)
+  --concurrency <n>        Parallel file workers (default: CPU count)
+  --timeout-mins <mins>    Total timeout in minutes (default: 60)
+  --feedback <file>        Load NDJSON diff artifact for refinement
+  --verbose                Print worker stderr and summary statistics
+```
+
+---
+
+## High-level architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     vibgrate CLI (ESM)                      │
+│                     packages/vibgrate-cli                   │
+├─────────────────────────────────────────────────────────────┤
+│  cli.ts                                                     │
+│    └── extractCommand   (src/commands/extract.ts)           │
+│    └── diffCommand      (src/commands/diff.ts)              │
+│                                                             │
+│  Extract orchestration:                                     │
+│    1. Validate args & options                               │
+│    2. Detect languages (walk filesystem for extensions)     │
+│    3. Spawn HCS worker process per language                 │
+│    4. Parse stdout (NDJSON facts) + stderr (progress/logs)  │
+│    5. Validate FactEnvelope schema for every line           │
+│    6. Write to stdout or --out file                         │
+│    7. Optionally --push to dashboard API                    │
+└───────────────┬─────────────────────────────────────────────┘
+                │  spawns: node --enable-source-maps <worker> --project <dir>
+                ▼
+┌─────────────────────────────────────────────────────────────┐
+│              HCS Node Worker (ESM, tsup bundle)             │
+│              packages/vibgrate-hcs/node                     │
+├─────────────────────────────────────────────────────────────┤
+│  dist/main.js  (~4.8 MB, bundles antlr4ts + vb6-antlr4)    │
+│                                                             │
+│  AST extractors (ts-morph):                                 │
+│    typescript, javascript                                   │
+│                                                             │
+│  Text/regex extractors:                                     │
+│    swift, rust, ruby, php, dart, scala, vb6, cobol          │
+│                                                             │
+│  STDOUT ─▶ NDJSON FactEnvelope lines                        │
+│  STDERR ─▶ [info], [warn], [error], [progress] lines        │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Package dependency chain
+
+```
+@vibgrate/cli
+  └── @vibgrate/hcs-node-worker  (workspace:*)
+        ├── ts-morph       (external — resolved from node_modules at runtime)
+        ├── commander      (external)
+        ├── antlr4ts       (bundled into dist/main.js by tsup)
+        └── vb6-antlr4     (bundled into dist/main.js by tsup)
+```
+
+### Build order
+
+The CLI's `build` and `build:only` scripts automatically build the HCS worker
+first via `pnpm run build:hcs`:
+
+```json
+{
+  "build":      "pnpm run build:hcs && tsup ... && pnpm test:solutions",
+  "build:only": "pnpm run build:hcs && tsup ...",
+  "build:hcs":  "pnpm --filter @vibgrate/hcs-node-worker build"
+}
+```
+
+The root-level `pnpm -r build` also resolves the correct order because pnpm
+sees the `workspace:*` dependency and topologically sorts accordingly.
+
+### Publishing
+
+| Package | `files` field | Notes |
+|---------|---------------|-------|
+| `@vibgrate/cli` | `["dist", "DOCS.md"]` | Built CLI + library |
+| `@vibgrate/hcs-node-worker` | `["dist"]` | Single-file worker bundle |
+
+When `@vibgrate/cli` is installed via npm, `@vibgrate/hcs-node-worker` is
+pulled in as a normal dependency. Its `dist/main.js` self-contains the ANTLR
+parsers; only `ts-morph` and `commander` are resolved transitively from
+node_modules.
+
+---
+
+## Worker resolution
+
+`extract.ts` → `resolveHcsWorkerBin()` locates the worker binary at runtime:
+
+| Priority | Method | When |
+|----------|--------|------|
+| 1 | `import.meta.resolve('@vibgrate/hcs-node-worker')` | Installed package or pnpm workspace link |
+| 2 | Monorepo sibling path: `../../vibgrate-hcs/node/dist/main.js` | Dev fallback |
+| 3 | Source path: `../../vibgrate-hcs/node/src/main.ts` | `tsx` dev mode |
+
+---
+
+## Language detection
+
+When `--language` is omitted, `extract.ts` walks the target directory and
+counts files by extension:
+
+| Language | Extensions |
+|----------|-----------|
+| typescript | `.ts`, `.tsx`, `.mts`, `.cts` |
+| javascript | `.js`, `.jsx`, `.mjs`, `.cjs` |
+| swift | `.swift` |
+| rust | `.rs` |
+| ruby | `.rb`, `.rake`, `.gemspec` |
+| php | `.php` |
+| dart | `.dart` |
+| scala | `.scala`, `.sc` |
+| cobol | `.cbl`, `.cob`, `.cpy`, `.cob85`, `.cobol` |
+| vb6 | `.vbp`, `.bas`, `.cls`, `.frm`, `.ctl`, `.dsr` |
+| go | `.go` |
+| python | `.py` |
+| java | `.java` |
+| csharp | `.cs` |
+| cplusplus | `.vcxproj`, `.cpp`, `.cc`, `.cxx`, `.hpp`, `.hh`, `.hxx`, `.h`, `.ixx` |
+| vbnet | `.vb` |
+
+Directories in `SKIP_DIRS` (`node_modules`, `.git`, `dist`, `build`, `target`,
+`vendor`, etc.) are skipped. Test files are excluded unless `--include-tests`
+is set.
+
+---
+
+## Worker dispatch
+
+Each detected language spawns a separate worker process:
+
+```
+node --enable-source-maps <worker> --project <dir>                  # TS/JS
+node --enable-source-maps <worker> --project <dir> --swift-project <dir>   # text langs
+node --enable-source-maps <worker> --project <dir> --cobol-project <dir> \
+  --cobol-copybook-paths <paths>                                    # COBOL
+```
+
+The `--concurrency` flag controls how many workers run in parallel (default:
+CPU count), managed by a `Semaphore` utility.
+
+For native workers (Go/Python/Java/.NET), if no bundled worker is available, the CLI falls back to local toolchains and emits installation hints when commands are missing. See [HCS-RUNTIME-SETUP.md](./HCS-RUNTIME-SETUP.md).
+
+---
+
+## Fact Envelope schema (ABI v0.2)
+
+Every NDJSON line emitted on stdout must conform to:
+
+```typescript
+interface FactEnvelope {
+  factId: string;        // "hcs:<FactType>:<sha256-16>"
+  factType: string;      // e.g. "SymbolDeclared", "CallObserved"
+  language: string;      // e.g. "typescript", "cobol"
+  scanner: string;       // "ts-morph"
+  scannerVersion: string; // "0.2.0"
+  emittedAt: string;     // ISO 8601 timestamp
+  payload: unknown;      // Fact-type-specific payload object
+}
+```
+
+The CLI validates every line against this schema. Invalid lines cause exit
+code `1` (schema failure).
+
+### Fact types emitted per language
+
+| Language | Fact types |
+|----------|-----------|
+| typescript | CallObserved, DataAccessOperation, EndpointMetadata, FileIndexed, ImportObserved, RouteDeclared, SqlStatementObserved, SqlUsage, SymbolDeclared |
+| javascript | ApiClientCall, CallObserved, DataAccessOperation, EndpointMetadata, ExternalServiceCall, FileIndexed, ImportObserved, RouteDeclared, SqlStatementObserved, SqlUsage, SymbolDeclared |
+| swift | ApiClientCall, ConfigAccess, PageRouteDeclared |
+| cplusplus | FileIndexed, ImportObserved, RouteDeclared, SqlUsage, SymbolDeclared, TestCaseDeclared |
+| rust | AnnotationFound, ExternalServiceCall, FileIndexed, ImportObserved, RouteDeclared, SymbolDeclared, TestCaseDeclared |
+| ruby | ConfigAccess, ExternalServiceCall, FileIndexed, ImportObserved, RouteDeclared, SqlUsage, SymbolDeclared |
+| php | ConfigAccess, ExternalServiceCall, FileIndexed, ImportObserved, SqlUsage, SymbolDeclared |
+| dart | ExternalServiceCall, FileIndexed, ImportObserved, RouteDeclared, SymbolDeclared |
+| scala | ConfigAccess, FileIndexed, ImportObserved, SymbolDeclared |
+| vb6 | AnnotationFound, CallObserved, ConfigAccess, FieldDeclared, SqlUsage, SymbolDeclared |
+| cobol | CallObserved, CobolConfidenceReport, CobolProgramDeclared, ExecBlockObserved, FileResourceDeclared, RecordLayoutDeclared, SqlStatementObserved, SqlUsage, SymbolDeclared |
+
+---
+
+## AST extractors (TypeScript / JavaScript)
+
+These use [ts-morph](https://ts-morph.com) to build a full TypeScript AST and
+run extractors in dependency order:
+
+| # | Extractor | Emits |
+|---|-----------|-------|
+| 1 | `FileIndexedExtractor` | `FileIndexed` |
+| 2 | `SymbolAndCallGraphExtractor` | `SymbolDeclared`, `CallObserved` |
+| 3 | `ImportObservedExtractor` | `ImportObserved` |
+| 4 | `RouteExtractor` | `RouteDeclared`, `EndpointMetadata` |
+| 5 | `EntityExtractor` | `EntityDeclared`, `FieldDeclared` |
+| 6 | `AuthExtractor` | `AuthBoundaryDeclared`, `RoleRequirement` |
+| 7 | `SqlUsageExtractor` | `SqlUsage` |
+| 8 | `DataAccessOperationExtractor` | `DataAccessOperation` |
+| 9 | `ConfigExtractor` | `ConfigAccess` |
+| 10 | `TestCaseDeclaredExtractor` | `TestCaseDeclared` |
+| 11 | `MigrationDeclaredExtractor` | `MigrationDeclared` |
+| 12 | `EventEmittedExtractor` | `EventEmitted` |
+| 13 | `EventConsumedExtractor` | `EventConsumed` |
+| 14 | `ExternalServiceCallExtractor` | `ExternalServiceCall`, `ApiClientCall` |
+| 15 | `SqlObjectDeclaredExtractor` | `SqlObjectDeclared` |
+| 16 | `ComponentExtractor` | `ComponentDeclared` |
+| 17 | `ClientRouteExtractor` | `PageRouteDeclared` |
+| 18 | `StateExtractor` | `StateStoreDeclared` |
+
+### Text extractors (regex-based, no AST)
+
+| Language | Extractor classes |
+|----------|------------------|
+| Swift | `SwiftApiCallExtractor`, `SwiftConfigExtractor`, `SwiftNavigationExtractor` |
+| VB6 | `VB6ProjectExtractor`, `VB6SymbolExtractor`, `VB6SqlExtractor`, `VB6ConfigExtractor`, `VB6FormsExtractor` |
+| Rust | `RustExtractor` |
+| Ruby | `RubyExtractor` |
+| PHP | `PhpExtractor` |
+| Dart | `DartExtractor` |
+| Scala | `ScalaExtractor` |
+| C++ | `CppExtractor` |
+| COBOL | `CobolAdapter` (wraps ANTLR parser + preprocessor + SQL/data/procedure extractors) |
+
+---
+
+## Progress reporting protocol
+
+The HCS worker emits structured progress events on **stderr** using the
+`[progress]` prefix. The CLI parses these for live terminal display.
+
+### Worker → CLI protocol
+
+```
+[progress] {"phase":"discovering","language":"typescript"}
+[progress] {"phase":"scanning","language":"rust","fileCount":142,"fileIndex":0}
+[progress] {"phase":"scanning","language":"rust","file":"src/main.rs","fileIndex":1,"fileCount":142}
+[progress] {"phase":"extracting","extractor":"SymbolAndCallGraphExtractor","fileIndex":2,"fileCount":18}
+[progress] {"phase":"done","language":"rust","fileCount":142}
+```
+
+### Progress event schema
+
+```typescript
+interface ProgressEvent {
+  phase: "discovering" | "scanning" | "extracting" | "done";
+  language?: string;
+  file?: string;         // Absolute path of file being processed
+  fileIndex?: number;     // 1-based current file/extractor index
+  fileCount?: number;     // Total files or extractors
+  extractor?: string;     // Extractor class name (AST extractors)
+}
+```
+
+### CLI progress rendering
+
+The `ProgressTracker` class in `extract.ts` renders a single-line progress
+bar on stderr:
+
+```
+  typescript 12/42 29%  rust ✓  ruby extracting  23 facts
+```
+
+| Behaviour | TTY (interactive) | Pipe / CI |
+|-----------|-------------------|-----------|
+| Display | `\r`-overwriting single line, 12 fps throttle | No progress line (clean logs) |
+| Facts | Live counter | `--verbose` summary only |
+| Completion | Line cleared, summary printed | Summary only |
+
+stderr is used exclusively so that stdout remains pure NDJSON.
+
+---
+
+## I/O channel separation
+
+```
+┌──────────────┐     stdout (NDJSON)      ┌──────────────┐
+│  HCS Worker  │ ─────────────────────▶   │   CLI        │ ──▶ stdout / --out file
+│              │     stderr               │              │
+│              │ ─────────────────────▶   │ (progress    │ ──▶ stderr (progress/logs)
+│              │  [info] [progress] etc   │  tracker)    │
+└──────────────┘                          └──────────────┘
+```
+
+- **stdout**: Only NDJSON `FactEnvelope` lines. One JSON object per line.
+  The CLI validates each line, collects valid facts, sorts them, and writes
+  to stdout (or `--out` file).
+- **stderr**: Human-readable logs (`[info]`, `[warn]`, `[error]`) and
+  machine-readable `[progress]` JSON lines. Shown in `--verbose` mode
+  (except progress, which is always parsed).
+
+---
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success |
+| 1 | Schema validation failure (invalid fact envelope) |
+| 2 | Worker parse failure |
+| 3 | Timeout exceeded |
+| 4 | Push to dashboard API failed |
+| 5 | Usage error (bad args) |
+
+---
+
+## ESM bundling details
+
+The HCS worker is built with [tsup](https://tsup.egoist.dev) using
+`packages/vibgrate-hcs/node/tsup.config.ts`:
+
+```typescript
+export default defineConfig({
+  entry: ["src/main.ts"],
+  format: ["esm"],
+  target: "es2022",
+  platform: "node",
+  noExternal: ["antlr4ts", "vb6-antlr4"],  // Bundle ANTLR parsers
+  esbuildOptions(options) {
+    options.banner = {
+      js: [
+        '#!/usr/bin/env node',
+        'import { createRequire as __cjsRequire } from "node:module";',
+        'const require = __cjsRequire(import.meta.url);',
+      ].join('\n'),
+    };
+  },
+});
+```
+
+Key decisions:
+- `antlr4ts` and `vb6-antlr4` are **bundled** because their generated ANTLR
+  files use extensionless imports that fail under Node ESM strict resolution.
+- A `createRequire` banner shim is injected **before** esbuild's `__require`
+  IIFE so that bundled CJS code (antlr4ts internals) can call `require()`
+  without throwing `ERR_REQUIRE_ESM`.
+- `ts-morph` and `commander` remain external — resolved normally from
+  node_modules at runtime.
+
+---
+
+## Integration tests
+
+```
+pnpm test:hcs                    # from packages/vibgrate-cli
+```
+
+Runs `test-hcs/test-runner.ts` which exercises all 10 languages against the
+**built** CLI binary. Each language has fixture files under
+`test-hcs/fixtures/<language>/`.
+
+| Check | Description |
+|-------|-------------|
+| Exit code | Must be 0 |
+| NDJSON validity | Every stdout line must parse as valid JSON |
+| FactEnvelope schema | All required fields present and typed |
+| Min fact count | Language-specific minimum (3–5) |
+| Required fact types | Language-specific fact types must appear |
+| Language field | Must match the expected language |
+| factId uniqueness | All factIds should be unique (warning if not) |
+
+### Running tests
+
+```bash
+# Full build + test
+pnpm build:only && pnpm test:hcs
+
+# Just tests (assumes built)
+pnpm test:hcs
+
+# Verbose output
+pnpm test:hcs -- --verbose
+```
+
+---
+
+## Directories
+
+```
+packages/vibgrate-cli/
+  src/commands/extract.ts      # CLI extract orchestration + progress tracker
+  src/commands/diff.ts         # CLI diff command (NDJSON delta comparison)
+  test-hcs/
+    test-runner.ts             # Integration test runner (10 languages)
+    fixtures/                  # Per-language fixture projects
+      typescript/              # Express + Prisma app
+      javascript/              # Express + SQL + axios app
+      swift/                   # SwiftUI + URLSession app
+      rust/                    # actix-web + sqlx + reqwest app
+      ruby/                    # Sinatra + ActiveRecord app
+      php/                     # Laravel controller
+      dart/                    # Flutter + http app
+      scala/                   # Akka HTTP + Slick app
+      vb6/                     # VB6 module (Type, Sub, Function, SQL)
+      cobol/                   # COBOL with EXEC SQL + file I/O
+
+packages/vibgrate-hcs/node/
+  src/main.ts                  # Worker entry — commander, dispatch, progress
+  src/facts/
+    fact-emitter.ts            # NdjsonFactEmitter (FactEnvelope, emit helpers)
+    fact-types.ts              # TypeScript interfaces for all payload types
+  src/extractors/
+    extractor.ts               # Extractor interface (AST-based)
+    text-extractor.ts          # TextExtractor interface (regex-based)
+    file-indexed.ts            # FileIndexedExtractor
+    symbol-call-graph.ts       # SymbolAndCallGraphExtractor
+    import-observed.ts         # ImportObservedExtractor
+    routes.ts                  # RouteExtractor
+    ...                        # 18 AST extractors total
+    rust-extractor.ts          # RustExtractor
+    ruby-extractor.ts          # RubyExtractor
+    php-extractor.ts           # PhpExtractor
+    dart-extractor.ts          # DartExtractor
+    scala-extractor.ts         # ScalaExtractor
+    swift-*.ts                 # 3 Swift extractors
+    vb6-*.ts                   # 5 VB6 extractors
+    cobol-adapter.ts           # CobolAdapter (wraps ANTLR pipeline)
+    cobol-*.ts                 # COBOL parser + 5 sub-extractors
+  tsup.config.ts               # Build config (bundle ANTLR, createRequire shim)
+  dist/main.js                 # Built worker (~4.8 MB)
+```

package/HCS-RUNTIME-SETUP.md

@@ -0,0 +1,73 @@
+# HCS Runtime Setup (Windows, macOS, Linux)
+
+This guide explains what must be installed to run `vibgrate extract` across languages.
+
+## Important behavior
+
+- **Swift scanning currently uses the Node worker (text/regex extraction)**, so no Swift/Xcode toolchain is required today.
+- **Native AST scanners** currently exist for: Go, Python, Java, and .NET (C#).
+- The CLI tries to run **bundled native workers** first when present in `dist/workers/`.
+- If no bundled worker exists, the CLI falls back to local toolchains (`go`, `python3`, `java`, `dotnet`).
+
+## What the CLI can and cannot auto-install
+
+- The CLI **does not auto-install system runtimes/toolchains**.
+- On first run, if a required runtime is missing, CLI errors include install hints.
+- Recommended enterprise approach: pre-provision toolchains in base images or publish bundled workers for each target OS.
+
+## Prerequisites by language
+
+### Go (`--language go`)
+
+- Runtime command needed when no bundled worker exists: `go`
+- Install docs: https://go.dev/doc/install
+
+Quick install examples:
+- macOS: `brew install go`
+- Windows: `winget install GoLang.Go`
+- Linux: install from `https://go.dev/dl/` or distro package manager
+
+### Python (`--language python`)
+
+- Runtime command needed when no bundled worker exists: `python3`
+- Install docs: https://www.python.org/downloads/
+
+Quick install examples:
+- macOS: `brew install python`
+- Windows: `winget install Python.Python.3.12`
+- Linux: install Python 3.10+ from distro package manager
+
+### Java (`--language java`)
+
+- Runtime command needed when no bundled worker exists: `java` (JRE/JDK 17+)
+- Install docs: https://adoptium.net/
+
+Quick install examples:
+- macOS: `brew install --cask temurin`
+- Windows: `winget install EclipseAdoptium.Temurin.17.JRE`
+- Linux: install OpenJDK 17+
+
+### C# / .NET (`--language csharp`) and VB.NET (`--language vbnet` or `--language vb.net`)
+
+Resolution order in CLI:
+1. Platform-native bundled worker executable (if present)
+2. `dotnet VibgrateHcsWorker.dll`
+3. `dotnet run --project VibgrateHcsWorker.csproj` (source mode)
+
+- Runtime command needed for fallback modes: `dotnet`
+- Install docs: https://dotnet.microsoft.com/download
+
+Quick install examples:
+- macOS: `brew install --cask dotnet-sdk`
+- Windows: `winget install Microsoft.DotNet.SDK.8`
+- Linux: install .NET 8 SDK/runtime from Microsoft packages
+
+## Packaging guidance for full coverage
+
+For easiest user experience across Windows/macOS/Linux:
+
+1. Build and ship worker artifacts per OS/arch in `dist/workers/`.
+2. Keep runtime fallback for dev workflows.
+3. Document minimum versions in release notes and this setup guide.
+4. In CI images, pre-install toolchains if not shipping bundled workers.
+

package/README.md

@@ -116,7 +116,7 @@ We keep output plain and operational: easy to convert into backlog items and CI
 Vibgrate recursively scans mixed repositories and supports:
 
 - Node.js / TypeScript (`package.json`)
-- .NET (`.sln`, `.csproj`)
+- .NET (`.sln`, `.csproj`, `.vbproj`)
 - Python (`requirements.txt`, `pyproject.toml` style ecosystems)
 - Java (`pom.xml`, Gradle-style manifest ecosystems)
 

package/dist/{baseline-NRKROYVK.js → baseline-WDQNMJ4M.js}

@@ -1,8 +1,8 @@
 import {
   baselineCommand,
   runBaseline
-} from "./chunk-DKSPLRJV.js";
-import "./chunk-TKNDQ337.js";
+} from "./chunk-UH7CY33M.js";
+import "./chunk-22VJDYG5.js";
 import "./chunk-JQHUH6A3.js";
 export {
   baselineCommand,