@typed/virtual-modules-compiler 1.0.0-beta.1

package/README.md

@@ -0,0 +1,130 @@
+# @typed/virtual-modules-compiler
+
+A drop-in replacement for `tsc` that uses the custom compiler host from `@typed/virtual-modules`, enabling virtual module resolution during type-checking and compilation.
+
+## Why vmc?
+
+Virtual modules (e.g. `router:./routes`, `api:./endpoints`) exist at runtime via Vite or the TS plugin, but `tsc` cannot resolve them. vmc uses the same resolver so CI, `pnpm run typecheck`, and non-Vite workflows get correct type-checking and emit. A single config (`vmc.config.ts`) is shared with the TS plugin and `typedVitePlugin`.
+
+## Installation
+
+```bash
+pnpm add @typed/virtual-modules-compiler typescript
+```
+
+## Usage
+
+The `vmc` CLI mirrors `tsc` 100%:
+
+```bash
+# Initialize vmc.config.ts in project root
+vmc init
+
+# Single-shot compile (same as tsc)
+vmc
+
+# With options
+vmc --noEmit -p tsconfig.json
+
+# Watch mode
+vmc --watch
+
+# Build mode (project references)
+vmc --build
+```
+
+### Capabilities
+
+- Single-shot compile, `--noEmit`, `--watch`, `--build` (project references)
+- `vmc init` — scaffolds `vmc.config.ts` with a starter plugin
+- Inline plugins (name, shouldResolve, build)
+- Plugin modules (string paths to sync ESM)
+- Custom resolver
+- TypeInfo API in `build(id, importer, api)` for file/directory snapshots and assignability checks
+- Type target specs for structural assignability (auto-injected bootstrap file)
+
+### `vmc init`
+
+Creates an initial `vmc.config.ts` in the current directory with a starter plugin. Use `--force` to overwrite an existing config:
+
+```bash
+vmc init
+vmc init --force
+```
+
+## Configuration
+
+Place a `vmc.config.ts` in your project root (preferred) to configure virtual module plugins:
+
+```ts
+// vmc.config.ts
+export default {
+  plugins: [
+    {
+      name: "virtual-types",
+      shouldResolve: (id) => id.startsWith("virtual:"),
+      build: (id, _importer, api) => {
+        // Return generated TypeScript source
+        return `export type ${id.replace("virtual:", "")} = { value: string };`;
+      },
+    },
+  ],
+};
+```
+
+You can also provide plugin module specifiers (including sync ESM modules):
+
+```ts
+export default {
+  plugins: ["./plugins/virtual-types.mjs"],
+};
+```
+
+`vmc` plugin modules must be synchronous (no top-level await).
+
+Or provide a custom resolver:
+
+```ts
+export default {
+  resolver: myCustomResolver,
+};
+```
+
+## Plugin `build` callback and TypeInfoApi
+
+The `build(id, importer, api)` callback receives a `TypeInfoApi` instance:
+
+- `api.file(relativePath, options)` — file snapshot with exports and imports
+- `api.directory(relativeGlobs, options)` — directory snapshots
+- `api.resolveExport(baseDir, filePath, exportName)` — resolve an export by name
+- `api.isAssignableTo(node, targetId, projection?)` — structural assignability check
+
+Plugins that need assignability checks (e.g. Route, Effect) should declare `typeTargetSpecs`.
+
+## Type target specs
+
+Plugins can export `typeTargetSpecs` for structural assignability. vmc injects a bootstrap file into the program’s `rootNames` when present so type targets resolve from the same TypeScript program.
+
+For typed-smol apps using router and HttpApi virtual modules, use `createTypeInfoApiSessionForApp` from `@typed/app` to supply the session with router and HttpApi type targets.
+
+## How it works
+
+`vmc` parses the same command-line arguments as `tsc` via `ts.parseCommandLine`, then:
+
+1. Loads the resolver and plugins from `vmc.config.ts` (or returns an empty PluginManager)
+2. When `typeTargetSpecs` exist, writes a bootstrap file and adds it to `rootNames`
+3. Creates a standard `CompilerHost` with `ts.createCompilerHost`
+4. Wraps it with `attachCompilerHostAdapter` from `@typed/virtual-modules`
+5. Runs the compilation (single-shot, watch, or build) using the adapted host
+
+Virtual modules resolved by your plugins are injected into the compilation graph and type-checked alongside real files.
+
+## Errors
+
+vmc does **not** throw itself. Errors are surfaced via exit code (1) and TypeScript diagnostics. If the underlying adapter or resolver throws (e.g. invalid `projectRoot`), that may propagate uncaught. See [virtual-modules-errors-and-gotchas](../virtual-modules/.docs/virtual-modules-errors-and-gotchas.md) for full reference.
+
+## Ecosystem
+
+`vmc.config.ts` is shared by vmc, `@typed/virtual-modules-ts-plugin`, and `typedVitePlugin` (via `@typed/virtual-modules-vite`). The VS Code integration (`@typed/virtual-modules-vscode`) can use the same config via the `vmcConfigPath` option.
+
+For agent-facing guidance (exports, constraints, pointers), see [AGENTS.md](./AGENTS.md).

