@usevaulta/vexa 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,54 @@
+PROPRIETARY AND CONFIDENTIAL SOFTWARE LICENSE
+
+Copyright (c) 2026 Vaulta. All rights reserved.
+
+NOTICE TO USER:
+This software, source code, documentation, specifications, and associated digital
+assets ("Software") are proprietary and confidential property of Vaulta ("Licensor").
+The Software is licensed, not sold, and is protected by copyright laws, international
+treaty provisions, trade secret laws, and other applicable intellectual property laws.
+
+1. PROPRIETARY AND CLOSED-SOURCE NATURE
+This Software is strictly closed-source and proprietary. No open-source license,
+public grant, or implied rights of any kind are conveyed by access to, possession
+of, or evaluation of this repository, source code, binaries, or documentation.
+
+2. RESTRICTIONS
+Except as expressly authorized under a separate, valid, written commercial license
+agreement executed directly with Licensor, you may NOT:
+(a) Copy, distribute, publish, sublicense, rent, lease, or transfer the Software
+    or any portion thereof;
+(b) Decompile, reverse engineer, disassemble, decrypt, or otherwise attempt to
+    derive the source code, underlying ideas, algorithms, or protocols of the
+    Software, except to the extent mandatory law expressly prohibits such restriction;
+(c) Modify, adapt, translate, enhance, or create derivative works based upon the
+    Software;
+(d) Use the Software for commercial operations, automated multi-device execution,
+    or service-bureau arrangements without an active commercial license tier;
+(e) Remove, alter, or obscure any copyright, trademark, confidentiality, or other
+    proprietary notices displayed in or on the Software.
+
+3. CONFIDENTIALITY
+Any non-public source code, protocols, security mechanisms, API definitions,
+and architectural designs contained within this repository constitute trade
+secrets of Licensor. You agree to hold all such confidential information in
+strict confidence and prevent unauthorized disclosure or dissemination.
+
+4. RESERVATION OF RIGHTS
+Licensor retains all right, title, and interest in and to the Software, including
+all worldwide copyrights, patents, trade secrets, trademarks, and other intellectual
+property rights. All rights not expressly granted under an executed commercial
+agreement are reserved by Licensor.
+
+5. DISCLAIMER OF WARRANTIES & LIMITATION OF LIABILITY
+TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THE SOFTWARE IS PROVIDED
+"AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+TITLE, AND NON-INFRINGEMENT. IN NO EVENT SHALL LICENSOR BE LIABLE FOR ANY CLAIM,
+DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE,
+ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+For licensing inquiries, commercial terms, or access authorization:
+Portal: https://usevaulta.site
+Repository: https://github.com/usevaulta/vaulta

package/README.md

@@ -1,3 +1,61 @@
-# Temporary Holding Version
+# @usevaulta/vexa
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Native Rust CLI toolchain for GPUI desktop applications — `build`, `bundle`,
+`release`, `dev`, and diagnostics for Vexa projects.
+
+## Install
+
+```bash
+npm install --save-dev @usevaulta/vexa
+npx vexa --help
+```
+
+The package installs the matching platform binary from one of 11
+`@usevaulta/vexa-<platform>` packages as an optional dependency. Nothing is built at
+install time and no Rust toolchain is required.
+
+|Platform|Package|
+|---|---|
+|Windows x64|`@usevaulta/vexa-win32-x64-msvc`|
+|Windows x86|`@usevaulta/vexa-win32-ia32-msvc`|
+|Windows ARM64|`@usevaulta/vexa-win32-arm64-msvc`|
+|macOS Intel|`@usevaulta/vexa-darwin-x64`|
+|macOS Apple silicon|`@usevaulta/vexa-darwin-arm64`|
+|Linux x64 glibc|`@usevaulta/vexa-linux-x64-gnu`|
+|Linux x64 musl (Alpine)|`@usevaulta/vexa-linux-x64-musl`|
+|Linux ARM64 glibc|`@usevaulta/vexa-linux-arm64-gnu`|
+|Linux ARM64 musl|`@usevaulta/vexa-linux-arm64-musl`|
+|Linux ARMv7 / RISC-V 64|`@usevaulta/vexa-linux-arm-gnueabihf`, `@usevaulta/vexa-linux-riscv64-gnu`|
+
+## Use
+
+```bash
+npx vexa build --release          # compile and report artifacts
+npx vexa bundle my-app --target inno
+npx vexa doctor                   # verify host toolchain
+```
+
+Programmatic use:
+
+```ts
+import { run, resolveBinary, platformTarget } from "@usevaulta/vexa";
+
+const binary = resolveBinary();       // absolute path to the native CLI
+const target = platformTarget();      // { suffix: "linux-x64-gnu", ... }
+const code = await run(["build", "--release"]);
+```
+
+## Behaviour
+
+- Spawns the native binary with inherited stdio, so progress output, colours,
+  and TTY detection match a direct invocation.
+- Propagates the child's exit code; a signal-terminated child maps to
+  `128 + signal`.
+- Sets `VEXA_CLI_BIN_NAME` so `--help` shows the wrapper you invoked
+  (`npx vexa`, `pnpm vexa`, …).
+- `VEXA_BINARY_PATH` overrides binary resolution (useful for testing a locally
+  built `vexa`).
+
+## License
+
+See `LICENSE`.

