@soundor/vst3-host 0.0.0-stage → 0.1.0

package/dist/prepare-ayjTVhfk.mjs

@@ -0,0 +1,1149 @@
+import { createRequire } from "node:module";
+import { spawn, spawnSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { endianness, homedir } from "node:os";
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { gunzipSync } from "node:zlib";
+// src/errors.ts
+var Vst3HostError = class extends Error {
+	name = "Vst3HostError";
+	code;
+	details;
+	constructor(code, message, details, options) {
+		super(message, options);
+		this.code = code;
+		this.details = details;
+	}
+};
+// protocol.json
+var version = 1;
+var magic = "SVH1";
+var maxHeaderBytes = 1048576;
+var defaultMaxPayloadBytes = 268435456;
+// src/protocol.ts
+const PROTOCOL_VERSION = version;
+const MAX_HEADER_BYTES = maxHeaderBytes;
+const DEFAULT_MAX_PAYLOAD_BYTES = defaultMaxPayloadBytes;
+const MAGIC = Buffer.from(magic, "latin1");
+const PREFIX_BYTES = 12;
+function encodeFrame(header, payload = /* @__PURE__ */ new Uint8Array(0)) {
+	const json = Buffer.from(JSON.stringify(header), "utf8");
+	const prefix = Buffer.alloc(PREFIX_BYTES);
+	MAGIC.copy(prefix, 0);
+	prefix.writeUInt32LE(json.length, 4);
+	prefix.writeUInt32LE(payload.byteLength, 8);
+	return payload.byteLength > 0 ? [
+		prefix,
+		json,
+		Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength)
+	] : [prefix, json];
+}
+/** Turns a byte stream into frames; throws on a corrupt or oversized one,
+after which the stream cannot be read any further. */
+var FrameDecoder = class {
+	#chunks = [];
+	#buffered = 0;
+	#pending;
+	maxPayloadBytes;
+	constructor(maxPayloadBytes = DEFAULT_MAX_PAYLOAD_BYTES) {
+		this.maxPayloadBytes = maxPayloadBytes;
+	}
+	push(chunk) {
+		this.#chunks.push(chunk);
+		this.#buffered += chunk.length;
+		const frames = [];
+		while (true) {
+			if (this.#pending === void 0) {
+				if (this.#buffered < PREFIX_BYTES) break;
+				const prefix = this.#take(PREFIX_BYTES);
+				if (!prefix.subarray(0, 4).equals(MAGIC)) throw new Error("the host wrote something that is not a protocol frame (bad magic)");
+				const header = prefix.readUInt32LE(4);
+				const payload = prefix.readUInt32LE(8);
+				if (header > MAX_HEADER_BYTES) throw new Error(`a frame header of ${header} bytes exceeds the limit of ${MAX_HEADER_BYTES}`);
+				if (payload > this.maxPayloadBytes) throw new Error(`a frame payload of ${payload} bytes exceeds the limit of ${this.maxPayloadBytes}`);
+				this.#pending = {
+					header,
+					payload
+				};
+			}
+			const { header, payload } = this.#pending;
+			if (this.#buffered < header + payload) break;
+			this.#pending = void 0;
+			const text = this.#take(header).toString("utf8");
+			let parsed;
+			try {
+				parsed = JSON.parse(text);
+			} catch {
+				throw new Error("the host wrote a frame whose header is not JSON");
+			}
+			frames.push({
+				header: parsed,
+				payload: this.#take(payload)
+			});
+		}
+		return frames;
+	}
+	#take(size) {
+		if (size === 0) return Buffer.alloc(0);
+		const first = this.#chunks[0];
+		let result;
+		if (first.length >= size) {
+			result = first.subarray(0, size);
+			if (first.length === size) this.#chunks.shift();
+			else this.#chunks[0] = first.subarray(size);
+		} else {
+			result = Buffer.alloc(size);
+			let offset = 0;
+			while (offset < size) {
+				const chunk = this.#chunks[0];
+				const part = Math.min(chunk.length, size - offset);
+				chunk.copy(result, offset, 0, part);
+				offset += part;
+				if (part === chunk.length) this.#chunks.shift();
+				else this.#chunks[0] = chunk.subarray(part);
+			}
+		}
+		this.#buffered -= size;
+		return result;
+	}
+};
+// src/targets.ts
+/** The platform packages a release generates (targets.json). */
+const targets = [
+	{
+		"target": "linux-x64-gnu",
+		"package": "@soundor/vst3-host-linux-x64-gnu",
+		"os": ["linux"],
+		"cpu": ["x64"],
+		"libc": ["glibc"],
+		"runner": "ubuntu-24.04",
+		"architectures": ["x64"],
+		"executable": "bin/soundor-vst3-host"
+	},
+	{
+		"target": "darwin-universal",
+		"package": "@soundor/vst3-host-darwin-universal",
+		"os": ["darwin"],
+		"cpu": ["arm64", "x64"],
+		"runner": "macos-15",
+		"architectures": ["arm64", "x64"],
+		"executable": "bin/soundor-vst3-host"
+	},
+	{
+		"target": "win32-x64",
+		"package": "@soundor/vst3-host-win32-x64",
+		"os": ["win32"],
+		"cpu": ["x64"],
+		"runner": "windows-2025",
+		"architectures": ["x64"],
+		"executable": "bin/soundor-vst3-host.exe"
+	}
+];
+/** This package's root: the directory of its package.json. */
+const packageRoot = fileURLToPath(new URL("..", import.meta.url));
+function ownManifest(root = packageRoot) {
+	return JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+}
+/** A checkout of the repository, not an installed package: the published
+manifest always pins its platform packages. */
+function isSourceWorkspace(root = packageRoot) {
+	return ownManifest(root).optionalDependencies === void 0 && existsSync(join(root, "native/src"));
+}
+function currentPlatform() {
+	if (process.platform !== "linux") return {
+		platform: process.platform,
+		arch: process.arch
+	};
+	const header = process.report.getReport().header;
+	return header?.glibcVersionRuntime ? {
+		platform: "linux",
+		arch: process.arch,
+		libc: "glibc",
+		glibc: header.glibcVersionRuntime
+	} : {
+		platform: "linux",
+		arch: process.arch,
+		libc: "musl"
+	};
+}
+/** The target whose executable runs here, if any. */
+function targetFor(platform = currentPlatform()) {
+	return targets.find((target) => target.os.includes(platform.platform) && target.cpu.includes(platform.arch) && (target.libc === void 0 || target.libc.includes(platform.libc ?? "")));
+}
+function describePlatform(platform = currentPlatform()) {
+	return `${platform.platform}-${platform.arch}${platform.libc ? `-${platform.libc}` : ""}`;
+}
+/** Version comparison of dotted numbers ("2.35" < "2.39"). */
+function versionAtLeast(actual, required) {
+	const a = actual.split(".").map(Number);
+	const b = required.split(".").map(Number);
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		const x = a[i] ?? 0;
+		const y = b[i] ?? 0;
+		if (x !== y) return x > y;
+	}
+	return true;
+}
+// src/inputs.ts
+/** Files, relative to the package root. Directories are walked. */
+const INPUTS = [
+	"CMakeLists.txt",
+	"CMakePresets.json",
+	"protocol.json",
+	"cmake",
+	"native/src",
+	"native/tools"
+];
+const TEXT = /\.(?:cmake|cpp|c|h|hpp|mm|m|in|json|txt)$/;
+const IGNORED = /(?:^\.|~$|\.(?:swp|tmp|orig|rej)$)/;
+function nativeInputs(root = packageRoot) {
+	const files = [];
+	const visit = (relative) => {
+		const path = join(root, relative);
+		let entries;
+		try {
+			entries = readdirSync(path, { withFileTypes: true });
+		} catch (error) {
+			if (error.code === "ENOTDIR") {
+				files.push(relative);
+				return;
+			}
+			throw error;
+		}
+		for (const entry of entries) {
+			if (IGNORED.test(entry.name)) continue;
+			const child = join(relative, entry.name);
+			if (entry.isDirectory()) visit(child);
+			else if (entry.isFile()) files.push(child);
+			else if (entry.isSymbolicLink()) throw new Error(`A native input is a symbolic link: ${child}`);
+		}
+	};
+	for (const input of INPUTS) visit(input);
+	const normalized = files.map((file) => file.split(sep).join("/")).sort();
+	const { version } = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+	const hash = createHash("sha256").update(`soundor-vst3-host-inputs-v1\0${version}\0`);
+	for (const file of normalized) {
+		const bytes = readFileSync(join(root, file));
+		const content = TEXT.test(file) ? Buffer.from(bytes.toString("utf8").replaceAll("\r\n", "\n")) : bytes;
+		hash.update(file).update("\0");
+		hash.update(createHash("sha256").update(content).digest()).update("\0");
+	}
+	return {
+		fingerprint: hash.digest("hex"),
+		files: normalized,
+		version
+	};
+}
+// src/provenance.ts
+const PROVENANCE_FILE = "soundor-vst3-host.json";
+function sha256(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+function sha256File(path) {
+	return sha256(readFileSync(path));
+}
+/** The problems with a provenance record, empty when it is well-formed. */
+function provenanceProblems(value) {
+	const p = value;
+	const problems = [];
+	if (p === null || typeof p !== "object") return ["it is not an object"];
+	if (p.format !== 1) problems.push(`format is ${p.format}, not 1`);
+	if (p.name !== "@soundor/vst3-host") problems.push(`name is ${p.name}`);
+	if (typeof p.version !== "string") problems.push("version is missing");
+	if (typeof p.protocol !== "number") problems.push("protocol is missing");
+	if (typeof p.target !== "string") problems.push("target is missing");
+	if (!Array.isArray(p.architectures)) problems.push("architectures are missing");
+	if (p.configuration !== "Release") problems.push(`configuration is ${p.configuration}, not Release`);
+	if (p.sourceCommit !== null && !/^[0-9a-f]{40}$/.test(p.sourceCommit ?? "")) problems.push("sourceCommit is not a full commit hash");
+	if (!/^[0-9a-f]{64}$/.test(p.sourceFingerprint ?? "")) problems.push("sourceFingerprint is not a SHA-256");
+	if (typeof p.executable?.path !== "string" || !/^[0-9a-f]{64}$/.test(p.executable.sha256 ?? "") || typeof p.executable.size !== "number") problems.push("executable is not { path, sha256, size }");
+	return problems;
+}
+function checkedProvenance(value, where) {
+	const problems = provenanceProblems(value);
+	if (problems.length) throw new Error(`${where} is not a valid host provenance record: ${problems.join("; ")}`);
+	return value;
+}
+// src/resolve.ts
+function selectionFile(root = packageRoot) {
+	return join(root, "build", "selected.json");
+}
+const verified = /* @__PURE__ */ new Map();
+function verifyExecutable(path, sha256, what) {
+	if (verified.get(path) === sha256) return;
+	if (!existsSync(path)) throw new Vst3HostError("executable-not-found", `${what}: ${path} does not exist`);
+	if (sha256File(path) !== sha256) throw new Vst3HostError("incompatible-host", `${what}: ${path} is not the executable its record describes (SHA-256 differs)`);
+	verified.set(path, sha256);
+}
+function resolveHost(options = {}) {
+	const root = options.root ?? packageRoot;
+	const explicit = options.executable ?? process.env.SOUNDOR_VST3_HOST_EXECUTABLE;
+	if (explicit) {
+		const executable = resolve(explicit);
+		if (!existsSync(executable)) throw new Vst3HostError("executable-not-found", `the VST3 host executable ${executable} does not exist`);
+		return {
+			executable,
+			source: "explicit",
+			reason: options.executable ? "given as `executable`" : "SOUNDOR_VST3_HOST_EXECUTABLE"
+		};
+	}
+	const platform = currentPlatform();
+	const target = targetFor(platform);
+	if (!target) throw new Vst3HostError("unsupported-platform", `@soundor/vst3-host has no executable for ${describePlatform(platform)}; it ships for Linux x64 (glibc), macOS (arm64 and x64) and Windows x64`);
+	const manifest = ownManifest(root);
+	if (isSourceWorkspace(root)) {
+		const file = selectionFile(root);
+		if (!existsSync(file)) throw new Vst3HostError("executable-not-found", "no VST3 host executable is selected in this checkout: run `pnpm --filter @soundor/vst3-host build:native` (prepareHost()) first");
+		const selection = JSON.parse(readFileSync(file, "utf8"));
+		const { fingerprint } = nativeInputs(root);
+		if (selection.sourceFingerprint !== fingerprint || selection.version !== manifest.version) throw new Vst3HostError("executable-not-found", "the selected VST3 host executable was built from other native sources than this checkout has: run `pnpm --filter @soundor/vst3-host build:native` again", {
+			selected: selection.sourceFingerprint,
+			current: fingerprint
+		});
+		const executable = isAbsolute(selection.executable) ? selection.executable : join(root, selection.executable);
+		verifyExecutable(executable, selection.sha256, "the selected VST3 host");
+		return {
+			executable,
+			source: "selection",
+			reason: selection.reason
+		};
+	}
+	let packageJson;
+	try {
+		packageJson = createRequire(join(root, "package.json")).resolve(`${target.package}/package.json`);
+	} catch {
+		throw new Vst3HostError("platform-package-missing", `${target.package} is not installed. npm or pnpm installs it with @soundor/vst3-host as an optional dependency for ${describePlatform(platform)}; it is missing when optional dependencies are omitted (--no-optional, --omit=optional) or node_modules came from another platform. Reinstall with optional dependencies.`, {
+			package: target.package,
+			version: manifest.version
+		});
+	}
+	const directory = dirname(packageJson);
+	const platformManifest = JSON.parse(readFileSync(packageJson, "utf8"));
+	const provenance = checkedProvenance(JSON.parse(readFileSync(join(directory, PROVENANCE_FILE), "utf8")), `${target.package}/${PROVENANCE_FILE}`);
+	if (platformManifest.version !== manifest.version || provenance.version !== manifest.version) throw new Vst3HostError("incompatible-host", `${target.package}@${platformManifest.version} is installed; @soundor/vst3-host@${manifest.version} needs exactly ${manifest.version}. Reinstall so both match.`);
+	if (provenance.protocol !== PROTOCOL_VERSION || provenance.target !== target.target) throw new Vst3HostError("incompatible-host", `${target.package} holds a ${provenance.target} executable for protocol ${provenance.protocol}; this client needs ${target.target} and protocol ${PROTOCOL_VERSION}`);
+	if (provenance.glibc && platform.glibc && !versionAtLeast(platform.glibc, provenance.glibc)) throw new Vst3HostError("unsupported-platform", `the VST3 host needs glibc ${provenance.glibc} or newer; this system has ${platform.glibc}`);
+	const executable = join(directory, target.executable);
+	verifyExecutable(executable, provenance.executable.sha256, target.package);
+	return {
+		executable,
+		source: "package",
+		reason: `${target.package}@${platformManifest.version}`,
+		provenance
+	};
+}
+// src/host.ts
+function audioParams(settings) {
+	return {
+		input: settings.input,
+		file: settings.file,
+		muted: settings.muted,
+		volume: settings.volume
+	};
+}
+/**
+* The one parameter with this title, or `unknown-parameter`. A JUCE plugin with
+* a Bypass of its own also has the bypass JUCE adds for hosts, with the same
+* title and the bypass flag: the title means the plugin's own.
+*/
+function parameterTitled(parameters, title) {
+	let found = parameters.filter((info) => info.title === title);
+	if (found.length > 1) {
+		const own = found.filter((info) => !info.flags.bypass);
+		if (own.length === 1) found = own;
+	}
+	if (found.length === 1) return found[0];
+	throw new Vst3HostError("unknown-parameter", found.length === 0 ? `No parameter is titled "${title}"; the plugin has: ${parameters.map((info) => `"${info.title}"`).join(", ")}` : `${found.length} parameters are titled "${title}"; use getParameters() and their ids`);
+}
+const live = /* @__PURE__ */ new Set();
+let exitHookInstalled = false;
+function track(child) {
+	live.add(child);
+	child.once("exit", () => live.delete(child));
+	if (!exitHookInstalled) {
+		exitHookInstalled = true;
+		process.once("exit", () => {
+			for (const host of live) host.kill("SIGKILL");
+		});
+	}
+}
+const LITTLE_ENDIAN = endianness() === "LE";
+/** Starts a host process, loads the plugin and resolves once it is ready. */
+async function launchHost(options) {
+	if (!LITTLE_ENDIAN) throw new Vst3HostError("unsupported-platform", "the host protocol carries little-endian audio");
+	const executable = options.executable ?? resolveHost().executable;
+	const maxPayloadBytes = options.maxPayloadBytes ?? DEFAULT_MAX_PAYLOAD_BYTES;
+	const args = [
+		options.editor ? "--ui" : "--headless",
+		"--max-payload",
+		String(maxPayloadBytes)
+	];
+	const env = {
+		...options.inheritEnv === false ? {} : process.env,
+		...options.env
+	};
+	for (const key of Object.keys(env)) if (env[key] === void 0) delete env[key];
+	const child = spawn(executable, args, {
+		cwd: options.cwd,
+		env,
+		detached: options.detached ?? false,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
+	});
+	track(child);
+	const host = new Vst3Host(child, {
+		maxPayloadBytes,
+		requestTimeout: options.requestTimeout ?? 6e4,
+		onLog: options.onLog,
+		executable
+	});
+	const startTimeout = options.startTimeout ?? 3e4;
+	try {
+		await host.ready(startTimeout, options.signal);
+		await host.load(options, startTimeout, options.signal);
+		return host;
+	} catch (error) {
+		await host.close();
+		throw error;
+	}
+}
+/** A running host with one plugin loaded. Requests run one at a time, in
+the order they are made. */
+var Vst3Host = class {
+	#child;
+	#options;
+	#events = new EventEmitter();
+	#decoder;
+	#queue = [];
+	#current;
+	#nextId = 1;
+	#stderr = "";
+	#partialLine = "";
+	#exit;
+	#exited;
+	#failure;
+	#closing;
+	#closeRequested = false;
+	#hello;
+	#identity;
+	#info;
+	/** @internal Use launchHost(). */
+	constructor(child, options) {
+		this.#child = child;
+		this.#options = options;
+		this.#decoder = new FrameDecoder(options.maxPayloadBytes);
+		this.#events.setMaxListeners(0);
+		this.#exited = new Promise((resolve) => {
+			child.once("exit", (code, signal) => {
+				this.#exit = {
+					code,
+					signal
+				};
+				this.#fail(this.#closeRequested ? new Vst3HostError("closed", "the VST3 host was closed") : new Vst3HostError("host-exited", `the VST3 host exited (${signal ? `signal ${signal}` : `code ${code}`})${this.#stderrTail()}`, {
+					code,
+					signal,
+					stderr: this.#stderr.slice(-4096)
+				}));
+				this.#events.emit("exit", {
+					code,
+					signal
+				});
+				resolve({
+					code,
+					signal
+				});
+			});
+			child.once("error", (error) => {
+				if (child.pid !== void 0) return;
+				this.#fail(new Vst3HostError("executable-not-found", `the VST3 host could not be started from ${options.executable}: ${error.message}`, { executable: options.executable }, { cause: error }));
+				this.#exit = {
+					code: null,
+					signal: null
+				};
+				resolve(this.#exit);
+			});
+		});
+		child.stdout.on("data", (chunk) => {
+			let frames;
+			try {
+				frames = this.#decoder.push(chunk);
+			} catch (error) {
+				this.#fail(new Vst3HostError("protocol-error", error.message));
+				child.kill("SIGKILL");
+				return;
+			}
+			for (const frame of frames) this.#receive(frame);
+		});
+		child.stderr.setEncoding("utf8");
+		child.stderr.on("data", (text) => {
+			this.#stderr = (this.#stderr + text).slice(-65536);
+			if (!this.#options.onLog) return;
+			const lines = (this.#partialLine + text).split(/\r?\n/);
+			this.#partialLine = lines.pop() ?? "";
+			for (const line of lines) this.#options.onLog(line);
+		});
+		child.stdin.on("error", () => {});
+	}
+	/** The host process's id. */
+	get pid() {
+		return this.#child.pid;
+	}
+	/** What the host reported when it started. */
+	get identity() {
+		return this.#identity;
+	}
+	/** The loaded plugin, as of launch or the last recreate/configure. */
+	get info() {
+		return this.#info;
+	}
+	/** Resolves when the process has ended. */
+	get exited() {
+		return this.#exited;
+	}
+	/** The end of what the host and the plugin wrote to stderr. */
+	get diagnostics() {
+		return this.#stderr;
+	}
+	on(event, listener) {
+		this.#events.on(event, listener);
+		return this;
+	}
+	off(event, listener) {
+		this.#events.off(event, listener);
+		return this;
+	}
+	once(event, listener) {
+		this.#events.once(event, listener);
+		return this;
+	}
+	/** @internal */
+	async ready(timeout, signal) {
+		const identity = await this.#withTimeout(new Promise((resolve, reject) => {
+			this.#hello = resolve;
+			this.#exited.then(() => reject(this.#failure));
+		}), timeout, signal, "start");
+		if (identity.protocol !== PROTOCOL_VERSION) throw new Vst3HostError("incompatible-host", `${this.#options.executable} speaks protocol ${identity.protocol}; this client speaks ${PROTOCOL_VERSION}. Use the executable of the same @soundor/vst3-host version.`, { ...identity });
+		this.#identity = identity;
+	}
+	/** @internal */
+	async load(options, timeout, signal) {
+		const { result } = await this.#request("load", {
+			path: options.plugin,
+			className: options.className,
+			classId: options.classId,
+			sampleRate: options.sampleRate,
+			blockSize: options.blockSize,
+			processMode: options.processMode,
+			inputs: options.inputs,
+			outputs: options.outputs,
+			openEditor: options.editor === true,
+			scale: options.scale,
+			presentation: options.presentation === void 0 ? "editor" : options.presentation ?? void 0
+		}, void 0, {
+			timeout,
+			signal
+		});
+		this.#info = result;
+	}
+	async getInfo(options) {
+		this.#info = (await this.#request("info", {}, void 0, options)).result;
+		return this.#info;
+	}
+	async getParameters(options) {
+		return (await this.#request("getParameters", {}, void 0, options)).result;
+	}
+	async getParameter(id, options) {
+		return (await this.#request("getParameter", { id }, void 0, options)).result;
+	}
+	/** Sets the controller's value now and hands the change to the processor
+	at the first frame of the next process call. */
+	async setParameter(id, value, options) {
+		const values = typeof value === "number" ? { normalized: value } : value;
+		return (await this.#request("setParameter", {
+			id,
+			...values
+		}, void 0, options)).result;
+	}
+	/** A parameter by its title, looked up at each use (see
+	{@link parameterTitled}). */
+	parameter(title) {
+		const find = async (options) => parameterTitled(await this.getParameters(options), title);
+		return {
+			get: find,
+			set: async (value, options) => this.setParameter((await find(options)).id, value, options)
+		};
+	}
+	async getLatency(options) {
+		return (await this.#request("getLatency", {}, void 0, options)).result;
+	}
+	/** Processes `frames` frames, in blocks of at most the block size. */
+	async process(request = {}) {
+		const info = this.#info;
+		const inputs = request.inputs ?? [];
+		if (inputs.length > info.buses.audioInputs.length) throw new Vst3HostError("invalid-request", `${inputs.length} input buses were given; "${info.name}" has ${info.buses.audioInputs.length}`);
+		let frames = request.frames;
+		for (const [index, bus] of inputs.entries()) {
+			if (bus == null) continue;
+			for (const [channel, samples] of bus.entries()) {
+				if (!(samples instanceof Float32Array)) throw new Vst3HostError("invalid-request", `inputs[${index}][${channel}] must be a Float32Array`);
+				frames ??= samples.length;
+				if (samples.length !== frames) throw new Vst3HostError("invalid-request", `inputs[${index}][${channel}] has ${samples.length} frames; the call processes ${frames}`);
+			}
+		}
+		if (frames === void 0) throw new Vst3HostError("invalid-request", "process() needs `frames` when no input audio is given");
+		if (!Number.isInteger(frames) || frames < 0) throw new Vst3HostError("invalid-request", `frames must be a non-negative integer, not ${frames}`);
+		const channels = inputs.map((bus) => bus?.length ?? 0);
+		const bytes = channels.reduce((sum, count) => sum + count, 0) * frames * 4;
+		const outputBytes = info.buses.audioOutputs.filter((bus) => bus.active).reduce((sum, bus) => sum + bus.channels, 0) * frames * 4;
+		if (bytes > this.#options.maxPayloadBytes || outputBytes > this.#options.maxPayloadBytes) throw new Vst3HostError("message-too-large", `${frames} frames exceed the ${this.#options.maxPayloadBytes}-byte message limit; process them in several calls (the transport and plugin state carry over) or raise maxPayloadBytes`);
+		const payload = new Uint8Array(bytes);
+		let offset = 0;
+		for (const bus of inputs) for (const samples of bus ?? []) {
+			payload.set(new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength), offset);
+			offset += samples.byteLength;
+		}
+		const { result, payload: output } = await this.#request("process", {
+			frames,
+			inputs: channels,
+			events: request.events,
+			parameterChanges: request.parameterChanges,
+			transport: request.transport
+		}, payload, request);
+		const response = result;
+		const audio = new Float32Array(output.byteLength / 4);
+		new Uint8Array(audio.buffer).set(output);
+		let position = 0;
+		const outputs = response.outputs.map((count) => Array.from({ length: count }, () => {
+			const channel = audio.subarray(position, position + frames);
+			position += frames;
+			return channel;
+		}));
+		return {
+			...response,
+			outputs
+		};
+	}
+	/** The processor's and the controller's state. Pending parameter changes
+	reach the processor first (in a process call of zero frames). */
+	async getState(options) {
+		const { result, payload } = await this.#request("getState", {}, void 0, options);
+		const { componentBytes } = result;
+		const bytes = new Uint8Array(payload);
+		return {
+			component: bytes.slice(0, componentBytes),
+			controller: bytes.slice(componentBytes)
+		};
+	}
+	async setState(state, options) {
+		const payload = new Uint8Array(state.component.byteLength + state.controller.byteLength);
+		payload.set(state.component, 0);
+		payload.set(state.controller, state.component.byteLength);
+		await this.#request("setState", {
+			componentBytes: state.component.byteLength,
+			controllerBytes: state.controller.byteLength
+		}, payload, options);
+	}
+	/** Deactivates and reactivates the plugin: it clears delay lines, held
+	notes and other processing state. The transport is kept. */
+	async reset(options) {
+		await this.#request("reset", {}, void 0, options);
+	}
+	/** A fresh instance of the same class and setup, in the same process.
+	The transport starts over. */
+	async recreate(options) {
+		this.#info = (await this.#request("recreate", {}, void 0, options)).result;
+		return this.#info;
+	}
+	/** A new sample rate, block size, mode or bus layout. What is not given
+	stays as it is. */
+	async configure(setup, options) {
+		this.#info = (await this.#request("configure", setup, void 0, options)).result;
+		return this.#info;
+	}
+	/** Opens the editor, or shows an open one in another presentation (it
+	opens again there, at the same size). */
+	async openEditor(options = {}) {
+		return (await this.#request("openEditor", {
+			scale: options.scale,
+			presentation: options.presentation
+		}, void 0, options)).result;
+	}
+	async closeEditor(options) {
+		return (await this.#request("closeEditor", {}, void 0, options)).result;
+	}
+	async resizeEditor(width, height, options) {
+		return (await this.#request("resizeEditor", {
+			width,
+			height
+		}, void 0, options)).result;
+	}
+	async getEditor(options) {
+		return (await this.#request("getEditor", {}, void 0, options)).result;
+	}
+	/** Starts live audio through the default output device, with `settings`
+	applied first. Fails with `audio-unavailable` without a device.
+	While it runs, `process` fails: the plugin is processing live. */
+	async startAudio(settings = {}) {
+		return (await this.#request("startAudio", audioParams(settings), void 0, settings)).result;
+	}
+	async stopAudio(options) {
+		return (await this.#request("stopAudio", {}, void 0, options)).result;
+	}
+	/** Changes live audio's input, volume or muting, running or not. */
+	async setAudio(settings) {
+		return (await this.#request("setAudio", audioParams(settings), void 0, settings)).result;
+	}
+	async getAudio(options) {
+		return (await this.#request("getAudio", {}, void 0, options)).result;
+	}
+	/** The host's transport, which live audio advances while it plays. */
+	async getTransport(options) {
+		return (await this.#request("getTransport", {}, void 0, options)).result;
+	}
+	/** Changes the transport, as `process({ transport })` does, without
+	processing: play and stop live audio's transport, or set its tempo. */
+	async setTransport(update, options) {
+		return (await this.#request("setTransport", { ...update }, void 0, options)).result;
+	}
+	/** Unloads the plugin and ends the process: politely, then by force.
+	Safe to call more than once and after a failure. */
+	close(timeout = 1e4) {
+		this.#closing ??= (async () => {
+			if (this.#exit) return this.#exit;
+			this.#closeRequested = true;
+			const kill = setTimeout(() => this.#child.kill("SIGKILL"), timeout);
+			try {
+				if (!this.#failure && this.#identity) await this.#request("shutdown", {}, void 0, { timeout }).catch(() => this.#child.kill("SIGKILL"));
+				else this.#child.kill("SIGKILL");
+				this.#child.stdin.end();
+				return await this.#exited;
+			} finally {
+				clearTimeout(kill);
+			}
+		})();
+		return this.#closing;
+	}
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
+	#request(method, params, payload, options) {
+		if (this.#failure && method !== "shutdown") return Promise.reject(this.#failure);
+		if (this.#closing && method !== "shutdown") return Promise.reject(new Vst3HostError("closed", "the VST3 host is closing"));
+		if (options?.signal?.aborted) return Promise.reject(this.#aborted(method, options.signal));
+		return new Promise((resolve, reject) => {
+			const pending = {
+				id: this.#nextId++,
+				method,
+				params,
+				payload,
+				timeout: options?.timeout ?? this.#options.requestTimeout,
+				signal: options?.signal,
+				resolve,
+				reject,
+				settled: false
+			};
+			if (pending.signal) {
+				pending.onAbort = () => {
+					const index = this.#queue.indexOf(pending);
+					if (index >= 0) this.#queue.splice(index, 1);
+					this.#settle(pending, pending !== this.#current);
+					reject(this.#aborted(method, pending.signal));
+				};
+				pending.signal.addEventListener("abort", pending.onAbort, { once: true });
+			}
+			this.#queue.push(pending);
+			this.#pump();
+		});
+	}
+	#aborted(method, signal) {
+		return new Vst3HostError("aborted", `${method} was aborted`, void 0, { cause: signal.reason });
+	}
+	#settle(pending, clearTimer = true) {
+		pending.settled = true;
+		if (clearTimer) clearTimeout(pending.timer);
+		if (pending.onAbort) pending.signal?.removeEventListener("abort", pending.onAbort);
+	}
+	#pump() {
+		if (this.#current || this.#failure) return;
+		const next = this.#queue.shift();
+		if (!next) return;
+		this.#current = next;
+		next.timer = setTimeout(() => {
+			const error = new Vst3HostError("timeout", `${next.method} did not finish within ${next.timeout} ms; the VST3 host was stopped${this.#stderrTail()}`, {
+				method: next.method,
+				timeout: next.timeout
+			});
+			if (!next.settled) {
+				this.#settle(next);
+				next.reject(error);
+			}
+			this.#fail(error);
+			this.#child.kill("SIGKILL");
+		}, next.timeout);
+		const frame = encodeFrame({
+			id: next.id,
+			method: next.method,
+			params: next.params
+		}, next.payload);
+		for (const part of frame) this.#child.stdin.write(part);
+	}
+	#receive(frame) {
+		const header = frame.header;
+		if (typeof header.event === "string") {
+			if (header.event === "hello") this.#hello?.(header.params);
+			else if (header.event === "protocolError") this.#fail(new Vst3HostError("protocol-error", `the host rejected the request stream: ${header.params.message}`));
+			else this.#events.emit(header.event, header.params);
+			return;
+		}
+		const pending = this.#current;
+		if (!pending || header.id !== pending.id) {
+			this.#fail(new Vst3HostError("protocol-error", `the host answered request ${header.id}, not ${pending?.id}`));
+			this.#child.kill("SIGKILL");
+			return;
+		}
+		this.#current = void 0;
+		clearTimeout(pending.timer);
+		if (!pending.settled) {
+			this.#settle(pending);
+			if (header.error) pending.reject(new Vst3HostError(header.error.code, header.error.message, header.error.details));
+			else pending.resolve({
+				result: header.result,
+				payload: frame.payload
+			});
+		}
+		this.#pump();
+	}
+	#fail(error) {
+		this.#failure ??= error;
+		const failed = [...this.#current ? [this.#current] : [], ...this.#queue];
+		this.#current = void 0;
+		this.#queue = [];
+		for (const pending of failed) if (!pending.settled) {
+			this.#settle(pending);
+			pending.reject(this.#failure);
+		}
+	}
+	#stderrTail() {
+		const tail = this.#stderr.trim().split("\n").slice(-12).join("\n");
+		return tail ? `\nhost stderr:\n${tail}` : "";
+	}
+	async #withTimeout(promise, timeout, signal, what) {
+		let timer;
+		let onAbort;
+		try {
+			return await Promise.race([promise, new Promise((_, reject) => {
+				timer = setTimeout(() => reject(new Vst3HostError("timeout", `the VST3 host did not ${what} within ${timeout} ms${this.#stderrTail()}`)), timeout);
+				if (signal) {
+					onAbort = () => reject(this.#aborted(what, signal));
+					if (signal.aborted) onAbort();
+					else signal.addEventListener("abort", onAbort, { once: true });
+				}
+			})]);
+		} finally {
+			clearTimeout(timer);
+			if (onAbort) signal?.removeEventListener("abort", onAbort);
+		}
+	}
+};
+// src/npm.ts
+const NPM_REGISTRY = "https://registry.npmjs.org";
+/** Never "missing" for anything but the registry's 404: a network,
+authentication or server error is an error. */
+var RegistryError = class extends Error {
+	name = "RegistryError";
+	status;
+	constructor(message, status, options) {
+		super(message, options);
+		this.status = status;
+	}
+};
+function versionUrl(registry, name, version) {
+	return `${registry.replace(/\/$/, "")}/${name.replace("/", "%2f")}/${encodeURIComponent(version)}`;
+}
+/** The version's metadata, or null when the registry says it does not exist. */
+async function versionMetadata(name, version, { registry = NPM_REGISTRY, fetcher = fetch } = {}) {
+	const url = versionUrl(registry, name, version);
+	let response;
+	try {
+		response = await fetcher(url, {
+			headers: { accept: "application/json" },
+			signal: AbortSignal.timeout(3e4)
+		});
+	} catch (error) {
+		throw new RegistryError(`could not reach ${url}: ${error.message}`, void 0, { cause: error });
+	}
+	if (response.status === 404) return null;
+	if (!response.ok) throw new RegistryError(`${url} answered HTTP ${response.status}`, response.status);
+	let metadata;
+	try {
+		metadata = await response.json();
+	} catch (error) {
+		throw new RegistryError(`${url} did not answer JSON`, response.status, { cause: error });
+	}
+	if (metadata.name !== name || metadata.version !== version || !metadata.dist?.integrity?.startsWith("sha512-") || typeof metadata.dist.tarball !== "string") throw new RegistryError(`${url} has no ${name}@${version} with a SHA-512 integrity`);
+	return metadata;
+}
+function matchesIntegrity(bytes, integrity) {
+	if (!integrity.startsWith("sha512-")) return false;
+	const expected = Buffer.from(integrity.slice(7), "base64");
+	const actual = createHash("sha512").update(bytes).digest();
+	return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+/** The version's tarball, verified against its metadata's integrity. */
+async function downloadTarball(metadata, { registry = NPM_REGISTRY, fetcher = fetch } = {}) {
+	const url = new URL(metadata.dist.tarball);
+	const allowed = new URL(registry);
+	if (url.protocol !== allowed.protocol || url.host !== allowed.host) throw new RegistryError(`${metadata.name}'s tarball must come from ${allowed.origin}, not ${url.origin}`);
+	let response;
+	try {
+		response = await fetcher(url.href, { signal: AbortSignal.timeout(12e4) });
+	} catch (error) {
+		throw new RegistryError(`could not download ${url.href}: ${error.message}`, void 0, { cause: error });
+	}
+	if (!response.ok) throw new RegistryError(`${url.href} answered HTTP ${response.status}`, response.status);
+	const bytes = Buffer.from(await response.arrayBuffer());
+	if (!matchesIntegrity(bytes, metadata.dist.integrity)) throw new RegistryError(`${metadata.name}@${metadata.version}'s tarball failed its SHA-512 integrity check`);
+	return bytes;
+}
+/** Every entry of a gzipped tarball (ustar with pax path records, as npm
+writes them). Links and devices are reported as "other". */
+function readTarball(gzipped, maxBytes = 536870912) {
+	const tar = gunzipSync(gzipped, { maxOutputLength: maxBytes });
+	const entries = [];
+	let paxPath;
+	for (let offset = 0; offset + 512 <= tar.length;) {
+		const header = tar.subarray(offset, offset + 512);
+		if (header.every((byte) => byte === 0)) break;
+		const field = (start, length) => header.toString("utf8", start, start + length).split("\0")[0];
+		const size = Number.parseInt(field(124, 12).trim() || "0", 8);
+		if (!Number.isSafeInteger(size) || size < 0 || offset + 512 + size > tar.length) throw new Error("the tarball is truncated or corrupt");
+		const typeFlag = String.fromCharCode(header[156]);
+		const data = tar.subarray(offset + 512, offset + 512 + size);
+		offset += 512 + Math.ceil(size / 512) * 512;
+		if (typeFlag === "x") {
+			paxPath = /\d+ path=([^\n]*)\n/.exec(data.toString("utf8"))?.[1];
+			continue;
+		}
+		if (typeFlag === "g") continue;
+		const prefix = field(345, 155);
+		let path = paxPath ?? (prefix ? `${prefix}/${field(0, 100)}` : field(0, 100));
+		paxPath = void 0;
+		path = path.replace(/^package\//, "");
+		entries.push({
+			path,
+			mode: Number.parseInt(field(100, 8).trim() || "0", 8),
+			type: typeFlag === "0" || typeFlag === "\0" ? "file" : typeFlag === "5" ? "directory" : "other",
+			data: Buffer.from(data)
+		});
+	}
+	return entries;
+}
+// src/prepare.ts
+function cacheRoot() {
+	if (process.env.SOUNDOR_CACHE) return process.env.SOUNDOR_CACHE;
+	if (process.platform === "win32") return join(process.env.LOCALAPPDATA ?? homedir(), "Soundor", "cache");
+	if (process.platform === "darwin") return join(homedir(), "Library", "Caches", "Soundor");
+	return join(process.env.XDG_CACHE_HOME || join(homedir(), ".cache"), "soundor");
+}
+function currentTarget() {
+	const platform = currentPlatform();
+	const target = targetFor(platform);
+	if (!target) throw new Vst3HostError("unsupported-platform", `@soundor/vst3-host has no executable for ${describePlatform(platform)}`);
+	return target;
+}
+function writeAtomically(path, data, mode) {
+	const partial = `${path}.${randomUUID()}.part`;
+	writeFileSync(partial, data);
+	if (mode !== void 0) chmodSync(partial, mode);
+	renameSync(partial, path);
+}
+async function prepareHost(options = {}) {
+	const root = options.root ?? packageRoot;
+	const log = options.log ?? ((message) => console.log(message));
+	const workspace = isSourceWorkspace(root);
+	const target = currentTarget();
+	const { fingerprint, version } = nativeInputs(root);
+	const artifact = options.artifact ?? process.env.SOUNDOR_VST3_HOST_ARTIFACT;
+	const build = options.build ?? ((reason) => buildFromSource(root, fingerprint, reason, log));
+	const select = (prepared) => {
+		log(`VST3 host: ${prepared.executable} (${prepared.mode}: ${prepared.reason})`);
+		if (workspace) {
+			mkdirSync(join(root, "build"), { recursive: true });
+			const selection = {
+				mode: prepared.mode,
+				executable: relative(root, prepared.executable),
+				sha256: sha256File(prepared.executable),
+				sourceFingerprint: fingerprint,
+				version,
+				target: target.target,
+				reason: prepared.reason
+			};
+			writeAtomically(selectionFile(root), `${JSON.stringify(selection, null, 2)}\n`);
+		}
+		return prepared;
+	};
+	if (artifact) return select({
+		executable: checkArtifact(artifact, {
+			target,
+			version,
+			fingerprint,
+			commit: options.commit ?? process.env.GITHUB_SHA
+		}),
+		mode: "artifact",
+		reason: `the CI artifact in ${artifact}, matching this checkout`,
+		sourceFingerprint: fingerprint
+	});
+	const mode = options.mode ?? "prebuilt";
+	if (mode !== "source" && !workspace) {
+		const resolved = resolveHost({ root });
+		return {
+			executable: resolved.executable,
+			mode: "prebuilt",
+			reason: resolved.reason,
+			sourceFingerprint: resolved.provenance?.sourceFingerprint ?? fingerprint
+		};
+	}
+	if (mode !== "source") {
+		const cache = options.cache ?? cacheRoot();
+		let published;
+		try {
+			published = await publishedExecutable({
+				target,
+				version,
+				fingerprint,
+				cache,
+				registry: options.registry ?? "https://registry.npmjs.org",
+				fetcher: options.fetcher ?? fetch
+			});
+		} catch (error) {
+			throw new Vst3HostError("selection-failed", `could not check the published VST3 host executable (${error.message}). Build it instead with mode "source" (pnpm --filter @soundor/vst3-host build:native).`, void 0, { cause: error });
+		}
+		if (typeof published === "object") return select(published);
+		const reason = published === "unpublished" ? `${target.package}@${version} is not published` : `the native sources differ from ${target.package}@${version}'s`;
+		if (mode === "published") throw new Vst3HostError("selection-failed", `no published VST3 host executable to use: ${reason}`);
+		log(`VST3 host: building from source (${reason})`);
+		return select(build(`${reason}; built from source`));
+	}
+	return select(build("built from source as requested"));
+}
+async function publishedExecutable(context) {
+	const { target, version, fingerprint } = context;
+	const directory = join(context.cache, "vst3-host", "prebuilt", version, target.target);
+	const cachedProvenance = join(directory, PROVENANCE_FILE);
+	if (existsSync(cachedProvenance)) {
+		const provenance = checkedProvenance(JSON.parse(readFileSync(cachedProvenance, "utf8")), cachedProvenance);
+		const executable = join(directory, provenance.executable.path);
+		if (existsSync(executable) && sha256File(executable) === provenance.executable.sha256) {
+			if (provenance.sourceFingerprint !== fingerprint) return "different";
+			return {
+				executable,
+				mode: "prebuilt",
+				reason: `${target.package}@${version}, cached in ${directory}; its native inputs match`,
+				sourceFingerprint: fingerprint
+			};
+		}
+	}
+	const metadata = await versionMetadata(target.package, version, context);
+	if (metadata === null) return "unpublished";
+	const entries = readTarball(await downloadTarball(metadata, context));
+	const record = entries.find((entry) => entry.path === PROVENANCE_FILE);
+	if (!record) throw new Error(`${target.package}@${version} has no ${PROVENANCE_FILE}`);
+	const provenance = checkedProvenance(JSON.parse(record.data.toString("utf8")), `${target.package}@${version}/${PROVENANCE_FILE}`);
+	if (provenance.version !== version || provenance.target !== target.target || provenance.protocol !== PROTOCOL_VERSION) throw new Error(`${target.package}@${version} describes another build (${provenance.target} ${provenance.version})`);
+	const binary = entries.find((entry) => entry.path === provenance.executable.path);
+	if (!binary || sha256(binary.data) !== provenance.executable.sha256) throw new Error(`${target.package}@${version}'s executable does not match its provenance`);
+	mkdirSync(join(directory, "bin"), { recursive: true });
+	const executable = join(directory, provenance.executable.path);
+	writeAtomically(executable, binary.data, 493);
+	writeAtomically(cachedProvenance, `${JSON.stringify(provenance, null, 2)}\n`);
+	if (provenance.sourceFingerprint !== fingerprint) return "different";
+	return {
+		executable,
+		mode: "prebuilt",
+		reason: `${target.package}@${version} from npm; its native inputs match`,
+		sourceFingerprint: fingerprint
+	};
+}
+/** A CI artifact: right target, version, sources and commit, intact. */
+function checkArtifact(directory, expected) {
+	const file = join(directory, PROVENANCE_FILE);
+	if (!existsSync(file)) throw new Vst3HostError("selection-failed", `${directory} has no ${PROVENANCE_FILE}`);
+	let provenance;
+	try {
+		provenance = checkedProvenance(JSON.parse(readFileSync(file, "utf8")), file);
+	} catch (error) {
+		throw new Vst3HostError("selection-failed", error.message);
+	}
+	const problems = [];
+	if (provenance.target !== expected.target.target) problems.push(`it is for ${provenance.target}, not ${expected.target.target}`);
+	if (provenance.version !== expected.version) problems.push(`it is version ${provenance.version}, not ${expected.version}`);
+	if (provenance.protocol !== PROTOCOL_VERSION) problems.push(`it speaks protocol ${provenance.protocol}, not ${PROTOCOL_VERSION}`);
+	if (provenance.sourceFingerprint !== expected.fingerprint) problems.push("it was built from other native sources than this checkout has");
+	if (expected.commit && provenance.sourceCommit !== expected.commit) problems.push(`it was built from ${provenance.sourceCommit}, not ${expected.commit}`);
+	const executable = join(directory, provenance.executable.path);
+	if (!existsSync(executable)) problems.push(`${provenance.executable.path} is missing`);
+	else if (sha256File(executable) !== provenance.executable.sha256) problems.push(`${provenance.executable.path} does not match its SHA-256`);
+	if (problems.length) throw new Vst3HostError("selection-failed", `the VST3 host artifact in ${directory} does not match: ${problems.join("; ")}`);
+	if (process.platform !== "win32") chmodSync(executable, 493);
+	return executable;
+}
+/** The build directory for the current toolchain: a build directory keeps
+the compiler and generator it was configured with. */
+function sourceBuildDirectory(root = packageRoot) {
+	const toolchain = [
+		process.platform,
+		process.arch,
+		process.env.CMAKE_GENERATOR ?? "",
+		process.env.CC ?? "",
+		process.env.CXX ?? "",
+		process.env.CMAKE_OSX_ARCHITECTURES ?? ""
+	].join("\0");
+	const id = createHash("sha256").update(toolchain).digest("hex").slice(0, 12);
+	return join(root, "build", `host-${id}`);
+}
+function run(command, args, cwd) {
+	const result = spawnSync(command, args, {
+		cwd,
+		stdio: "inherit"
+	});
+	if (result.error) throw new Vst3HostError("selection-failed", `could not run ${command}: ${result.error.message} (building the VST3 host needs CMake and a C++20 compiler)`);
+	if (result.status !== 0) throw new Vst3HostError("selection-failed", `${command} ${args.join(" ")} failed (exit ${result.status})`);
+}
+/** An incremental Release build of the executable alone. */
+function buildFromSource(root, fingerprint, reason, log = console.log) {
+	const directory = sourceBuildDirectory(root);
+	log(`VST3 host: building in ${directory}`);
+	run("cmake", [
+		"-S",
+		root,
+		"-B",
+		directory,
+		"-DCMAKE_BUILD_TYPE=Release"
+	], root);
+	run("cmake", [
+		"--build",
+		directory,
+		"--config",
+		"Release",
+		"--target",
+		"soundor-vst3-host"
+	], root);
+	const executable = join(directory, "bin", process.platform === "win32" ? "soundor-vst3-host.exe" : "soundor-vst3-host");
+	if (!existsSync(executable)) throw new Vst3HostError("selection-failed", `the build did not produce ${executable}`);
+	return {
+		executable,
+		mode: "source",
+		reason,
+		sourceFingerprint: fingerprint
+	};
+}
+export { nativeInputs as a, PROTOCOL_VERSION as c, resolveHost as i, Vst3HostError as l, Vst3Host as n, targetFor as o, launchHost as r, targets as s, prepareHost as t };
+
+//# sourceMappingURL=prepare-ayjTVhfk.mjs.map