package/dist/build.d.ts

@@ -0,0 +1,15 @@
+import type * as ts from "typescript";
+import type { TypeTargetSpec, VirtualModuleResolver } from "@typed/virtual-modules";
+export interface BuildParams {
+    readonly ts: typeof import("typescript");
+    readonly buildCommand: ts.ParsedBuildCommand;
+    readonly resolver: VirtualModuleResolver;
+    readonly reportDiagnostic: ts.DiagnosticReporter;
+    readonly reportSolutionBuilderStatus?: ts.DiagnosticReporter;
+    readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+}
+/**
+ * Run the compiler in build mode (tsc -b). Mirrors tsc --build.
+ */
+export declare function runBuild(params: BuildParams): number;
+//# sourceMappingURL=build.d.ts.map

package/dist/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAkBpF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,cAAc,YAAY,CAAC,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC,kBAAkB,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IACzC,QAAQ,CAAC,gBAAgB,EAAE,EAAE,CAAC,kBAAkB,CAAC;IACjD,QAAQ,CAAC,2BAA2B,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC;IAC7D,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACtD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAmFpD"}

package/dist/build.js

@@ -0,0 +1,69 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { attachCompilerHostAdapter, createTypeInfoApiSessionFactory, ensureTypeTargetBootstrapFile, } from "@typed/virtual-modules";
+function inferProjectRoot(sys, rootNames, fallback) {
+    if (rootNames && rootNames.length > 0) {
+        return dirname(rootNames[0]);
+    }
+    return fallback;
+}
+/**
+ * Run the compiler in build mode (tsc -b). Mirrors tsc --build.
+ */
+export function runBuild(params) {
+    const { ts, buildCommand, resolver, reportDiagnostic, reportSolutionBuilderStatus, typeTargetSpecs } = params;
+    const { projects, buildOptions } = buildCommand;
+    const sys = ts.sys;
+    if (!sys) {
+        reportDiagnostic(createDiagnostic(ts, ts.DiagnosticCategory.Error, 0, 0, "ts.sys is not available."));
+        return 1;
+    }
+    const projectRoot = sys.getCurrentDirectory();
+    const createProgramForSession = (rootNames, opts) => {
+        const h = ts.createCompilerHost(opts ?? {});
+        return ts.createProgram(rootNames, opts ?? {}, h);
+    };
+    const createProgram = (rootNames, opts, host, oldProgram, configFileParsingDiagnostics, refs) => {
+        if (!host) {
+            host = ts.createCompilerHost(opts ?? {});
+        }
+        const root = inferProjectRoot(sys, rootNames, projectRoot);
+        let effectiveRootNames = rootNames ?? [];
+        if (typeTargetSpecs && typeTargetSpecs.length > 0) {
+            const bootstrapPath = ensureTypeTargetBootstrapFile(root, typeTargetSpecs, {
+                mkdirSync,
+                writeFile: (path, content) => sys.writeFile(path, content),
+            });
+            effectiveRootNames = effectiveRootNames.includes(bootstrapPath)
+                ? [...effectiveRootNames]
+                : [...effectiveRootNames, bootstrapPath];
+        }
+        const preliminaryProgram = createProgramForSession(effectiveRootNames, opts ?? {});
+        const createTypeInfoApiSession = createTypeInfoApiSessionFactory({
+            ts,
+            program: preliminaryProgram,
+            ...(typeTargetSpecs?.length ? { typeTargetSpecs } : {}),
+        });
+        const adapter = attachCompilerHostAdapter({
+            ts,
+            compilerHost: host,
+            resolver,
+            projectRoot: root,
+            createTypeInfoApiSession,
+            reportDiagnostic,
+        });
+        try {
+            return ts.createEmitAndSemanticDiagnosticsBuilderProgram(effectiveRootNames, opts ?? {}, host, oldProgram, configFileParsingDiagnostics, refs);
+        }
+        finally {
+            adapter.dispose();
+        }
+    };
+    const host = ts.createSolutionBuilderHost(sys, createProgram, reportDiagnostic, reportSolutionBuilderStatus);
+    const builder = ts.createSolutionBuilder(host, projects, buildOptions);
+    const exitCode = builder.build();
+    return exitCode === ts.ExitStatus.Success ? 0 : 1;
+}
+function createDiagnostic(ts, category, code, length, messageText) {
+    return { category, code, file: undefined, start: 0, length, messageText };
+}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import ts from "typescript";
+import { resolveCommandLine } from "./commandLine.js";
+import { loadResolver } from "./resolverLoader.js";
+import { compile } from "./compile.js";
+import { runWatch } from "./watch.js";
+import { runBuild } from "./build.js";
+import { runInit } from "./init.js";
+const args = process.argv.slice(2);
+const sys = ts.sys;
+if (!sys) {
+    console.error("vmc: ts.sys is not available.");
+    process.exit(1);
+}
+const reportDiagnostic = (diagnostic) => {
+    const message = ts.formatDiagnostic(diagnostic, {
+        getCanonicalFileName: (f) => f,
+        // oxlint-disable-next-line typescript/unbound-method
+        getCurrentDirectory: sys.getCurrentDirectory,
+        getNewLine: () => sys.newLine,
+    });
+    if (diagnostic.category === ts.DiagnosticCategory.Error) {
+        sys.write(message);
+    }
+    else {
+        sys.write(message);
+    }
+};
+function main() {
+    if (args[0] === "init") {
+        const force = args.includes("--force");
+        const result = runInit({
+            projectRoot: sys.getCurrentDirectory(),
+            force,
+        });
+        if (result.ok) {
+            sys.write(result.message + sys.newLine);
+            return 0;
+        }
+        sys.write(result.message + sys.newLine);
+        return 1;
+    }
+    const buildIndex = args.findIndex((a) => a === "--build" || a === "-b");
+    const watchIndex = args.findIndex((a) => a === "--watch" || a === "-w");
+    if (buildIndex >= 0) {
+        const buildArgs = args.filter((_, i) => i !== buildIndex);
+        const parsed = ts.parseBuildCommand(buildArgs);
+        for (const d of parsed.errors) {
+            reportDiagnostic(d);
+        }
+        if (parsed.errors.length > 0) {
+            return 1;
+        }
+        const projectRoot = sys.getCurrentDirectory();
+        const { resolver, typeTargetSpecs } = loadResolver(projectRoot);
+        return runBuild({
+            ts,
+            buildCommand: parsed,
+            resolver,
+            typeTargetSpecs,
+            reportDiagnostic,
+            reportSolutionBuilderStatus: reportDiagnostic,
+        });
+    }
+    const watchArgs = watchIndex >= 0 ? args.filter((_, i) => i !== watchIndex) : args;
+    // oxlint-disable-next-line typescript/unbound-method
+    let commandLine = ts.parseCommandLine(watchArgs, sys.readFile);
+    commandLine = resolveCommandLine(ts, commandLine, sys);
+    for (const d of commandLine.errors) {
+        reportDiagnostic(d);
+    }
+    if (commandLine.errors.length > 0) {
+        return 1;
+    }
+    const projectRoot = sys.getCurrentDirectory();
+    const { resolver, typeTargetSpecs } = loadResolver(projectRoot);
+    if (watchIndex >= 0) {
+        runWatch({
+            ts,
+            commandLine,
+            resolver,
+            typeTargetSpecs,
+            reportDiagnostic,
+            reportWatchStatus: (diag, newLine, _opts, _errorCount) => {
+                sys.write(ts.formatDiagnostic(diag, {
+                    getCanonicalFileName: (f) => f,
+                    // oxlint-disable-next-line typescript/unbound-method
+                    getCurrentDirectory: sys.getCurrentDirectory,
+                    getNewLine: () => newLine,
+                }));
+            },
+        });
+        return 0;
+    }
+    return compile({
+        ts,
+        commandLine,
+        resolver,
+        reportDiagnostic,
+        typeTargetSpecs,
+    });
+}
+process.exit(main());