package/dist/cli.cjs

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+let node_child_process = require("node:child_process");
+let node_module = require("node:module");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+// src/platform.ts
+const WINDOWS_BINARY = "vexa.exe";
+const UNIX_BINARY = "vexa";
+/** All 11 published platform packages, in publish order. */
+const PLATFORM_TARGETS = [
+	{
+		packageName: "@usevaulta/vexa-win32-x64-msvc",
+		suffix: "win32-x64-msvc",
+		rustTarget: "x86_64-pc-windows-msvc",
+		platform: "win32",
+		arch: "x64",
+		binaryName: WINDOWS_BINARY,
+		osField: "win32",
+		cpuField: "x64"
+	},
+	{
+		packageName: "@usevaulta/vexa-win32-ia32-msvc",
+		suffix: "win32-ia32-msvc",
+		rustTarget: "i686-pc-windows-msvc",
+		platform: "win32",
+		arch: "ia32",
+		binaryName: WINDOWS_BINARY,
+		osField: "win32",
+		cpuField: "ia32"
+	},
+	{
+		packageName: "@usevaulta/vexa-win32-arm64-msvc",
+		suffix: "win32-arm64-msvc",
+		rustTarget: "aarch64-pc-windows-msvc",
+		platform: "win32",
+		arch: "arm64",
+		binaryName: WINDOWS_BINARY,
+		osField: "win32",
+		cpuField: "arm64"
+	},
+	{
+		packageName: "@usevaulta/vexa-darwin-x64",
+		suffix: "darwin-x64",
+		rustTarget: "x86_64-apple-darwin",
+		platform: "darwin",
+		arch: "x64",
+		binaryName: UNIX_BINARY,
+		osField: "darwin",
+		cpuField: "x64"
+	},
+	{
+		packageName: "@usevaulta/vexa-darwin-arm64",
+		suffix: "darwin-arm64",
+		rustTarget: "aarch64-apple-darwin",
+		platform: "darwin",
+		arch: "arm64",
+		binaryName: UNIX_BINARY,
+		osField: "darwin",
+		cpuField: "arm64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-x64-gnu",
+		suffix: "linux-x64-gnu",
+		rustTarget: "x86_64-unknown-linux-gnu",
+		platform: "linux",
+		arch: "x64",
+		libc: "glibc",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "x64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-x64-musl",
+		suffix: "linux-x64-musl",
+		rustTarget: "x86_64-unknown-linux-musl",
+		platform: "linux",
+		arch: "x64",
+		libc: "musl",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "x64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-arm64-gnu",
+		suffix: "linux-arm64-gnu",
+		rustTarget: "aarch64-unknown-linux-gnu",
+		platform: "linux",
+		arch: "arm64",
+		libc: "glibc",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "arm64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-arm64-musl",
+		suffix: "linux-arm64-musl",
+		rustTarget: "aarch64-unknown-linux-musl",
+		platform: "linux",
+		arch: "arm64",
+		libc: "musl",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "arm64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-arm-gnueabihf",
+		suffix: "linux-arm-gnueabihf",
+		rustTarget: "armv7-unknown-linux-gnueabihf",
+		platform: "linux",
+		arch: "arm",
+		libc: "glibc",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "arm"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-riscv64-gnu",
+		suffix: "linux-riscv64-gnu",
+		rustTarget: "riscv64gc-unknown-linux-gnu",
+		platform: "linux",
+		arch: "riscv64",
+		libc: "glibc",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "riscv64"
+	}
+];
+/** Looks up the package for an explicit tuple. */
+function findPlatformTarget(platform, arch, libc) {
+	return PLATFORM_TARGETS.find((target) => target.platform === platform && target.arch === arch && (target.libc === void 0 ? true : target.libc === libc));
+}
+/** Resolves the platform target for the current (or injected) process. */
+function resolvePlatformTarget(platform, arch, muslOverride) {
+	if (platform === "linux") {
+		const libc = muslOverride ? "musl" : "glibc";
+		const target = findPlatformTarget(platform, arch, libc);
+		if (target === void 0) throw new Error(`@usevaulta/vexa does not ship a binary for linux/${arch} (${libc}).\nSupported: ${PLATFORM_TARGETS.filter((t) => t.platform === "linux").map((t) => t.suffix).join(", ")}`);
+		return target;
+	}
+	const target = findPlatformTarget(platform, arch);
+	if (target === void 0) throw new Error(`@usevaulta/vexa does not ship a binary for ${platform}/${arch}.\nSupported: ${PLATFORM_TARGETS.map((t) => t.suffix).join(", ")}`);
+	return target;
+}
+// src/launcher.ts
+/**
+* Native-binary resolution for the `@usevaulta/vexa` launcher.
+*
+* Resolution order:
+*  1. `VEXA_BINARY_PATH` — explicit override, used by tests and CI.
+*  2. A locally staged `platforms/<suffix>/bin/<binary>` (monorepo checkouts).
+*  3. The installed `@usevaulta/vexa-<suffix>` optional dependency.
+*/
+/** Raised when no native binary can be located for this platform. */
+var BinaryResolutionError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "BinaryResolutionError";
+	}
+};
+/** Narrows an unknown value to a plain object record. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Reads `stderr` off a failed `execFileSync` without trusting its shape. */
+function stderrOf(error) {
+	if (!isRecord(error) || !("stderr" in error)) return;
+	const stderr = error["stderr"];
+	if (typeof stderr === "string") return stderr;
+	if (Buffer.isBuffer(stderr)) return stderr.toString();
+}
+/**
+* Detects whether the current Linux host uses musl instead of glibc.
+*
+* Three independent signals, cheapest first: musl loader files, the Node.js
+* process report (a glibc version is absent on musl builds), then `ldd --version`.
+*/
+function detectMusl() {
+	if ([
+		"/lib/ld-musl-x86_64.so.1",
+		"/lib/ld-musl-aarch64.so.1",
+		"/lib/libc.musl-x86_64.so.1"
+	].some((path) => (0, node_fs.existsSync)(path))) return true;
+	try {
+		const report = process.report?.getReport();
+		if (isRecord(report) && isRecord(report["header"])) {
+			if (!("glibcVersionRuntime" in report["header"])) return true;
+		}
+	} catch {}
+	try {
+		const banner = (0, node_child_process.execFileSync)("ldd", ["--version"], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		return /musl/i.test(banner);
+	} catch (error) {
+		const stderr = stderrOf(error);
+		return stderr !== void 0 && /musl/i.test(stderr);
+	}
+}
+/** Whether the resolved host needs the musl build. */
+function hostLibc(options = {}) {
+	const platform = options.platform ?? process.platform;
+	if (options.musl !== void 0) return options.musl ? "musl" : "glibc";
+	return platform === "linux" && detectMusl() ? "musl" : "glibc";
+}
+/** Resolves the platform target for this host. */
+function hostTarget(options = {}) {
+	const platform = options.platform ?? process.platform;
+	const arch = options.arch ?? process.arch;
+	if (platform === "linux") return resolvePlatformTarget(platform, arch, hostLibc(options) === "musl");
+	return resolvePlatformTarget(platform, arch);
+}
+function stagedBinaryPath(target, options) {
+	const launcherDir = options.launcherDir ?? __dirname;
+	const root = (0, node_path.dirname)(launcherDir);
+	return [(0, node_path.join)(root, "platforms", target.suffix, "bin", target.binaryName), (0, node_path.join)(launcherDir, "platforms", target.suffix, "bin", target.binaryName)].find((candidate) => (0, node_fs.existsSync)(candidate));
+}
+function installedBinaryPath(target) {
+	const require$1 = (0, node_module.createRequire)(__filename);
+	let packageJson;
+	try {
+		packageJson = require$1.resolve(`${target.packageName}/package.json`);
+	} catch (error) {
+		const installed = PLATFORM_TARGETS.filter((candidate) => isInstalled(candidate.packageName)).map((candidate) => candidate.suffix);
+		const hint = installed.length > 0 ? `Installed platform packages: ${installed.join(", ")} (expected ${target.suffix}).` : "No platform package is installed; the optional dependency may have been skipped.";
+		throw new BinaryResolutionError(`Could not find the \`${target.packageName}\` package.\n${hint}\nReinstall with optional dependencies enabled, or set VEXA_BINARY_PATH.`, { cause: error });
+	}
+	const binary = (0, node_path.join)((0, node_path.dirname)(packageJson), "bin", target.binaryName);
+	return (0, node_fs.existsSync)(binary) ? binary : void 0;
+}
+function isInstalled(packageName) {
+	try {
+		(0, node_module.createRequire)(__filename).resolve(`${packageName}/package.json`);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Resolves the native `vexa` binary for this host. */
+function resolveBinaryPath(options = {}) {
+	const env = options.env ?? process.env;
+	const target = hostTarget(options);
+	const override = env["VEXA_BINARY_PATH"];
+	if (override !== void 0 && override.trim() !== "") return {
+		path: override,
+		target
+	};
+	const staged = stagedBinaryPath(target, options);
+	if (staged !== void 0) return {
+		path: staged,
+		target
+	};
+	const installed = installedBinaryPath(target);
+	if (installed === void 0) throw new BinaryResolutionError(`\`${target.packageName}\` is installed but does not contain bin/${target.binaryName}.`);
+	return {
+		path: installed,
+		target
+	};
+}
+// src/cli.ts
+/**
+* CLI entry point used by the `vexa` bin shim.
+*
+* Spawns the native binary with inherited stdio so colours, TTY detection, and
+* progress output behave exactly as when running `vexa` directly, then mirrors
+* its exit code (and terminating signal) to the caller.
+*/
+/**
+* Derives the program name the user invoked, so `--help` prints the wrapper
+* (`npx @usevaulta/vexa`) rather than the internal binary path.
+*/
+function detectBinName(argv, env) {
+	const fromEnv = env["VEXA_CLI_BIN_NAME"];
+	if (fromEnv !== void 0 && fromEnv.trim() !== "") return fromEnv;
+	const invoked = argv[1];
+	if (invoked === void 0) return;
+	if (invoked.endsWith("vexa.js") || invoked.endsWith("cli.cjs")) {
+		const npmExecPath = env["npm_execpath"];
+		if (npmExecPath !== void 0 && npmExecPath.includes("pnpm")) return "pnpm vexa";
+		if (npmExecPath !== void 0 && npmExecPath.includes("yarn")) return "yarn vexa";
+		if (env["npm_config_user_agent"]?.startsWith("npm/") === true) return "npx vexa";
+		return;
+	}
+}
+/** Spawns the native binary, returning its status without exiting. */
+function launch(args, options = {}) {
+	const env = {
+		...process.env,
+		...options.env
+	};
+	const resolved = resolveBinaryPath({
+		...options,
+		env
+	});
+	const binName = detectBinName([process.argv[0] ?? "", process.argv[1] ?? ""], env);
+	const childEnv = { ...env };
+	if (binName !== void 0) childEnv["VEXA_CLI_BIN_NAME"] = binName;
+	const result = (0, node_child_process.spawnSync)(resolved.path, [...args], {
+		stdio: "inherit",
+		shell: false,
+		env: childEnv,
+		windowsHide: false
+	});
+	if (result.error !== void 0) throw new BinaryResolutionError(`Failed to execute ${resolved.path}: ${result.error.message}`, { cause: result.error });
+	return {
+		status: result.status,
+		signal: result.signal,
+		binary: resolved.path
+	};
+}
+/** Runs the CLI and returns the exit code to hand to `process.exit`. */
+function runCli(args, options = {}) {
+	const { status, signal } = launch(args, options);
+	if (status !== null) return status;
+	if (signal !== null) return 128 + (SIGNAL_NUMBERS[signal] ?? 1);
+	return 0;
+}
+const SIGNAL_NUMBERS = {
+	SIGHUP: 1,
+	SIGINT: 2,
+	SIGQUIT: 3,
+	SIGILL: 4,
+	SIGTRAP: 5,
+	SIGABRT: 6,
+	SIGBUS: 7,
+	SIGFPE: 8,
+	SIGKILL: 9,
+	SIGUSR1: 10,
+	SIGSEGV: 11,
+	SIGUSR2: 12,
+	SIGPIPE: 13,
+	SIGALRM: 14,
+	SIGTERM: 15
+};
+// src/entry.ts
+/**
+* `vexa` bin shim: forwards argv to the native binary and mirrors its exit code.
+*
+* Compiled from `src/entry.ts` to `dist/cli.cjs`; kept in TypeScript so the
+* launcher logic stays type-checked under `tsc --noEmit`.
+*/
+function main() {
+	try {
+		process.exitCode = runCli(process.argv.slice(2));
+	} catch (error) {
+		if (error instanceof BinaryResolutionError) {
+			process.stderr.write(`error: ${error.message}\n`);
+			process.exitCode = 1;
+			return;
+		}
+		throw error;
+	}
+}
+main();

package/dist/index.cjs

@@ -0,0 +1,388 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_child_process = require("node:child_process");
+let node_module = require("node:module");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+// src/platform.ts
+const WINDOWS_BINARY = "vexa.exe";
+const UNIX_BINARY = "vexa";
+/** All 11 published platform packages, in publish order. */
+const PLATFORM_TARGETS = [
+	{
+		packageName: "@usevaulta/vexa-win32-x64-msvc",
+		suffix: "win32-x64-msvc",
+		rustTarget: "x86_64-pc-windows-msvc",
+		platform: "win32",
+		arch: "x64",
+		binaryName: WINDOWS_BINARY,
+		osField: "win32",
+		cpuField: "x64"
+	},
+	{
+		packageName: "@usevaulta/vexa-win32-ia32-msvc",
+		suffix: "win32-ia32-msvc",
+		rustTarget: "i686-pc-windows-msvc",
+		platform: "win32",
+		arch: "ia32",
+		binaryName: WINDOWS_BINARY,
+		osField: "win32",
+		cpuField: "ia32"
+	},
+	{
+		packageName: "@usevaulta/vexa-win32-arm64-msvc",
+		suffix: "win32-arm64-msvc",
+		rustTarget: "aarch64-pc-windows-msvc",
+		platform: "win32",
+		arch: "arm64",
+		binaryName: WINDOWS_BINARY,
+		osField: "win32",
+		cpuField: "arm64"
+	},
+	{
+		packageName: "@usevaulta/vexa-darwin-x64",
+		suffix: "darwin-x64",
+		rustTarget: "x86_64-apple-darwin",
+		platform: "darwin",
+		arch: "x64",
+		binaryName: UNIX_BINARY,
+		osField: "darwin",
+		cpuField: "x64"
+	},
+	{
+		packageName: "@usevaulta/vexa-darwin-arm64",
+		suffix: "darwin-arm64",
+		rustTarget: "aarch64-apple-darwin",
+		platform: "darwin",
+		arch: "arm64",
+		binaryName: UNIX_BINARY,
+		osField: "darwin",
+		cpuField: "arm64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-x64-gnu",
+		suffix: "linux-x64-gnu",
+		rustTarget: "x86_64-unknown-linux-gnu",
+		platform: "linux",
+		arch: "x64",
+		libc: "glibc",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "x64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-x64-musl",
+		suffix: "linux-x64-musl",
+		rustTarget: "x86_64-unknown-linux-musl",
+		platform: "linux",
+		arch: "x64",
+		libc: "musl",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "x64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-arm64-gnu",
+		suffix: "linux-arm64-gnu",
+		rustTarget: "aarch64-unknown-linux-gnu",
+		platform: "linux",
+		arch: "arm64",
+		libc: "glibc",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "arm64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-arm64-musl",
+		suffix: "linux-arm64-musl",
+		rustTarget: "aarch64-unknown-linux-musl",
+		platform: "linux",
+		arch: "arm64",
+		libc: "musl",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "arm64"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-arm-gnueabihf",
+		suffix: "linux-arm-gnueabihf",
+		rustTarget: "armv7-unknown-linux-gnueabihf",
+		platform: "linux",
+		arch: "arm",
+		libc: "glibc",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "arm"
+	},
+	{
+		packageName: "@usevaulta/vexa-linux-riscv64-gnu",
+		suffix: "linux-riscv64-gnu",
+		rustTarget: "riscv64gc-unknown-linux-gnu",
+		platform: "linux",
+		arch: "riscv64",
+		libc: "glibc",
+		binaryName: UNIX_BINARY,
+		osField: "linux",
+		cpuField: "riscv64"
+	}
+];
+/** Looks up the package for an explicit tuple. */
+function findPlatformTarget(platform, arch, libc) {
+	return PLATFORM_TARGETS.find((target) => target.platform === platform && target.arch === arch && (target.libc === void 0 ? true : target.libc === libc));
+}
+/** True when `ldd` reports musl, detected from its version banner. */
+function lddReportsMusl(banner) {
+	return /musl/i.test(banner);
+}
+/** True when a musl loader is present in the usual Alpine/musl locations. */
+function hasMuslLoader(paths) {
+	return paths.some((path) => /ld-musl-|libc\.musl/.test(path));
+}
+/** Resolves the platform target for the current (or injected) process. */
+function resolvePlatformTarget(platform, arch, muslOverride) {
+	if (platform === "linux") {
+		const libc = muslOverride ? "musl" : "glibc";
+		const target = findPlatformTarget(platform, arch, libc);
+		if (target === void 0) throw new Error(`@usevaulta/vexa does not ship a binary for linux/${arch} (${libc}).\nSupported: ${PLATFORM_TARGETS.filter((t) => t.platform === "linux").map((t) => t.suffix).join(", ")}`);
+		return target;
+	}
+	const target = findPlatformTarget(platform, arch);
+	if (target === void 0) throw new Error(`@usevaulta/vexa does not ship a binary for ${platform}/${arch}.\nSupported: ${PLATFORM_TARGETS.map((t) => t.suffix).join(", ")}`);
+	return target;
+}
+// src/launcher.ts
+/**
+* Native-binary resolution for the `@usevaulta/vexa` launcher.
+*
+* Resolution order:
+*  1. `VEXA_BINARY_PATH` — explicit override, used by tests and CI.
+*  2. A locally staged `platforms/<suffix>/bin/<binary>` (monorepo checkouts).
+*  3. The installed `@usevaulta/vexa-<suffix>` optional dependency.
+*/
+/** Raised when no native binary can be located for this platform. */
+var BinaryResolutionError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "BinaryResolutionError";
+	}
+};
+/** Narrows an unknown value to a plain object record. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Reads `stderr` off a failed `execFileSync` without trusting its shape. */
+function stderrOf(error) {
+	if (!isRecord(error) || !("stderr" in error)) return;
+	const stderr = error["stderr"];
+	if (typeof stderr === "string") return stderr;
+	if (Buffer.isBuffer(stderr)) return stderr.toString();
+}
+/**
+* Detects whether the current Linux host uses musl instead of glibc.
+*
+* Three independent signals, cheapest first: musl loader files, the Node.js
+* process report (a glibc version is absent on musl builds), then `ldd --version`.
+*/
+function detectMusl() {
+	if ([
+		"/lib/ld-musl-x86_64.so.1",
+		"/lib/ld-musl-aarch64.so.1",
+		"/lib/libc.musl-x86_64.so.1"
+	].some((path) => (0, node_fs.existsSync)(path))) return true;
+	try {
+		const report = process.report?.getReport();
+		if (isRecord(report) && isRecord(report["header"])) {
+			if (!("glibcVersionRuntime" in report["header"])) return true;
+		}
+	} catch {}
+	try {
+		const banner = (0, node_child_process.execFileSync)("ldd", ["--version"], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		return /musl/i.test(banner);
+	} catch (error) {
+		const stderr = stderrOf(error);
+		return stderr !== void 0 && /musl/i.test(stderr);
+	}
+}
+/** Whether the resolved host needs the musl build. */
+function hostLibc(options = {}) {
+	const platform = options.platform ?? process.platform;
+	if (options.musl !== void 0) return options.musl ? "musl" : "glibc";
+	return platform === "linux" && detectMusl() ? "musl" : "glibc";
+}
+/** Resolves the platform target for this host. */
+function hostTarget(options = {}) {
+	const platform = options.platform ?? process.platform;
+	const arch = options.arch ?? process.arch;
+	if (platform === "linux") return resolvePlatformTarget(platform, arch, hostLibc(options) === "musl");
+	return resolvePlatformTarget(platform, arch);
+}
+function stagedBinaryPath(target, options) {
+	const launcherDir = options.launcherDir ?? __dirname;
+	const root = (0, node_path.dirname)(launcherDir);
+	return [(0, node_path.join)(root, "platforms", target.suffix, "bin", target.binaryName), (0, node_path.join)(launcherDir, "platforms", target.suffix, "bin", target.binaryName)].find((candidate) => (0, node_fs.existsSync)(candidate));
+}
+function installedBinaryPath(target) {
+	const require$1 = (0, node_module.createRequire)(__filename);
+	let packageJson;
+	try {
+		packageJson = require$1.resolve(`${target.packageName}/package.json`);
+	} catch (error) {
+		const installed = PLATFORM_TARGETS.filter((candidate) => isInstalled(candidate.packageName)).map((candidate) => candidate.suffix);
+		const hint = installed.length > 0 ? `Installed platform packages: ${installed.join(", ")} (expected ${target.suffix}).` : "No platform package is installed; the optional dependency may have been skipped.";
+		throw new BinaryResolutionError(`Could not find the \`${target.packageName}\` package.\n${hint}\nReinstall with optional dependencies enabled, or set VEXA_BINARY_PATH.`, { cause: error });
+	}
+	const binary = (0, node_path.join)((0, node_path.dirname)(packageJson), "bin", target.binaryName);
+	return (0, node_fs.existsSync)(binary) ? binary : void 0;
+}
+function isInstalled(packageName) {
+	try {
+		(0, node_module.createRequire)(__filename).resolve(`${packageName}/package.json`);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Resolves the native `vexa` binary for this host. */
+function resolveBinaryPath(options = {}) {
+	const env = options.env ?? process.env;
+	const target = hostTarget(options);
+	const override = env["VEXA_BINARY_PATH"];
+	if (override !== void 0 && override.trim() !== "") return {
+		path: override,
+		target
+	};
+	const staged = stagedBinaryPath(target, options);
+	if (staged !== void 0) return {
+		path: staged,
+		target
+	};
+	const installed = installedBinaryPath(target);
+	if (installed === void 0) throw new BinaryResolutionError(`\`${target.packageName}\` is installed but does not contain bin/${target.binaryName}.`);
+	return {
+		path: installed,
+		target
+	};
+}
+/** Lists the platform directories present in a staging tree (diagnostics only). */
+function stagedSuffixes(root) {
+	try {
+		return (0, node_fs.readdirSync)(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	} catch {
+		return [];
+	}
+}
+// src/cli.ts
+/**
+* CLI entry point used by the `vexa` bin shim.
+*
+* Spawns the native binary with inherited stdio so colours, TTY detection, and
+* progress output behave exactly as when running `vexa` directly, then mirrors
+* its exit code (and terminating signal) to the caller.
+*/
+/**
+* Derives the program name the user invoked, so `--help` prints the wrapper
+* (`npx @usevaulta/vexa`) rather than the internal binary path.
+*/
+function detectBinName(argv, env) {
+	const fromEnv = env["VEXA_CLI_BIN_NAME"];
+	if (fromEnv !== void 0 && fromEnv.trim() !== "") return fromEnv;
+	const invoked = argv[1];
+	if (invoked === void 0) return;
+	if (invoked.endsWith("vexa.js") || invoked.endsWith("cli.cjs")) {
+		const npmExecPath = env["npm_execpath"];
+		if (npmExecPath !== void 0 && npmExecPath.includes("pnpm")) return "pnpm vexa";
+		if (npmExecPath !== void 0 && npmExecPath.includes("yarn")) return "yarn vexa";
+		if (env["npm_config_user_agent"]?.startsWith("npm/") === true) return "npx vexa";
+		return;
+	}
+}
+/** Spawns the native binary, returning its status without exiting. */
+function launch(args, options = {}) {
+	const env = {
+		...process.env,
+		...options.env
+	};
+	const resolved = resolveBinaryPath({
+		...options,
+		env
+	});
+	const binName = detectBinName([process.argv[0] ?? "", process.argv[1] ?? ""], env);
+	const childEnv = { ...env };
+	if (binName !== void 0) childEnv["VEXA_CLI_BIN_NAME"] = binName;
+	const result = (0, node_child_process.spawnSync)(resolved.path, [...args], {
+		stdio: "inherit",
+		shell: false,
+		env: childEnv,
+		windowsHide: false
+	});
+	if (result.error !== void 0) throw new BinaryResolutionError(`Failed to execute ${resolved.path}: ${result.error.message}`, { cause: result.error });
+	return {
+		status: result.status,
+		signal: result.signal,
+		binary: resolved.path
+	};
+}
+/** Runs the CLI and returns the exit code to hand to `process.exit`. */
+function runCli(args, options = {}) {
+	const { status, signal } = launch(args, options);
+	if (status !== null) return status;
+	if (signal !== null) return 128 + (SIGNAL_NUMBERS[signal] ?? 1);
+	return 0;
+}
+const SIGNAL_NUMBERS = {
+	SIGHUP: 1,
+	SIGINT: 2,
+	SIGQUIT: 3,
+	SIGILL: 4,
+	SIGTRAP: 5,
+	SIGABRT: 6,
+	SIGBUS: 7,
+	SIGFPE: 8,
+	SIGKILL: 9,
+	SIGUSR1: 10,
+	SIGSEGV: 11,
+	SIGUSR2: 12,
+	SIGPIPE: 13,
+	SIGALRM: 14,
+	SIGTERM: 15
+};
+// src/index.ts
+/** Absolute path of the native `vexa` binary for this host. */
+function resolveBinary(options) {
+	return resolveBinaryPath(options).path;
+}
+/** Platform package selected for this host. */
+function platformTarget(options) {
+	return resolveBinaryPath(options).target;
+}
+/**
+* Runs the native CLI, streaming output to this process's stdio.
+*
+* Resolves with the child's exit code; never rejects on a non-zero exit.
+*/
+async function run(args, options) {
+	return runCli(args, options);
+}
+exports.BinaryResolutionError = BinaryResolutionError;
+exports.PLATFORM_TARGETS = PLATFORM_TARGETS;
+exports.detectBinName = detectBinName;
+exports.detectMusl = detectMusl;
+exports.findPlatformTarget = findPlatformTarget;
+exports.hasMuslLoader = hasMuslLoader;
+exports.hostLibc = hostLibc;
+exports.hostTarget = hostTarget;
+exports.launch = launch;
+exports.lddReportsMusl = lddReportsMusl;
+exports.platformTarget = platformTarget;
+exports.resolveBinary = resolveBinary;
+exports.resolveBinaryPath = resolveBinaryPath;
+exports.resolvePlatformTarget = resolvePlatformTarget;
+exports.run = run;
+exports.runCli = runCli;
+exports.stagedSuffixes = stagedSuffixes;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./types/index.js";

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@usevaulta/vexa",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "private": false,
+  "description": "Native Rust CLI toolchain for GPUI desktop applications",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "commonjs",
+  "bin": {
+    "vexa": "./dist/cli.cjs"
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/cli.cjs",
+    "dist/index.cjs",
+    "dist/index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">= 18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown && node ./postbuild.mjs",
+    "sync-version": "node ./dist/scripts/sync-version.cjs",
+    "stage-artifacts": "node ./dist/scripts/stage-artifacts.cjs",
+    "verify": "node ./dist/scripts/verify-dist.cjs",
+    "prepublishOnly": "npm run typecheck && npm run build && node ./dist/scripts/sync-version.cjs --check"
+  },
+  "optionalDependencies": {
+    "@usevaulta/vexa-darwin-arm64": "0.1.0",
+    "@usevaulta/vexa-darwin-x64": "0.1.0",
+    "@usevaulta/vexa-linux-arm-gnueabihf": "0.1.0",
+    "@usevaulta/vexa-linux-arm64-gnu": "0.1.0",
+    "@usevaulta/vexa-linux-arm64-musl": "0.1.0",
+    "@usevaulta/vexa-linux-riscv64-gnu": "0.1.0",
+    "@usevaulta/vexa-linux-x64-gnu": "0.1.0",
+    "@usevaulta/vexa-linux-x64-musl": "0.1.0",
+    "@usevaulta/vexa-win32-arm64-msvc": "0.1.0",
+    "@usevaulta/vexa-win32-ia32-msvc": "0.1.0",
+    "@usevaulta/vexa-win32-x64-msvc": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.4",
+    "tsdown": "0.23.7",
+    "typescript": "5.9.3"
+  }
+}