@velarscript/cli 0.10.1

package/dist/cli.js

@@ -0,0 +1,1274 @@
+#!/usr/bin/env node
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { cp, lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { formatSource } from "@velarscript/compiler";
+import { createVelarProject, parseCreateArguments } from "create-velar";
+import { projectImportKey } from "./project.js";
+import { checkResolvedProject, discoverVelarSources, formatCheckOutput, projectTestModules } from "./project-check.js";
+import { reproductionHint, writeReproduction } from "./reproduction.js";
+import { runDevServer } from "./dev-server.js";
+import { createFrameworkArtifacts } from "./framework-host.js";
+import { resolveVelarProject } from "./config.js";
+import { STANDARD_MODULE_ADAPTER_DEPENDENCIES, standardModuleClosure, standardModuleSource, standardModuleSources } from "./standard-modules.js";
+import { runTests } from "./test-runner.js";
+import { runProgram } from "./program-runner.js";
+import { buildProductionFramework, writeProductionManifest } from "./production-build.js";
+import { VELAR_VERSION } from "./version.js";
+import { assertRequiredPublicAssets, copyPublicAssets, writeStaticDeployment } from "./static-deployment.js";
+import { verifyProductionBuild } from "./production-verifier.js";
+import { runProductionPreview } from "./preview-server.js";
+import { createDeploymentVerificationReport, verifyRemoteDeployment } from "./deployment-verifier.js";
+import { readVelarSourceFile } from "./source-limits.js";
+import { parseDependencyArguments, runDependencyCommand } from "./package-manager.js";
+import { hostErrorMessage, isHostErrorCode } from "./host-error.js";
+import { loadApplicationPackageHost, validateApplicationPackageResult } from "./application-package-host.js";
+import { buildLanguageServerTool, VELAR_LANGUAGE_SERVER_TOOL_ID } from "./language-server-tool.js";
+import { buildProjectTaskTool, VELAR_PROJECT_TASK_TOOL_ID } from "./project-task-tool.js";
+import { buildBuildEngineTool, VELAR_BUILD_ENGINE_TOOL_ID } from "./build-engine-tool.js";
+import { applyProjectMechanicalFixes } from "./mechanical-fixer.js";
+import { bundleStandaloneJavaScript, needsStandaloneJavaScriptBundle } from "./standalone-build.js";
+import { resolveInstalledPackageRoot } from "./installed-package.js";
+import { BUILD_STAGING_MARKER } from "./build-staging.js";
+import { assertUniqueEmbeddedModuleOutputs, embeddedModuleFileContents, embeddedModuleOutputPath, VELAR_EMBEDDED_MODULE_MARKER, } from "./embedded-modules.js";
+async function main(arguments_) {
+    const [command, ...rest] = arguments_;
+    if (!command || command === "--help" || command === "-h") {
+        if (rest.length > 0) {
+            process.stderr.write("velar help: unexpected arguments after the top-level help option\n");
+            return 2;
+        }
+        printHelp();
+        return 0;
+    }
+    if (command === "help") {
+        if (rest.length === 0) {
+            printHelp();
+            return 0;
+        }
+        if (rest.length !== 1 || !commandNames.has(rest[0])) {
+            process.stderr.write(`velar help: unknown command '${rest[0] ?? ""}'\n`);
+            return 2;
+        }
+        printCommandHelp(rest[0]);
+        return 0;
+    }
+    if (command === "--version" || command === "-v") {
+        if (rest.length > 0) {
+            process.stderr.write("velar --version: this option does not accept arguments\n");
+            return 2;
+        }
+        process.stdout.write(`velar ${VELAR_VERSION}\n`);
+        return 0;
+    }
+    if (commandNames.has(command) && helpRequested(command, rest)) {
+        printCommandHelp(command);
+        return 0;
+    }
+    if (command === "lsp") {
+        if (rest.length > 0) {
+            process.stderr.write("velar lsp: this command does not accept arguments\n");
+            return 2;
+        }
+        const temporary = await mkdtemp(join(tmpdir(), "velar-language-server-"));
+        const tool = join(temporary, "language-server.mjs");
+        try {
+            await buildLanguageServerTool(tool);
+            await import(__rewriteRelativeImportExtension(pathToFileURL(tool).href));
+        }
+        finally {
+            await rm(temporary, { recursive: true, force: true });
+        }
+        return 0;
+    }
+    if (command === "skill") {
+        if (rest.length > 0) {
+            process.stderr.write("velar skill: this command does not accept arguments\n");
+            return 2;
+        }
+        process.stdout.write(await readFile(new URL("../skill/ai-skill.md", import.meta.url), "utf8"));
+        return 0;
+    }
+    if (command === "create") {
+        const parsed = parseCreateArguments(rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar create: ${parsed}\n`);
+            return 2;
+        }
+        try {
+            const result = await createVelarProject(parsed.directory, { template: parsed.template });
+            process.stdout.write(`Created VelarScript ${result.template} project -> ${result.root}\n`);
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`velar create: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+    }
+    if (command === "install" || command === "add" || command === "remove" || command === "update") {
+        const parsed = parseDependencyArguments(command, rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar ${command}: ${parsed}\n`);
+            return 2;
+        }
+        try {
+            const result = await runDependencyCommand(command, parsed);
+            process.stdout.write(dependencyResultMessage(command, result.root, result.packages, result.activatedExtensions, result.removedExtensions));
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`velar ${command}: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+    }
+    if (command === "verify") {
+        const input = parseSingleOptionalInput(rest);
+        if (input !== null && typeof input === "object") {
+            process.stderr.write(`velar verify: ${input.error}\n`);
+            return 2;
+        }
+        try {
+            const verified = await verifyProductionBuild(input);
+            process.stdout.write(`Verified production ${verified.manifest.framework.capability} build ${verified.manifest.buildId} -> ${verified.directory}\n`);
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`velar verify: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+    }
+    if (command === "preview") {
+        const parsed = parsePreviewArguments(rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar preview: ${parsed}\n`);
+            return 2;
+        }
+        try {
+            const verified = await verifyProductionBuild(parsed.input);
+            await runProductionPreview(verified, parsed.port);
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`velar preview: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+    }
+    if (command === "verify-deployment") {
+        const parsed = parseDeploymentVerificationArguments(rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar verify-deployment: ${parsed}\n`);
+            return 2;
+        }
+        const url = parsed.url ?? process.env.VELAR_DEPLOYMENT_URL?.trim() ?? "";
+        if (!url) {
+            process.stderr.write("velar verify-deployment: provide --url <deployment-origin> or VELAR_DEPLOYMENT_URL\n");
+            return 2;
+        }
+        try {
+            const verified = await verifyProductionBuild(parsed.input);
+            const deployment = await verifyRemoteDeployment(verified, url);
+            if (parsed.json) {
+                process.stdout.write(`${JSON.stringify(createDeploymentVerificationReport(verified, deployment), null, 2)}\n`);
+            }
+            else {
+                process.stdout.write(`Verified deployed ${verified.manifest.framework.capability} build ${deployment.buildId} at ${deployment.url} `
+                    + `(${deployment.checkedFiles} files, ${deployment.checkedRoutes} routes, ${deployment.checkedHeaders} headers)\n`);
+            }
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`velar verify-deployment: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+    }
+    if (command === "run") {
+        const parsed = parseRunArguments(rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar run: ${parsed}\n`);
+            return 2;
+        }
+        let projectConfig;
+        try {
+            projectConfig = await resolveVelarProject(parsed.input);
+        }
+        catch (error) {
+            process.stderr.write(`velar run: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        if (projectConfig.framework) {
+            process.stderr.write(`velar run: this project enables the '${projectConfig.framework.host.id}' application framework; use 'velar dev' or 'velar build' instead\n`);
+            return 1;
+        }
+        try {
+            return await runProgram(projectConfig, parsed.programArguments, { fullStack: parsed.fullStack });
+        }
+        catch (error) {
+            process.stderr.write(`velar run: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+    }
+    if (command === "fix") {
+        const input = parseSingleOptionalInput(rest);
+        if (input !== null && typeof input === "object") {
+            process.stderr.write(`velar fix: ${input.error}\n`);
+            return 2;
+        }
+        let fixConfig;
+        try {
+            fixConfig = await resolveVelarProject(input);
+        }
+        catch (error) {
+            process.stderr.write(`velar fix: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        let report;
+        try {
+            report = await applyProjectMechanicalFixes(fixConfig, displayPath, 8, await projectTestModules(fixConfig));
+        }
+        catch (error) {
+            process.stderr.write(`velar fix: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        for (const change of report.changes)
+            process.stdout.write(`${change}\n`);
+        if (report.remainingDiagnostics.length > 0)
+            process.stderr.write(`${report.remainingDiagnostics.join("\n\n")}\n`);
+        // D51 item NEW-D8: a write that failed is named, and the summary that says
+        // what did change is printed either way — a rewritten tree is never left
+        // unreported.
+        for (const failure of report.writeFailures)
+            process.stderr.write(`velar fix: could not write ${failure}\n`);
+        const files = report.changedFiles.length;
+        process.stdout.write(`applied ${report.changes.length} mechanical fix${report.changes.length === 1 ? "" : "es"}`
+            + `${files > 0 ? ` in ${files} file${files === 1 ? "" : "s"}` : ""}`
+            + `${report.writeFailures.length > 0 ? `; ${report.writeFailures.length} file${report.writeFailures.length === 1 ? "" : "s"} could not be written` : ""}`
+            + `; ${report.remainingDiagnostics.length} diagnostic${report.remainingDiagnostics.length === 1 ? " remains" : "s remain"}\n`);
+        return report.remainingDiagnostics.length > 0 || report.writeFailures.length > 0 ? 1 : 0;
+    }
+    if (command === "repro") {
+        const parsed = parseReproArguments(rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar repro: ${parsed}\n`);
+            return 2;
+        }
+        let reproConfig;
+        try {
+            reproConfig = await resolveVelarProject(parsed.input);
+        }
+        catch (error) {
+            process.stderr.write(`velar repro: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        try {
+            const checked = await checkResolvedProject(reproConfig, parsed.input);
+            if (checked.errors.length === 0) {
+                process.stderr.write(`velar repro: ${displayInput(parsed.input, reproConfig)} checks without errors; there is no failure to reproduce\n`);
+                return 1;
+            }
+            const reproduction = await writeReproduction({
+                config: reproConfig,
+                input: parsed.input,
+                checked,
+                outputDirectory: parsed.outputDirectory,
+                toolchainEntry: fileURLToPath(import.meta.url),
+            });
+            process.stdout.write(`Wrote a minimal reproduction of ${checked.errors.length} diagnostic${checked.errors.length === 1 ? "" : "s"} -> ${reproduction.directory}\n`);
+            // Discipline 3: the bundle was re-checked in an extracted copy, and a
+            // bundle that stopped reproducing says so instead of being handed over
+            // as a clean report.
+            process.stdout.write(reproduction.reproduced
+                ? "The extracted bundle produces the same diagnostics.\n"
+                : "Reproduces on this machine but not in the extracted bundle; the README says what the copy reported instead.\n");
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`velar repro: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+    }
+    if (command !== "check" && command !== "build" && command !== "package" && command !== "format" && command !== "dev" && command !== "test") {
+        process.stderr.write(`Unknown command '${command}'.\n\n`);
+        printHelp(process.stderr);
+        return 2;
+    }
+    if (command === "format") {
+        const parsed = parseFormatArguments(rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar format: ${parsed}\n`);
+            return 2;
+        }
+        const singleFile = parsed.input !== null && extname(resolve(parsed.input)) === ".vel";
+        let inputs;
+        let formattingExtensions = [];
+        try {
+            if (singleFile) {
+                inputs = [resolve(parsed.input)];
+                const config = await resolveVelarProject(parsed.input);
+                formattingExtensions = config.compilerExtensions;
+            }
+            else {
+                const config = await resolveVelarProject(parsed.input);
+                inputs = await discoverVelarSources(config);
+                formattingExtensions = config.compilerExtensions;
+            }
+        }
+        catch (error) {
+            process.stderr.write(`velar format: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        if (inputs.length === 0) {
+            process.stderr.write("velar format: no .vel source files were found\n");
+            return 1;
+        }
+        const changed = [];
+        try {
+            for (const input of inputs) {
+                const source = await readVelarSourceFile(input);
+                const formatted = formatSource(source, { extensions: formattingExtensions });
+                if (formatted === source)
+                    continue;
+                changed.push(input);
+                if (!parsed.check)
+                    await writeFile(input, formatted, "utf8");
+            }
+        }
+        catch (error) {
+            process.stderr.write(`velar format: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        if (parsed.check && changed.length > 0) {
+            for (const input of changed)
+                process.stderr.write(`${displayPath(input)} is not formatted\n`);
+            process.stderr.write(`${changed.length} of ${inputs.length} VelarScript source file${inputs.length === 1 ? "" : "s"} require formatting\n`);
+            return 1;
+        }
+        if (singleFile) {
+            process.stdout.write(parsed.check ? `${parsed.input} is formatted\n` : `Formatted ${parsed.input}\n`);
+        }
+        else if (parsed.check) {
+            process.stdout.write(`Checked formatting of ${inputs.length} VelarScript source file${inputs.length === 1 ? "" : "s"}\n`);
+        }
+        else {
+            process.stdout.write(`Formatted ${changed.length} of ${inputs.length} VelarScript source file${inputs.length === 1 ? "" : "s"}\n`);
+        }
+        return 0;
+    }
+    if (command === "dev") {
+        const parsed = parseDevArguments(rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar dev: ${parsed}\n`);
+            return 2;
+        }
+        let projectConfig;
+        try {
+            projectConfig = await resolveVelarProject(parsed.input);
+            if (!projectConfig.framework)
+                throw new Error("the project does not declare an application framework host");
+            await runDevServer(projectConfig, parsed.port);
+        }
+        catch (error) {
+            process.stderr.write(`velar dev: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        return 0;
+    }
+    if (command === "test") {
+        const parsed = parseTestArguments(rest);
+        if (typeof parsed === "string") {
+            process.stderr.write(`velar test: ${parsed}\n`);
+            return 2;
+        }
+        if (!parsed.browser && parsed.input?.endsWith(".browser.test.vel")) {
+            process.stderr.write("velar test: .browser.test.vel files require --browser\n");
+            return 2;
+        }
+        if (parsed.browser && parsed.input?.endsWith(".test.vel") && !parsed.input.endsWith(".browser.test.vel")) {
+            process.stderr.write("velar test: --browser accepts a project or .browser.test.vel file\n");
+            return 2;
+        }
+        let projectConfig;
+        try {
+            projectConfig = await resolveVelarProject(parsed.input);
+            if (parsed.browser && parsed.input?.endsWith(".browser.test.vel") && projectConfig.manifestPath) {
+                projectConfig = await resolveVelarProject(projectConfig.root);
+            }
+        }
+        catch (error) {
+            process.stderr.write(`velar test: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        if (parsed.browser) {
+            const { runBrowserTests } = await import("./browser-test-runner.js");
+            return runBrowserTests(projectConfig, parsed.input, parsed.browser);
+        }
+        return runTests(projectConfig, parsed.input);
+    }
+    const parsed = command === "package" ? parsePackageArguments(rest) : parseCommandArguments(rest);
+    if (typeof parsed === "string") {
+        process.stderr.write(`velar ${command}: ${parsed}\n`);
+        return 2;
+    }
+    let projectConfig;
+    try {
+        projectConfig = await resolveVelarProject(parsed.input);
+    }
+    catch (error) {
+        process.stderr.write(`velar ${command}: ${hostErrorMessage(error)}\n`);
+        return 1;
+    }
+    const checked = await checkResolvedProject(projectConfig, parsed.input);
+    const project = checked.project;
+    process.stderr.write(formatCheckOutput(checked));
+    if (checked.errors.length > 0) {
+        // D66 ruling 7B: a failing check ends with the command that bundles the
+        // failure — one line, no persuasion, and nothing about data leaving the
+        // machine, because `velar repro` never sends any. `build` and `package`
+        // reach this same exit, and the ruling names `check`: it is the command the
+        // reproduction's own README tells a reader to run.
+        if (command === "check")
+            process.stderr.write(`${reproductionHint(parsed.input)}\n`);
+        return 1;
+    }
+    if (command === "check") {
+        const count = checked.compiled.size;
+        process.stdout.write(`Checked ${count} module${count === 1 ? "" : "s"} from ${displayInput(parsed.input, projectConfig)}\n`);
+        return 0;
+    }
+    if (command === "package") {
+        if (!project.framework) {
+            process.stderr.write("velar package: this project does not enable an application target\n");
+            return 1;
+        }
+        try {
+            const packageHost = await loadApplicationPackageHost(projectConfig);
+            let buildRequests = 0;
+            const toolRequests = new Set();
+            let frameworkBuild = null;
+            const packageResult = await packageHost.packageApplication({
+                projectRoot: projectConfig.root,
+                config: projectConfig.framework.config,
+                buildFramework: async (requestedOutput) => {
+                    buildRequests += 1;
+                    if (buildRequests > 1)
+                        throw new Error("application package host requested more than one framework build");
+                    const outputDirectory = packageFrameworkOutput(projectConfig.root, requestedOutput);
+                    frameworkBuild = writeFrameworkProductionApplication(project, outputDirectory);
+                    await frameworkBuild;
+                },
+                buildTool: async (tool) => {
+                    if (!tool || typeof tool.outputFile !== "string"
+                        || ![VELAR_LANGUAGE_SERVER_TOOL_ID, VELAR_PROJECT_TASK_TOOL_ID, VELAR_BUILD_ENGINE_TOOL_ID].includes(tool.id)) {
+                        throw new Error(`application package host requested unknown official tool '${String(tool?.id ?? "")}'`);
+                    }
+                    if (toolRequests.has(tool.id))
+                        throw new Error(`application package host requested official tool '${tool.id}' more than once`);
+                    toolRequests.add(tool.id);
+                    const outputFile = packageFrameworkOutput(projectConfig.root, tool.outputFile);
+                    if (tool.id === VELAR_LANGUAGE_SERVER_TOOL_ID)
+                        await buildLanguageServerTool(outputFile);
+                    else if (tool.id === VELAR_PROJECT_TASK_TOOL_ID)
+                        await buildProjectTaskTool(outputFile);
+                    else
+                        await buildBuildEngineTool(outputFile);
+                },
+            });
+            if (buildRequests !== 1 || !frameworkBuild)
+                throw new Error("application package host did not request exactly one checked framework build");
+            await frameworkBuild;
+            const result = validateApplicationPackageResult(packageResult, projectConfig.root);
+            process.stdout.write(`Packaged ${project.framework.host.displayName} application -> ${result.artifactPath}\n`);
+            for (const detail of result.details)
+                process.stdout.write(`${detail}\n`);
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`velar package: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+    }
+    if (parsed.output && project.modules.length !== 1) {
+        process.stderr.write("velar build: --out is only valid for a single-file build; use --out-dir for module projects\n");
+        return 2;
+    }
+    if (parsed.output) {
+        const outputPath = resolve(parsed.output);
+        try {
+            await assertNodeStandardModuleOutputAvailable(dirname(outputPath), project);
+            await mkdir(dirname(outputPath), { recursive: true });
+            const result = project.modules[0].result;
+            if (needsStandaloneJavaScriptBundle(result)) {
+                const bundled = await bundleStandaloneJavaScript(outputPath, result);
+                await writeCompiled(outputPath, result, true, bundled.code, bundled.sourceMap, false);
+            }
+            else {
+                await writeCompiled(outputPath, result, true);
+            }
+            await writeNodeStandardModules(dirname(outputPath), project, true);
+        }
+        catch (error) {
+            process.stderr.write(`velar build: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        process.stdout.write(`Built ${displayInput(parsed.input, projectConfig)} -> ${outputPath}\n`);
+        return 0;
+    }
+    const outputDirectory = parsed.outputDirectory ? resolve(parsed.outputDirectory) : projectConfig.outDir;
+    if (project.framework) {
+        try {
+            await writeFrameworkProductionApplication(project, outputDirectory);
+        }
+        catch (error) {
+            process.stderr.write(`velar build: ${hostErrorMessage(error)}\n`);
+            return 1;
+        }
+        process.stdout.write(`Built production ${project.framework.host.displayName} app -> ${outputDirectory}\n`);
+        return 0;
+    }
+    const staging = await prepareBuildStaging(outputDirectory);
+    try {
+        assertUniqueEmbeddedModuleOutputs(project.modules.map((module) => ({
+            ownerPath: join(staging, module.relativePath.replace(/\.vel$/, ".js")),
+            embeddedModules: module.result.embeddedModules,
+        })));
+        for (const module of project.modules) {
+            const outputPath = join(staging, module.relativePath.replace(/\.vel$/, ".js"));
+            await mkdir(dirname(outputPath), { recursive: true });
+            await writeCompiled(outputPath, module.result, false, rewriteVelarPackageImports(project, module));
+        }
+        await writeNodeStandardModules(staging, project);
+        await replaceOutputDirectory(staging, outputDirectory);
+    }
+    catch (error) {
+        await rm(staging, { recursive: true, force: true });
+        process.stderr.write(`velar build: ${hostErrorMessage(error)}\n`);
+        return 1;
+    }
+    process.stdout.write(`Built ${project.modules.length} module${project.modules.length === 1 ? "" : "s"} -> ${outputDirectory}\n`);
+    return 0;
+}
+async function writeFrameworkProductionApplication(project, outputDirectory) {
+    if (!project.framework)
+        throw new Error("the checked project has no framework host");
+    const framework = project.framework;
+    await assertRequiredPublicAssets(project.publicRoot, project.projectRoot, framework.host.requiredPublicAssets?.(framework.config) ?? []);
+    const staging = await prepareBuildStaging(outputDirectory);
+    try {
+        await copyPublicAssets(project.publicRoot, staging);
+        const production = await buildProductionFramework(project, staging);
+        const artifacts = createFrameworkArtifacts(project, false, {}, {
+            entryPath: production.entryPath,
+            stylesheetPath: production.stylesheetPath,
+            includeStandardImports: false,
+        });
+        if (!artifacts)
+            throw new Error("The framework host did not create an application entry");
+        await writeFile(join(staging, "index.html"), artifacts.html, "utf8");
+        const deployment = await writeStaticDeployment(staging, artifacts.html, project.framework.host.staticDeployment(project.framework.config), production.framework);
+        await writeProductionManifest(staging, production, deployment);
+        await replaceOutputDirectory(staging, outputDirectory);
+    }
+    catch (error) {
+        await rm(staging, { recursive: true, force: true });
+        throw error;
+    }
+}
+function packageFrameworkOutput(root, input) {
+    if (!isAbsolute(input))
+        throw new Error("application package host requested a non-absolute framework output path");
+    const output = resolve(input);
+    const fromRoot = relative(root, output);
+    if (fromRoot === "" || fromRoot === ".." || fromRoot.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(fromRoot)) {
+        throw new Error("application package host requested a framework output path outside the project root");
+    }
+    return output;
+}
+/**
+ * Reclaims only staging directories carrying a marker that names this exact
+ * output. A process cut can happen before or after either rename, so recovery
+ * also finishes restoring the previous output when installation never began.
+ */
+async function prepareBuildStaging(outputDirectory) {
+    const normalizedOutput = resolve(outputDirectory);
+    const parent = dirname(normalizedOutput);
+    await mkdir(parent, { recursive: true });
+    await recoverInterruptedBuilds(normalizedOutput);
+    const staging = await mkdtemp(join(parent, `.velar-${basename(normalizedOutput)}-`));
+    const ownership = {
+        formatVersion: 1,
+        kind: "velar-build-staging",
+        outputDirectory: normalizedOutput,
+        stagingDirectory: resolve(staging),
+        ownerPid: process.pid,
+    };
+    await writeFile(join(staging, BUILD_STAGING_MARKER), `${JSON.stringify(ownership, null, 2)}\n`, "utf8");
+    return staging;
+}
+async function recoverInterruptedBuilds(outputDirectory) {
+    const parent = dirname(outputDirectory);
+    const prefix = `.velar-${basename(outputDirectory)}-`;
+    const installed = await buildStagingOwnership(outputDirectory, outputDirectory, null);
+    if (installed && !processIsAlive(installed.ownerPid)) {
+        await rm(`${installed.stagingDirectory}-previous`, { recursive: true, force: true });
+        await rm(join(outputDirectory, BUILD_STAGING_MARKER), { force: true });
+    }
+    for (const entry of await readdir(parent, { withFileTypes: true })) {
+        if (!entry.name.startsWith(prefix) || entry.name.endsWith("-previous") || !entry.isDirectory())
+            continue;
+        const staging = resolve(parent, entry.name);
+        const ownership = await buildStagingOwnership(staging, outputDirectory, staging);
+        if (!ownership || processIsAlive(ownership.ownerPid))
+            continue;
+        const previous = `${staging}-previous`;
+        try {
+            await lstat(outputDirectory);
+            await rm(previous, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (!isHostErrorCode(error, "ENOENT"))
+                throw error;
+            try {
+                await rename(previous, outputDirectory);
+            }
+            catch (restoreError) {
+                if (!isHostErrorCode(restoreError, "ENOENT"))
+                    throw restoreError;
+            }
+        }
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+async function buildStagingOwnership(directory, outputDirectory, expectedStaging) {
+    try {
+        const directoryMetadata = await lstat(directory);
+        if (!directoryMetadata.isDirectory() || directoryMetadata.isSymbolicLink())
+            return null;
+        const markerPath = join(directory, BUILD_STAGING_MARKER);
+        const markerMetadata = await lstat(markerPath);
+        if (!markerMetadata.isFile() || markerMetadata.isSymbolicLink())
+            return null;
+        const parsed = JSON.parse(await readFile(markerPath, "utf8"));
+        if (parsed.formatVersion !== 1
+            || parsed.kind !== "velar-build-staging"
+            || parsed.outputDirectory !== outputDirectory
+            || typeof parsed.stagingDirectory !== "string"
+            || dirname(parsed.stagingDirectory) !== dirname(outputDirectory)
+            || !basename(parsed.stagingDirectory).startsWith(`.velar-${basename(outputDirectory)}-`)
+            || (expectedStaging !== null && parsed.stagingDirectory !== expectedStaging)
+            || !Number.isSafeInteger(parsed.ownerPid)
+            || (parsed.ownerPid ?? 0) <= 0)
+            return null;
+        return parsed;
+    }
+    catch (error) {
+        if (isHostErrorCode(error, "ENOENT") || error instanceof SyntaxError)
+            return null;
+        throw error;
+    }
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return isHostErrorCode(error, "EPERM");
+    }
+}
+async function replaceOutputDirectory(staging, outputDirectory) {
+    const previous = `${staging}-previous`;
+    let movedPrevious = false;
+    let installed = false;
+    try {
+        try {
+            await rename(outputDirectory, previous);
+            movedPrevious = true;
+        }
+        catch (error) {
+            if (!isHostErrorCode(error, "ENOENT"))
+                throw error;
+        }
+        await rename(staging, outputDirectory);
+        installed = true;
+        if (movedPrevious)
+            await rm(previous, { recursive: true, force: true });
+        await rm(join(outputDirectory, BUILD_STAGING_MARKER), { force: true });
+    }
+    catch (error) {
+        if (!installed && movedPrevious) {
+            try {
+                await rename(previous, outputDirectory);
+            }
+            catch (restoreError) {
+                throw new Error(`Build output replacement failed and the previous output could not be restored: ${hostErrorMessage(restoreError)}`, { cause: error });
+            }
+        }
+        throw error;
+    }
+}
+const VELAR_GENERATED_RUNTIME_PACKAGE_VERSION = 1;
+async function writeNodeStandardModules(outputRoot, project, replaceExisting = false) {
+    const used = requiredNodeStandardModules(project);
+    const packageRoot = join(outputRoot, "node_modules", "velar");
+    if (!replaceExisting) {
+        if (used.size === 0)
+            return;
+        await writeNodeStandardModulePackage(packageRoot, used, project);
+        if (used.has("velar/websocket"))
+            await writeWebSocketDependency(dirname(packageRoot));
+        await writeAdapterDependencies(dirname(packageRoot), used);
+        return;
+    }
+    const ownership = await generatedRuntimePackageOwnership(packageRoot);
+    if (used.size === 0) {
+        if (ownership === "generated")
+            await rm(packageRoot, { recursive: true, force: true });
+        return;
+    }
+    if (ownership === "foreign")
+        throw new Error(`Refusing to replace non-generated package '${packageRoot}'`);
+    await mkdir(dirname(packageRoot), { recursive: true });
+    const staging = await mkdtemp(join(dirname(packageRoot), ".velar-runtime-"));
+    try {
+        await writeNodeStandardModulePackage(staging, used, project);
+        if (ownership === "generated")
+            await replaceOutputDirectory(staging, packageRoot);
+        else
+            await rename(staging, packageRoot);
+        if (used.has("velar/websocket"))
+            await writeWebSocketDependency(dirname(packageRoot));
+        await writeAdapterDependencies(dirname(packageRoot), used);
+    }
+    catch (error) {
+        await rm(staging, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function writeWebSocketDependency(nodeModulesRoot) {
+    const target = join(nodeModulesRoot, "ws");
+    try {
+        const manifest = JSON.parse(await readFile(join(target, "package.json"), "utf8"));
+        if (manifest.name !== "ws" || manifest.version !== "8.21.1")
+            throw new Error(`Refusing to use incompatible WebSocket runtime package '${target}'`);
+        return;
+    }
+    catch (error) {
+        if (!isHostErrorCode(error, "ENOENT"))
+            throw error;
+    }
+    const require = createRequire(import.meta.url);
+    const source = dirname(require.resolve("ws/package.json"));
+    await cp(source, target, { recursive: true, errorOnExist: true });
+}
+async function writeAdapterDependencies(nodeModulesRoot, used) {
+    const require = createRequire(import.meta.url);
+    for (const [moduleName, dependency] of STANDARD_MODULE_ADAPTER_DEPENDENCIES) {
+        if (!used.has(moduleName))
+            continue;
+        const target = join(nodeModulesRoot, dependency.packageName);
+        try {
+            const manifest = JSON.parse(await readFile(join(target, "package.json"), "utf8"));
+            if (manifest.name !== dependency.packageName || manifest.version !== dependency.version) {
+                throw new Error(`Refusing to use incompatible ${moduleName} runtime package '${target}'`);
+            }
+            continue;
+        }
+        catch (error) {
+            if (!isHostErrorCode(error, "ENOENT"))
+                throw error;
+        }
+        const source = await resolveInstalledPackageRoot(dependency.packageName, dependency.packageName, require);
+        await cp(source, target, { recursive: true, errorOnExist: true });
+    }
+}
+function requiredNodeStandardModules(project) {
+    const sources = standardModuleSources(project.compilerExtensions);
+    const roots = new Set(project.modules.flatMap((module) => module.result.dependencies
+        .map((dependency) => dependency.source)
+        .filter((source) => sources.has(source))));
+    for (const module of project.modules) {
+        for (const source of module.result.runtimeModules)
+            if (sources.has(source))
+                roots.add(source);
+    }
+    return standardModuleClosure(roots, project.extensionConfig, project.compilerExtensions);
+}
+async function assertNodeStandardModuleOutputAvailable(outputRoot, project) {
+    if (requiredNodeStandardModules(project).size === 0)
+        return;
+    const packageRoot = join(outputRoot, "node_modules", "velar");
+    if (await generatedRuntimePackageOwnership(packageRoot) === "foreign") {
+        throw new Error(`Refusing to replace non-generated package '${packageRoot}'`);
+    }
+}
+async function writeNodeStandardModulePackage(packageRoot, used, project) {
+    await mkdir(packageRoot, { recursive: true });
+    const exports = {};
+    for (const source of [...used].sort()) {
+        const name = source.slice("velar/".length);
+        const moduleSource = standardModuleSource(source, project.extensionConfig, project.compilerExtensions);
+        if (moduleSource === null)
+            throw new Error(`Unknown VelarScript standard module '${source}'`);
+        exports[`./${name}`] = `./${name}.js`;
+        await writeFile(join(packageRoot, `${name}.js`), moduleSource, "utf8");
+    }
+    await writeFile(join(packageRoot, "package.json"), `${JSON.stringify({
+        name: "velar",
+        private: true,
+        type: "module",
+        velarGeneratedRuntime: VELAR_GENERATED_RUNTIME_PACKAGE_VERSION,
+        exports,
+    }, null, 2)}\n`, "utf8");
+}
+async function generatedRuntimePackageOwnership(packageRoot) {
+    try {
+        const stats = await lstat(packageRoot);
+        if (!stats.isDirectory() || stats.isSymbolicLink())
+            return "foreign";
+    }
+    catch (error) {
+        if (isHostErrorCode(error, "ENOENT"))
+            return "absent";
+        throw error;
+    }
+    try {
+        const manifest = JSON.parse(await readFile(join(packageRoot, "package.json"), "utf8"));
+        return manifest.name === "velar"
+            && manifest.private === true
+            && manifest.type === "module"
+            && manifest.velarGeneratedRuntime === VELAR_GENERATED_RUNTIME_PACKAGE_VERSION
+            ? "generated"
+            : "foreign";
+    }
+    catch (error) {
+        if (isHostErrorCode(error, "ENOENT") || error instanceof SyntaxError)
+            return "foreign";
+        throw error;
+    }
+}
+async function writeCompiled(outputPath, result, writeCss, codeOverride = null, sourceMapOverride = null, writeEmbedded = true) {
+    const mapPath = `${outputPath}.map`;
+    const rawCode = codeOverride ?? result.code ?? "";
+    const code = rawCode.includes(`//# sourceMappingURL=${basename(mapPath)}`)
+        ? rawCode
+        : `${rawCode}//# sourceMappingURL=${basename(mapPath)}\n`;
+    if (writeEmbedded) {
+        assertUniqueEmbeddedModuleOutputs([{ ownerPath: outputPath, embeddedModules: result.embeddedModules }]);
+        for (const module of result.embeddedModules) {
+            const embeddedPath = embeddedModuleOutputPath(outputPath, module.specifier);
+            await assertEmbeddedModuleOutputWritable(embeddedPath);
+        }
+    }
+    const writes = [
+        writeFile(outputPath, code, "utf8"),
+        writeFile(mapPath, sourceMapOverride ?? result.sourceMap ?? "", "utf8"),
+        ...(writeEmbedded ? result.embeddedModules : []).flatMap((module) => {
+            const embeddedPath = embeddedModuleOutputPath(outputPath, module.specifier);
+            return [
+                writeFile(embeddedPath, embeddedModuleFileContents(embeddedPath, module), "utf8"),
+                writeFile(`${embeddedPath}.map`, module.sourceMap, "utf8"),
+            ];
+        }),
+    ];
+    if (writeCss) {
+        const cssPath = outputPath.replace(/\.js$/u, ".css");
+        writes.push(result.css ? writeFile(cssPath, result.css, "utf8") : rm(cssPath, { force: true }));
+    }
+    await Promise.all(writes);
+}
+async function assertEmbeddedModuleOutputWritable(path) {
+    try {
+        const metadata = await lstat(path);
+        if (!metadata.isFile() || metadata.isSymbolicLink()) {
+            throw new Error(`Refusing to replace non-generated embedded JavaScript output '${path}'`);
+        }
+        const existing = await readFile(path, "utf8");
+        if (!existing.includes(VELAR_EMBEDDED_MODULE_MARKER)) {
+            throw new Error(`Refusing to replace non-generated embedded JavaScript output '${path}'`);
+        }
+    }
+    catch (error) {
+        if (!isHostErrorCode(error, "ENOENT"))
+            throw error;
+        try {
+            await lstat(`${path}.map`);
+            throw new Error(`Refusing to replace source map '${path}.map' without its generated embedded JavaScript owner`);
+        }
+        catch (mapError) {
+            if (!isHostErrorCode(mapError, "ENOENT"))
+                throw mapError;
+        }
+    }
+}
+function rewriteVelarPackageImports(project, module) {
+    if (!module.result.code)
+        return null;
+    return module.result.code.replace(/(\bfrom\s+["']|\bimport\s+["'])([^"']+)(["'])/gu, (match, prefix, source, suffix) => {
+        const targetPath = project.velarImports.get(projectImportKey(module.inputPath, source));
+        if (!targetPath)
+            return match;
+        const target = project.modules.find((item) => item.inputPath === targetPath);
+        if (!target)
+            return match;
+        let targetImport = relative(dirname(module.relativePath), target.relativePath).replace(/\.vel$/u, ".js").replaceAll("\\", "/");
+        if (!targetImport.startsWith("."))
+            targetImport = `./${targetImport}`;
+        return `${prefix}${targetImport}${suffix}`;
+    });
+}
+function parseFormatArguments(arguments_) {
+    let input = null;
+    let check = false;
+    for (const argument of arguments_) {
+        if (argument === "--check") {
+            check = true;
+        }
+        else if (argument.startsWith("--")) {
+            return `unknown option '${argument}'`;
+        }
+        else if (input) {
+            return `unexpected extra input '${argument}'`;
+        }
+        else {
+            input = argument;
+        }
+    }
+    return { input, check };
+}
+function parseCommandArguments(arguments_) {
+    let input = null;
+    let output = null;
+    let outputDirectory = null;
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === "--out" || argument === "--out-dir") {
+            const value = arguments_[index + 1];
+            if (!value || value.startsWith("--")) {
+                return `${argument} requires a path`;
+            }
+            if (argument === "--out") {
+                if (extname(value) !== ".js")
+                    return "--out requires a .js file path";
+                output = value;
+            }
+            else {
+                outputDirectory = value;
+            }
+            index += 1;
+        }
+        else if (argument.startsWith("--")) {
+            return `unknown option '${argument}'`;
+        }
+        else if (input) {
+            return `unexpected extra input '${argument}'`;
+        }
+        else {
+            input = argument;
+        }
+    }
+    return { input, output, outputDirectory };
+}
+function parseReproArguments(arguments_) {
+    let input = null;
+    let outputDirectory = null;
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === "--out-dir") {
+            const value = arguments_[index + 1];
+            if (!value || value.startsWith("--"))
+                return "--out-dir requires a path";
+            if (outputDirectory)
+                return "--out-dir may be provided only once";
+            outputDirectory = value;
+            index += 1;
+        }
+        else if (argument.startsWith("--out-dir=")) {
+            if (outputDirectory)
+                return "--out-dir may be provided only once";
+            outputDirectory = argument.slice("--out-dir=".length);
+            if (!outputDirectory)
+                return "--out-dir requires a path";
+        }
+        else if (argument.startsWith("--")) {
+            return `unknown option '${argument}'`;
+        }
+        else if (input) {
+            return `unexpected extra input '${argument}'`;
+        }
+        else {
+            input = argument;
+        }
+    }
+    return { input, outputDirectory };
+}
+function parsePackageArguments(arguments_) {
+    if (arguments_.length > 1)
+        return `unexpected extra input '${arguments_[1]}'`;
+    if (arguments_[0]?.startsWith("-"))
+        return `unknown option '${arguments_[0]}'`;
+    return { input: arguments_[0] ?? null, output: null, outputDirectory: null };
+}
+function parseDevArguments(arguments_) {
+    let input = null;
+    let port = 5173;
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === "--port") {
+            const value = arguments_[index + 1];
+            const parsed = value ? Number(value) : Number.NaN;
+            if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65_535)
+                return "--port requires an integer from 1 to 65535";
+            port = parsed;
+            index += 1;
+        }
+        else if (argument.startsWith("--")) {
+            return `unknown option '${argument}'`;
+        }
+        else if (input) {
+            return `unexpected extra input '${argument}'`;
+        }
+        else {
+            input = argument;
+        }
+    }
+    return { input, port };
+}
+function parseTestArguments(arguments_) {
+    let input = null;
+    let browser = null;
+    const engines = new Set(["chromium", "firefox", "webkit", "all"]);
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === "--browser") {
+            const candidate = arguments_[index + 1];
+            if (candidate && engines.has(candidate)) {
+                browser = candidate;
+                index += 1;
+            }
+            else {
+                browser = "chromium";
+            }
+        }
+        else if (argument.startsWith("--browser=")) {
+            const candidate = argument.slice("--browser=".length);
+            if (!engines.has(candidate))
+                return "--browser must be chromium, firefox, webkit, or all";
+            browser = candidate;
+        }
+        else if (argument.startsWith("--")) {
+            return `unknown option '${argument}'`;
+        }
+        else if (input) {
+            return `unexpected extra input '${argument}'`;
+        }
+        else {
+            input = argument;
+        }
+    }
+    return { input, browser };
+}
+function parseRunArguments(arguments_) {
+    let input = null;
+    let fullStack = false;
+    const programArguments = [];
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === "--") {
+            programArguments.push(...arguments_.slice(index + 1));
+            break;
+        }
+        if (argument === "--stack") {
+            if (fullStack)
+                return "--stack may be provided only once";
+            fullStack = true;
+            continue;
+        }
+        if (argument.startsWith("--"))
+            return `unknown option '${argument}'; program arguments belong after '--'`;
+        if (input)
+            return `unexpected extra input '${argument}'`;
+        input = argument;
+    }
+    return { input, programArguments, fullStack };
+}
+function helpRequested(command, arguments_) {
+    const separator = command === "run" ? arguments_.indexOf("--") : -1;
+    const visible = separator === -1 ? arguments_ : arguments_.slice(0, separator);
+    return visible.some((argument) => argument === "--help" || argument === "-h");
+}
+function parseSingleOptionalInput(arguments_) {
+    if (arguments_.some((argument) => argument.startsWith("--"))) {
+        return { error: `unknown option '${arguments_.find((argument) => argument.startsWith("--"))}'` };
+    }
+    if (arguments_.length > 1)
+        return { error: `unexpected extra input '${arguments_[1]}'` };
+    return arguments_[0] ?? null;
+}
+function parsePreviewArguments(arguments_) {
+    let input = null;
+    let port = 4173;
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === "--port") {
+            const value = arguments_[index + 1];
+            const parsed = value ? Number(value) : Number.NaN;
+            if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65_535)
+                return "--port requires an integer from 1 to 65535";
+            port = parsed;
+            index += 1;
+        }
+        else if (argument.startsWith("--")) {
+            return `unknown option '${argument}'`;
+        }
+        else if (input) {
+            return `unexpected extra input '${argument}'`;
+        }
+        else {
+            input = argument;
+        }
+    }
+    return { input, port };
+}
+function parseDeploymentVerificationArguments(arguments_) {
+    let input = null;
+    let url = null;
+    let json = false;
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === "--json") {
+            if (json)
+                return "--json may be provided only once";
+            json = true;
+        }
+        else if (argument === "--url") {
+            const value = arguments_[index + 1];
+            if (!value || value.startsWith("--"))
+                return "--url requires an absolute deployment origin";
+            if (url)
+                return "--url may be provided only once";
+            url = value;
+            index += 1;
+        }
+        else if (argument.startsWith("--url=")) {
+            if (url)
+                return "--url may be provided only once";
+            url = argument.slice("--url=".length);
+            if (!url)
+                return "--url requires an absolute deployment origin";
+        }
+        else if (argument.startsWith("--")) {
+            return `unknown option '${argument}'`;
+        }
+        else if (input) {
+            return `unexpected extra input '${argument}'`;
+        }
+        else {
+            input = argument;
+        }
+    }
+    return { input, url, json };
+}
+function displayInput(input, config) {
+    return input ?? config.manifestPath ?? config.entryPath;
+}
+function displayPath(path) {
+    const value = relative(process.cwd(), path);
+    return (value && !value.startsWith("..") ? value : path).replaceAll("\\", "/");
+}
+function printHelp(output = process.stdout) {
+    output.write([
+        "VelarScript Compiler",
+        "",
+        "Usage:",
+        "  velar check [entry.vel | project-directory]",
+        "  velar create <project-directory> [--template <web|node|desktop|docs|library|component>]",
+        "  velar install",
+        "  velar add <package[@version]>... [--dev]",
+        "  velar remove <package>...",
+        "  velar update [package...]",
+        "  velar dev [entry.vel | project-directory] [--port <port>]",
+        "  velar build [entry.vel | project-directory] [--out-dir <directory>]",
+        "  velar run [entry.vel | project-directory] [--stack] [-- <program-arguments>...]",
+        "  velar verify [project-directory | build-directory]",
+        "  velar preview [project-directory | build-directory] [--port <port>]",
+        "  velar verify-deployment [project-directory | build-directory] --url <https-origin> [--json]",
+        "  velar test [project-directory | file.test.vel]",
+        "  velar test [project-directory] --browser [chromium|firefox|webkit|all]",
+        "  velar build <single.vel> --out <file.js>",
+        "  velar package [project-directory]",
+        "  velar format [file.vel | project-directory] [--check]",
+        "  velar fix [entry.vel | project-directory]",
+        "  velar repro [entry.vel | project-directory] [--out-dir <directory>]",
+        "  velar skill",
+        "  velar lsp",
+        "  velar --version",
+        "",
+    ].join("\n"));
+}
+const commandNames = new Set([
+    "check", "create", "install", "add", "remove", "update", "dev", "build", "package", "run", "verify", "preview",
+    "verify-deployment", "test", "format", "fix", "repro", "skill", "lsp",
+]);
+function printCommandHelp(command, output = process.stdout) {
+    const details = {
+        check: ["Usage: velar check [entry.vel | project-directory]", "Type-checks the whole resolved project without writing build output."],
+        create: ["Usage: velar create <project-directory> [--template <web|node|desktop|docs|library|component>]", "Creates a transactional Web, Node, or Desktop app, documentation site, Core source library, or Web component source package without installing dependencies."],
+        install: ["Usage: velar install", "Installs the current VelarScript project's declared dependencies through npm, then validates the project."],
+        add: ["Usage: velar add <package[@version]>... [--dev]", "Adds npm registry packages and activates packages that declare velar.extension metadata."],
+        remove: ["Usage: velar remove <package>...", "Removes npm packages and their extension-owned VelarScript project configuration."],
+        update: ["Usage: velar update [package...]", "Updates all or selected direct dependencies within package.json ranges through npm."],
+        dev: ["Usage: velar dev [entry.vel | project-directory] [--port <1-65535>]", "Runs the development server; the default port is 5173."],
+        build: ["Usage: velar build [entry.vel | project-directory] [--out-dir <directory>]", "       velar build <single.vel> --out <file.js>", "Builds isolated framework application output or JavaScript modules."],
+        package: ["Usage: velar package [project-directory]", "Packages an application through its target-owned native packaging host."],
+        run: ["Usage: velar run [entry.vel | project-directory] [--stack] [-- <program-arguments>...]", "Compiles the resolved Core project and executes its entry module once on Node.js; arguments after '--' reach the program.", "--stack prints the full Node.js trace behind an uncaught program error instead of the VelarScript frames."],
+        verify: ["Usage: velar verify [project-directory | build-directory]", "Verifies the exact production manifest, inventory, sizes, hashes, and relationships."],
+        preview: ["Usage: velar preview [project-directory | build-directory] [--port <1-65535>]", "Serves only a verified production build; the default port is 4173."],
+        "verify-deployment": ["Usage: velar verify-deployment [project-directory | build-directory] --url <https-origin> [--json]", "Compares verified local bytes, routes, MIME types, and headers with an HTTPS deployment."],
+        test: ["Usage: velar test [project-directory | file.test.vel]", "       velar test [project-directory | file.browser.test.vel] --browser[=chromium|firefox|webkit|all]", "Runs Core tests or explicit browser tests; bare --browser defaults to Chromium."],
+        format: ["Usage: velar format [file.vel | project-directory] [--check]", "Formats one file or every manifest-owned .vel source; --check never writes."],
+        fix: [
+            "Usage: velar fix [entry.vel | project-directory]",
+            "Applies every mechanical rewrite the compiler's own diagnostics name — retired spellings with one named successor, line-ending semicolons, and the rest of that family — then reports the diagnostics that are left.",
+            "Nothing that needs a decision is rewritten, and a second run changes nothing.",
+        ],
+        repro: [
+            "Usage: velar repro [entry.vel | project-directory] [--out-dir <directory>]",
+            "Writes a self-contained minimal reproduction of a failing check — the entry's modules and the test modules that failed, velar.json, the verbatim diagnostics, and the toolchain, Node, and platform versions — then prints where it went.",
+            "It writes to disk and nothing else: no upload, no network call, no environment or account data, and every absolute path rewritten to a project-relative one.",
+            "The bundle is extracted to a temporary directory and re-checked first; if the copy stops reproducing, the command says so rather than reporting a clean reproduction.",
+            "The default location is .velar/repro inside the project, replaced on each run; a directory named with --out-dir must be empty.",
+        ],
+        skill: ["Usage: velar skill", "Prints the packaged VelarScript AI skill brief verbatim to stdout for any coding agent."],
+        lsp: ["Usage: velar lsp", "Runs the stdio language server for an editor host."],
+    };
+    output.write(["VelarScript Compiler", "", ...(details[command] ?? []), ""].join("\n"));
+}
+function dependencyResultMessage(action, root, packages, activated, removed) {
+    if (action === "install")
+        return `Installed and validated VelarScript project dependencies -> ${root}\n`;
+    const names = packages.length > 0 ? packages.join(", ") : "all direct dependencies";
+    const detail = activated.length > 0
+        ? `; activated extensions: ${activated.join(", ")}`
+        : removed.length > 0
+            ? `; removed extensions: ${removed.join(", ")}`
+            : "";
+    const verb = action === "add" ? "Added" : action === "remove" ? "Removed" : "Updated";
+    return `${verb} ${names}${detail} -> ${root}\n`;
+}
+try {
+    process.exitCode = await main(process.argv.slice(2));
+}
+catch (error) {
+    process.stderr.write(`velar: ${hostErrorMessage(error)}\n`);
+    process.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map