package/dist/commandLine.d.ts

@@ -0,0 +1,8 @@
+import type * as ts from "typescript";
+/**
+ * Resolve the parsed command line. When fileNames is empty (e.g. "tsc" with no args),
+ * find tsconfig.json and use getParsedCommandLineOfConfigFile to populate fileNames.
+ * This mirrors tsc behavior.
+ */
+export declare function resolveCommandLine(ts: typeof import("typescript"), commandLine: ts.ParsedCommandLine, sys: ts.System): ts.ParsedCommandLine;
+//# sourceMappingURL=commandLine.d.ts.map

package/dist/commandLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandLine.d.ts","sourceRoot":"","sources":["../src/commandLine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,cAAc,YAAY,CAAC,EAC/B,WAAW,EAAE,EAAE,CAAC,iBAAiB,EACjC,GAAG,EAAE,EAAE,CAAC,MAAM,GACb,EAAE,CAAC,iBAAiB,CA0CtB"}

package/dist/commandLine.js

@@ -0,0 +1,43 @@
+/**
+ * Resolve the parsed command line. When fileNames is empty (e.g. "tsc" with no args),
+ * find tsconfig.json and use getParsedCommandLineOfConfigFile to populate fileNames.
+ * This mirrors tsc behavior.
+ */
+export function resolveCommandLine(ts, commandLine, sys) {
+    if (commandLine.fileNames.length > 0) {
+        return commandLine;
+    }
+    const project = commandLine.options.project;
+    const cwd = sys.getCurrentDirectory();
+    let configPath;
+    if (project) {
+        configPath = sys.fileExists(project)
+            ? project
+            : ts.findConfigFile(project, (p) => sys.fileExists(p));
+    }
+    else {
+        configPath = ts.findConfigFile(cwd, (p) => sys.fileExists(p));
+    }
+    if (!configPath) {
+        return commandLine;
+    }
+    const configHost = {
+        getCurrentDirectory: () => sys.getCurrentDirectory(),
+        useCaseSensitiveFileNames: sys.useCaseSensitiveFileNames,
+        readDirectory: sys.readDirectory,
+        fileExists: sys.fileExists,
+        readFile: (p) => sys.readFile(p),
+        onUnRecoverableConfigFileDiagnostic: (_d) => {
+            // Will be reported by caller
+        },
+    };
+    const resolved = ts.getParsedCommandLineOfConfigFile(configPath, commandLine.options, configHost);
+    if (!resolved) {
+        return commandLine;
+    }
+    return {
+        ...commandLine,
+        ...resolved,
+        options: { ...commandLine.options, ...resolved.options },
+    };
+}

package/dist/compile.d.ts

@@ -0,0 +1,16 @@
+import type * as ts from "typescript";
+import type { TypeTargetSpec, VirtualModuleResolver } from "@typed/virtual-modules";
+export interface CompileParams {
+    readonly ts: typeof import("typescript");
+    readonly commandLine: ts.ParsedCommandLine;
+    readonly resolver: VirtualModuleResolver;
+    readonly reportDiagnostic: ts.DiagnosticReporter;
+    /** Type target specs for structural assignability in TypeInfo API. From vmc.config when using loadResolver. */
+    readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+}
+/**
+ * Perform a single compile pass using the adapted compiler host.
+ * Mirrors tsc behavior: create program, emit, report diagnostics, return exit code.
+ */
+export declare function compile(params: CompileParams): number;
+//# sourceMappingURL=compile.d.ts.map

package/dist/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAOpF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,cAAc,YAAY,CAAC,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,EAAE,CAAC,iBAAiB,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IACzC,QAAQ,CAAC,gBAAgB,EAAE,EAAE,CAAC,kBAAkB,CAAC;IACjD,+GAA+G;IAC/G,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACtD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CA8GrD"}

package/dist/compile.js

@@ -0,0 +1,96 @@
+import { mkdirSync } from "node:fs";
+import { attachCompilerHostAdapter, createTypeInfoApiSessionFactory, ensureTypeTargetBootstrapFile, } from "@typed/virtual-modules";
+/**
+ * Perform a single compile pass using the adapted compiler host.
+ * Mirrors tsc behavior: create program, emit, report diagnostics, return exit code.
+ */
+export function compile(params) {
+    const { ts, commandLine, resolver, reportDiagnostic, typeTargetSpecs } = params;
+    const { options, fileNames, projectReferences } = commandLine;
+    const configFileParsingDiagnostics = commandLine.configFileParsingDiagnostics;
+    const configParseDiags = ts.getConfigFileParsingDiagnostics?.(commandLine) ?? commandLine.errors;
+    const allConfigErrors = [...(configFileParsingDiagnostics ?? []), ...configParseDiags];
+    for (const d of allConfigErrors) {
+        reportDiagnostic(d);
+    }
+    if (allConfigErrors.length > 0) {
+        return 1;
+    }
+    if (fileNames.length === 0) {
+        reportDiagnostic(createDiagnostic(ts, ts.DiagnosticCategory.Message, 0, 0, "No inputs were found in config file."));
+        return 0;
+    }
+    const sys = ts.sys;
+    if (!sys) {
+        reportDiagnostic(createDiagnostic(ts, ts.DiagnosticCategory.Error, 0, 0, "ts.sys is not available."));
+        return 1;
+    }
+    const projectRoot = sys.getCurrentDirectory();
+    let effectiveRootNames = fileNames;
+    if (typeTargetSpecs && typeTargetSpecs.length > 0) {
+        const bootstrapPath = ensureTypeTargetBootstrapFile(projectRoot, typeTargetSpecs, {
+            mkdirSync,
+            writeFile: (path, content) => sys.writeFile(path, content),
+        });
+        effectiveRootNames = fileNames.includes(bootstrapPath)
+            ? fileNames
+            : [...fileNames, bootstrapPath];
+    }
+    const host = ts.createCompilerHost(options);
+    // Preliminary program for TypeInfo API (plugins that use api.file()/api.directory() need it).
+    const preliminaryProgram = ts.createProgram({
+        rootNames: effectiveRootNames,
+        options,
+        host,
+        projectReferences,
+        configFileParsingDiagnostics: allConfigErrors,
+    });
+    const createTypeInfoApiSession = createTypeInfoApiSessionFactory({
+        ts,
+        program: preliminaryProgram,
+        ...(typeTargetSpecs?.length ? { typeTargetSpecs } : {}),
+    });
+    const adapter = attachCompilerHostAdapter({
+        ts,
+        compilerHost: host,
+        resolver,
+        projectRoot,
+        createTypeInfoApiSession,
+        reportDiagnostic,
+    });
+    let exitCode = 0;
+    try {
+        const program = ts.createProgram({
+            rootNames: effectiveRootNames,
+            options,
+            host,
+            projectReferences,
+            configFileParsingDiagnostics: allConfigErrors,
+        });
+        const preEmit = ts.getPreEmitDiagnostics(program);
+        // oxlint-disable-next-line typescript/unbound-method
+        const emitResult = program.emit(undefined, sys.writeFile);
+        const allDiagnostics = [...preEmit, ...emitResult.diagnostics];
+        for (const d of allDiagnostics) {
+            reportDiagnostic(d);
+        }
+        if (emitResult.emitSkipped ||
+            allDiagnostics.some((d) => d.category === ts.DiagnosticCategory.Error)) {
+            exitCode = 1;
+        }
+    }
+    finally {
+        adapter.dispose();
+    }
+    return exitCode;
+}
+function createDiagnostic(ts, category, code, length, messageText) {
+    return {
+        category,
+        code,
+        file: undefined,
+        start: 0,
+        length,
+        messageText,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { loadResolver, type LoadResolverResult, type VmcConfig, } from "./resolverLoader.js";
+export { resolveCommandLine } from "./commandLine.js";
+export { compile } from "./compile.js";
+export { runWatch } from "./watch.js";
+export { runBuild } from "./build.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,kBAAkB,EACvB,KAAK,SAAS,GACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { loadResolver, } from "./resolverLoader.js";
+export { resolveCommandLine } from "./commandLine.js";
+export { compile } from "./compile.js";
+export { runWatch } from "./watch.js";
+export { runBuild } from "./build.js";

package/dist/init.d.ts

@@ -0,0 +1,11 @@
+export interface InitOptions {
+    readonly projectRoot: string;
+    readonly force?: boolean;
+}
+export interface InitResult {
+    readonly ok: boolean;
+    readonly path: string;
+    readonly message: string;
+}
+export declare function runInit(options: InitOptions): InitResult;
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,CAkBxD"}

package/dist/init.js

@@ -0,0 +1,34 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const VMC_CONFIG_FILENAME = "vmc.config.ts";
+const INITIAL_VMC_CONFIG = `export default {
+  plugins: [
+    {
+      name: "example",
+      shouldResolve: (id) => id.startsWith("virtual:"),
+      build: (id) => {
+        // Return generated TypeScript source for the virtual module
+        const name = id.replace("virtual:", "");
+        return \`export type \${name} = { value: string };\`;
+      },
+    },
+  ],
+};
+`;
+export function runInit(options) {
+    const { projectRoot, force = false } = options;
+    const configPath = join(projectRoot, VMC_CONFIG_FILENAME);
+    if (existsSync(configPath) && !force) {
+        return {
+            ok: false,
+            path: configPath,
+            message: `vmc.config.ts already exists at ${configPath}. Use --force to overwrite.`,
+        };
+    }
+    writeFileSync(configPath, INITIAL_VMC_CONFIG.trim() + "\n", "utf8");
+    return {
+        ok: true,
+        path: configPath,
+        message: `Created ${configPath}`,
+    };
+}

package/dist/resolverLoader.d.ts

@@ -0,0 +1,15 @@
+import type { TypeTargetSpec, VirtualModuleResolver, VmcPluginEntry } from "@typed/virtual-modules";
+export interface VmcConfig {
+    readonly resolver?: VirtualModuleResolver;
+    readonly plugins?: readonly VmcPluginEntry[];
+}
+export interface LoadResolverResult {
+    readonly resolver: VirtualModuleResolver;
+    readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+}
+/**
+ * Load the resolver from vmc.config.* in projectRoot, or return an empty PluginManager.
+ * Also returns typeTargetSpecs when configured for structural assignability in TypeInfo API.
+ */
+export declare function loadResolver(projectRoot: string): LoadResolverResult;
+//# sourceMappingURL=resolverLoader.d.ts.map

package/dist/resolverLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolverLoader.d.ts","sourceRoot":"","sources":["../src/resolverLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,cAAc,EACf,MAAM,wBAAwB,CAAC;AAGhC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IACzC,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACtD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,kBAAkB,CAqBpE"}

package/dist/resolverLoader.js

@@ -0,0 +1,26 @@
+import ts from "typescript";
+import { loadResolverFromVmcConfig, PluginManager } from "@typed/virtual-modules";
+/**
+ * Load the resolver from vmc.config.* in projectRoot, or return an empty PluginManager.
+ * Also returns typeTargetSpecs when configured for structural assignability in TypeInfo API.
+ */
+export function loadResolver(projectRoot) {
+    const loaded = loadResolverFromVmcConfig({ projectRoot, ts });
+    if (loaded.status === "not-found") {
+        return { resolver: new PluginManager() };
+    }
+    if (loaded.status === "error") {
+        console.error(`[vmc] ${loaded.message}`);
+        process.exit(1);
+    }
+    if (loaded.pluginLoadErrors.length > 0) {
+        for (const error of loaded.pluginLoadErrors) {
+            console.error(`[vmc] Failed to load plugin "${error.specifier}": ${error.message}`);
+        }
+        process.exit(1);
+    }
+    return {
+        resolver: loaded.resolver ?? new PluginManager(),
+        ...(loaded.typeTargetSpecs ? { typeTargetSpecs: loaded.typeTargetSpecs } : {}),
+    };
+}

package/dist/watch.d.ts

@@ -0,0 +1,15 @@
+import type * as ts from "typescript";
+import type { TypeTargetSpec, VirtualModuleResolver } from "@typed/virtual-modules";
+export interface WatchParams {
+    readonly ts: typeof import("typescript");
+    readonly commandLine: ts.ParsedCommandLine;
+    readonly resolver: VirtualModuleResolver;
+    readonly reportDiagnostic: ts.DiagnosticReporter;
+    readonly reportWatchStatus?: ts.WatchStatusReporter;
+    readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+}
+/**
+ * Run the compiler in watch mode. Mirrors tsc --watch.
+ */
+export declare function runWatch(params: WatchParams): void;
+//# sourceMappingURL=watch.d.ts.map

package/dist/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../src/watch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAOpF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,cAAc,YAAY,CAAC,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,EAAE,CAAC,iBAAiB,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IACzC,QAAQ,CAAC,gBAAgB,EAAE,EAAE,CAAC,kBAAkB,CAAC;IACjD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC;IACpD,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACtD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAoFlD"}