oasbox 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kyle Brodeur
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS 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.

package/README.md

@@ -0,0 +1,54 @@
+# oasbox
+
+The in-project CLI for [Obsidian Arrow](https://github.com/kylebrodeur/obsidian-arrow-sandbox)
+projects — a small, deterministic generator and validator for components, views,
+and stories. Package-manager agnostic (pnpm / npm / bun / yarn) and installed as
+a local devDependency by `create-obsidian-arrow`, so its behavior is pinned and
+reproducible for humans and agents alike.
+
+## Install
+
+Scaffolds created with `create-obsidian-arrow` already include `oasbox` as a
+devDependency. To add it manually:
+
+```sh
+pnpm add -D oasbox     # or: npm i -D oasbox / bun add -d oasbox
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `oasbox generate component <Name> [--css]` | Scaffold a primitive → `src/components/<Name>/`. `Parent/Child` → view-scoped component under `src/views/<Parent>/`. |
+| `oasbox generate view <Name> [--editor]` | Scaffold a full-pane view (+ story). `--editor` → `surface: "editor"` (readable line width). |
+| `oasbox generate story <Name> [--kind view\|component]` | Story file only, for existing source. |
+| `oasbox validate [--json]` | Run CSS-orphan / scope / import checks + typecheck. `--json` for machine-readable output. |
+| `oasbox test` / `oasbox dev` | Pass-throughs to the project's package manager (auto-detected from the lockfile). |
+
+Run via the local bin (`oasbox …`) or your package manager:
+`pnpm oasbox …` · `npx oasbox …` · `bunx oasbox …`.
+
+## What `generate` produces
+
+```
+oasbox generate view Notes            oasbox generate component Badge --css
+└─ src/views/Notes/                    └─ src/components/Badge/
+   ├─ Notes.ts   (component)              ├─ Badge.ts
+   ├─ Notes.css                           └─ Badge.css
+   └─ state.ts                         └─ stories/components/Badge.stories.ts
+└─ stories/views/Notes.stories.ts
+   (kind: "view", surface: "panel")
+```
+
+```mermaid
+flowchart LR
+  M["command flags"] --> K{"kind ?"}
+  K -- "component" --> C["src/components/… + story"]
+  K -- "view" --> S{"--editor ?"}
+  S -- "no" --> P["view · surface: panel (full-bleed)"]
+  S -- "yes" --> E["view · surface: editor (oas-readable-width)"]
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "oasbox",
+  "version": "0.1.0",
+  "description": "In-project CLI for obsidian-arrow projects — generate, validate, test.",
+  "type": "module",
+  "bin": {
+    "oasbox": "src/cli.mjs"
+  },
+  "files": [
+    "src",
+    "templates"
+  ],
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^12.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.mjs",
+    "check": "node --test test/**/*.test.mjs",
+    "ci": "node --test test/**/*.test.mjs"
+  }
+}

package/src/cli.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { registerDev } from "./commands/dev.mjs";
+import { registerGenerate } from "./commands/generate.mjs";
+import { registerTest } from "./commands/test.mjs";
+import { registerValidate } from "./commands/validate.mjs";
+
+program
+	.name("oasbox")
+	.description("obsidian-arrow in-project CLI")
+	.option("--json", "machine-readable output")
+	.showHelpAfterError();
+
+registerGenerate(program);
+registerValidate(program);
+registerTest(program);
+registerDev(program);
+
+// No command given → print help and exit 0.
+if (process.argv.length <= 2) {
+	program.outputHelp();
+	process.exit(0);
+}
+
+program.parseAsync(process.argv);

package/src/commands/dev.mjs

@@ -0,0 +1,20 @@
+import { run } from "../lib/run.mjs";
+
+/**
+ * Start the dev server.
+ * @param {{ runner?: function }} options
+ * @returns {number} exit status from the dev process
+ */
+export function dev({ runner = run } = {}) {
+	return runner("dev");
+}
+
+export function registerDev(program) {
+	program
+		.command("dev")
+		.description("start the dev server")
+		.action(() => {
+			const status = dev({ runner: run });
+			process.exit(status);
+		});
+}

package/src/commands/generate.mjs

@@ -0,0 +1,406 @@
+import fs from "node:fs";
+import path from "node:path";
+import { emit } from "../lib/emit.mjs";
+import { resolveProjectRoot } from "../lib/project.mjs";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Write a file, refusing to overwrite an existing one.
+ * @param {string} absPath
+ * @param {string} content
+ */
+function writeNew(absPath, content) {
+	if (fs.existsSync(absPath)) {
+		throw new Error(`already exists: ${absPath}`);
+	}
+	fs.mkdirSync(path.dirname(absPath), { recursive: true });
+	fs.writeFileSync(absPath, content);
+}
+
+/**
+ * Convert a PascalCase or camelCase name to kebab-case.
+ * e.g. "MyComponent" → "my-component"
+ */
+function toKebab(name) {
+	return name.replace(/([A-Z])/g, (m, l, i) => (i ? "-" : "") + l.toLowerCase()).replace(/^-/, "");
+}
+
+// ---------------------------------------------------------------------------
+// Component generator
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a component scaffold.
+ *
+ * Supports view-scoped components via `Parent/Child` syntax:
+ *   "Foo"              → src/components/Foo/Foo.ts  (always a folder)
+ *   "ChatView/Composer" → src/views/ChatView/Composer.ts  (flat by default)
+ *   "ChatView/Widget --css" → src/views/ChatView/Widget/Widget.ts + .css
+ *
+ * @param {string} root       - absolute project root
+ * @param {string} name       - component name, optionally "ParentView/Child"
+ * @param {{ css?: boolean }} opts
+ * @returns {{ created: string[] }}
+ */
+export function generateComponent(root, name, opts = {}) {
+	const withCss = Boolean(opts.css);
+
+	// Detect view-scoped "Parent/Child" syntax
+	const slashIdx = name.indexOf("/");
+	if (slashIdx !== -1) {
+		return generateViewScopedComponent(root, name, withCss);
+	}
+
+	const srcDir = path.join(root, "src", "components", name);
+	const tsAbs = path.join(srcDir, `${name}.ts`);
+	const cssAbs = withCss ? path.join(srcDir, `${name}.css`) : null;
+	const storyAbs = path.join(root, "stories", "components", `${name}.stories.ts`);
+
+	// Check for existing files before writing any
+	if (fs.existsSync(tsAbs)) {
+		throw new Error(`already exists: ${tsAbs}`);
+	}
+	if (fs.existsSync(storyAbs)) {
+		throw new Error(`already exists: ${storyAbs}`);
+	}
+
+	const cssImport = withCss ? `import "./${name}.css";\n` : "";
+	const tsContent = `${cssImport}import { html } from "@arrow-js/core";
+import type { ArrowExpression } from "@arrow-js/core";
+
+export function ${name}(): ArrowExpression {
+\treturn html\`<div class="${toKebab(name)}">TODO</div>\`;
+}
+`;
+
+	const componentImport = `../../src/components/${name}/${name}`;
+	const storyContent = `import { ${name} } from "${componentImport}";
+import { defineStories } from "../../tools/viewer/stories";
+
+export default defineStories({
+\tdescription: "TODO: describe ${name}.",
+\tstatus: "draft",
+\tvariants: {
+\t\tdefault: () => ${name}(),
+\t},
+});
+`;
+
+	const created = [];
+
+	writeNew(tsAbs, tsContent);
+	created.push(`src/components/${name}/${name}.ts`);
+
+	if (cssAbs) {
+		writeNew(cssAbs, `/* ${name} styles */\n`);
+		created.push(`src/components/${name}/${name}.css`);
+	}
+
+	writeNew(storyAbs, storyContent);
+	created.push(`stories/components/${name}.stories.ts`);
+
+	return { created };
+}
+
+/**
+ * Generate a view-scoped component scaffold.
+ * `fullName` is "ParentView/ComponentName".
+ *
+ * Flat by default (no folder); --css adds a folder with a CSS file.
+ * Story lands at stories/views/<Parent>/<Component>.stories.ts.
+ *
+ * @param {string} root
+ * @param {string} fullName  - e.g. "ChatView/Composer"
+ * @param {boolean} withCss
+ * @returns {{ created: string[] }}
+ */
+function generateViewScopedComponent(root, fullName, withCss) {
+	const parts = fullName.split("/");
+	const componentName = parts[parts.length - 1];
+	const parentView = parts.slice(0, -1).join("/");
+
+	const viewDir = path.join(root, "src", "views", parentView);
+
+	// Flat (no folder) by default; folder only when --css
+	let srcDir;
+	let tsAbs;
+	let cssAbs;
+
+	if (withCss) {
+		srcDir = path.join(viewDir, componentName);
+		tsAbs = path.join(srcDir, `${componentName}.ts`);
+		cssAbs = path.join(srcDir, `${componentName}.css`);
+	} else {
+		srcDir = viewDir;
+		tsAbs = path.join(viewDir, `${componentName}.ts`);
+		cssAbs = null;
+	}
+
+	// Story is at stories/views/<parentView>/<componentName>.stories.ts
+	// That's 3 levels deep (stories/views/Parent/), so prefix is ../../../
+	const storyAbs = path.join(root, "stories", "views", parentView, `${componentName}.stories.ts`);
+
+	if (fs.existsSync(tsAbs)) {
+		throw new Error(`already exists: ${tsAbs}`);
+	}
+	if (fs.existsSync(storyAbs)) {
+		throw new Error(`already exists: ${storyAbs}`);
+	}
+
+	const cssImport = withCss ? `import "./${componentName}.css";\n` : "";
+	const tsContent = `${cssImport}import { html } from "@arrow-js/core";
+import type { ArrowExpression } from "@arrow-js/core";
+
+export function ${componentName}(): ArrowExpression {
+\treturn html\`<div class="${toKebab(componentName)}">TODO</div>\`;
+}
+`;
+
+	// stories/views/Parent/ is 3 dirs deep → ../../../ to reach root
+	const componentImport = `../../../src/views/${parentView}/${componentName}`;
+	const storyContent = `import { ${componentName} } from "${componentImport}";
+import { defineStories } from "../../../tools/viewer/stories";
+
+export default defineStories({
+\tkind: "component",
+\tdescription: "TODO: describe ${componentName}.",
+\tstatus: "draft",
+\tvariants: {
+\t\tdefault: () => ${componentName}(),
+\t},
+});
+`;
+
+	const created = [];
+
+	if (withCss) {
+		fs.mkdirSync(srcDir, { recursive: true });
+	} else {
+		fs.mkdirSync(viewDir, { recursive: true });
+	}
+
+	writeNew(tsAbs, tsContent);
+	if (withCss) {
+		created.push(`src/views/${parentView}/${componentName}/${componentName}.ts`);
+	} else {
+		created.push(`src/views/${parentView}/${componentName}.ts`);
+	}
+
+	if (cssAbs) {
+		writeNew(cssAbs, `/* ${componentName} styles */\n`);
+		created.push(`src/views/${parentView}/${componentName}/${componentName}.css`);
+	}
+
+	fs.mkdirSync(path.dirname(storyAbs), { recursive: true });
+	writeNew(storyAbs, storyContent);
+	created.push(`stories/views/${parentView}/${componentName}.stories.ts`);
+
+	return { created };
+}
+
+// ---------------------------------------------------------------------------
+// View generator
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a view scaffold.
+ *
+ * @param {string} root       - absolute project root
+ * @param {string} name       - view name (PascalCase)
+ * @param {{ editor?: boolean }} opts
+ * @returns {{ created: string[] }}
+ */
+export function generateView(root, name, opts = {}) {
+	const isEditor = Boolean(opts.editor);
+
+	const viewDir = path.join(root, "src", "views", name);
+	const tsAbs = path.join(viewDir, `${name}.ts`);
+	const cssAbs = path.join(viewDir, `${name}.css`);
+	const stateAbs = path.join(viewDir, "state.ts");
+	const storyAbs = path.join(root, "stories", "views", `${name}.stories.ts`);
+
+	// Check for existing files before writing any
+	if (fs.existsSync(tsAbs)) {
+		throw new Error(`already exists: ${tsAbs}`);
+	}
+
+	// Settings-block stub indented for a given base tab depth
+	const settingsBlock = (baseTabs) => {
+		const p = "\t".repeat(baseTabs);
+		return [
+			`${p}<div class="oas-settings">`,
+			`${p}\t<div class="setting-item setting-item-heading">`,
+			`${p}\t\t<div class="setting-item-info">`,
+			`${p}\t\t\t<div class="setting-item-name">${name}</div>`,
+			`${p}\t\t</div>`,
+			`${p}\t</div>`,
+			`${p}</div>`,
+		].join("\n");
+	};
+
+	const inner = isEditor
+		? `\t\t<div class="oas-readable-width">\n${settingsBlock(3)}\n\t\t</div>`
+		: settingsBlock(2);
+
+	const tsContent = `import "./${name}.css";
+import { component, html } from "@arrow-js/core";
+import type { ArrowTemplate } from "@arrow-js/core";
+
+export const ${name} = component((): ArrowTemplate => {
+\treturn html\`
+${inner}
+\t\`;
+});
+`;
+
+	const cssContent = `/* ${name} layout and chrome */\n`;
+
+	const stateContent = `import { reactive } from "@arrow-js/core";
+
+export const state = reactive({
+\t// TODO: add view state
+});
+`;
+
+	const surfaceLine = isEditor ? '\tsurface: "editor",\n' : '\tsurface: "panel",\n';
+	const storyContent = `import { ${name} } from "../../src/views/${name}/${name}";
+import { defineStories } from "../../tools/viewer/stories";
+
+export default defineStories({
+\tkind: "view",
+${surfaceLine}\tdescription: "TODO: describe ${name}.",
+\tstatus: "draft",
+\tvariants: {
+\t\tdefault: () => ${name}(),
+\t},
+});
+`;
+
+	const created = [];
+
+	writeNew(tsAbs, tsContent);
+	created.push(`src/views/${name}/${name}.ts`);
+
+	writeNew(cssAbs, cssContent);
+	created.push(`src/views/${name}/${name}.css`);
+
+	writeNew(stateAbs, stateContent);
+	created.push(`src/views/${name}/state.ts`);
+
+	writeNew(storyAbs, storyContent);
+	created.push(`stories/views/${name}.stories.ts`);
+
+	return { created };
+}
+
+// ---------------------------------------------------------------------------
+// Story generator
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a story file only (for an existing component/view).
+ *
+ * @param {string} root       - absolute project root
+ * @param {string} name       - component/view name (PascalCase)
+ * @param {{ kind?: "view"|"component" }} opts
+ * @returns {{ created: string[] }}
+ */
+export function generateStory(root, name, opts = {}) {
+	const kind = opts.kind === "view" ? "view" : "component";
+
+	let storyAbs;
+	let componentImport;
+	let kindLine;
+	let surfaceLine;
+
+	if (kind === "view") {
+		storyAbs = path.join(root, "stories", "views", `${name}.stories.ts`);
+		componentImport = `../../src/views/${name}/${name}`;
+		kindLine = '\tkind: "view",\n';
+		surfaceLine = '\tsurface: "panel",\n';
+	} else {
+		storyAbs = path.join(root, "stories", "components", `${name}.stories.ts`);
+		componentImport = `../../src/components/${name}/${name}`;
+		kindLine = "";
+		surfaceLine = "";
+	}
+
+	if (fs.existsSync(storyAbs)) {
+		throw new Error(`already exists: ${storyAbs}`);
+	}
+
+	const storyContent = `import { ${name} } from "${componentImport}";
+import { defineStories } from "../../tools/viewer/stories";
+
+export default defineStories({
+${kindLine}${surfaceLine}\tdescription: "TODO: describe ${name}.",
+\tstatus: "draft",
+\tvariants: {
+\t\tdefault: () => ${name}(),
+\t},
+});
+`;
+
+	writeNew(storyAbs, storyContent);
+
+	const relPath =
+		kind === "view" ? `stories/views/${name}.stories.ts` : `stories/components/${name}.stories.ts`;
+
+	return { created: [relPath] };
+}
+
+// ---------------------------------------------------------------------------
+// CLI registration
+// ---------------------------------------------------------------------------
+
+export function registerGenerate(program) {
+	const g = program.command("generate").description("scaffold components/views/stories");
+
+	g.command("component <name>")
+		.description("generate a component scaffold")
+		.option("--css", "add a CSS file")
+		.action((name, opts, cmd) => {
+			const json = cmd.optsWithGlobals().json;
+			try {
+				const root = resolveProjectRoot();
+				const result = generateComponent(root, name, opts);
+				emit(result, { json });
+			} catch (err) {
+				emit({ errors: [err.message] }, { json });
+				process.exit(1);
+			}
+		});
+
+	g.command("view <name>")
+		.description("generate a view scaffold")
+		.option("--editor", "wrap body in oas-readable-width for editor surface")
+		.action((name, opts, cmd) => {
+			const json = cmd.optsWithGlobals().json;
+			try {
+				const root = resolveProjectRoot();
+				const result = generateView(root, name, opts);
+				emit(result, { json });
+			} catch (err) {
+				emit({ errors: [err.message] }, { json });
+				process.exit(1);
+			}
+		});
+
+	g.command("story <name>")
+		.description("generate a story file for an existing component or view")
+		.option("--kind <kind>", "story kind: view or component (default: component)")
+		.action((name, opts, cmd) => {
+			const json = cmd.optsWithGlobals().json;
+			try {
+				const root = resolveProjectRoot();
+				const result = generateStory(root, name, opts);
+				emit(result, { json });
+			} catch (err) {
+				emit({ errors: [err.message] }, { json });
+				process.exit(1);
+			}
+		});
+}

package/src/commands/test.mjs

@@ -0,0 +1,20 @@
+import { run } from "../lib/run.mjs";
+
+/**
+ * Run the project's test script.
+ * @param {{ runner?: function }} options
+ * @returns {number} exit status from the test runner
+ */
+export function test({ runner = run } = {}) {
+	return runner("test");
+}
+
+export function registerTest(program) {
+	program
+		.command("test")
+		.description("run the project test suite")
+		.action(() => {
+			const status = test({ runner: run });
+			process.exit(status);
+		});
+}

package/src/commands/validate.mjs

@@ -0,0 +1,30 @@
+import { emit } from "../lib/emit.mjs";
+import { run } from "../lib/run.mjs";
+
+const CHECK_SCRIPTS = ["check:css", "check:scope", "check:imports", "typecheck"];
+
+/**
+ * Run all project check scripts and return a structured result.
+ * @param {{ runner?: function }} options
+ * @returns {{ ok: boolean, checks: { name: string, ok: boolean }[] }}
+ */
+export function validate({ runner = run } = {}) {
+	const checks = CHECK_SCRIPTS.map((name) => {
+		const status = runner(name);
+		return { name, ok: status === 0 };
+	});
+	const ok = checks.every((c) => c.ok);
+	return { ok, checks };
+}
+
+export function registerValidate(program) {
+	program
+		.command("validate")
+		.description("run type-check, lint, and structural checks")
+		.action((_, cmd) => {
+			const { json } = cmd.optsWithGlobals();
+			const result = validate({ runner: run });
+			emit(result, { json });
+			if (!result.ok) process.exit(1);
+		});
+}

package/src/lib/detect-pm.mjs

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const LOCK = [
+	["bun.lockb", "bun"],
+	["pnpm-lock.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["package-lock.json", "npm"],
+];
+
+export function detectPM(dir = process.cwd()) {
+	for (const [file, name] of LOCK) {
+		if (fs.existsSync(path.join(dir, file))) return { name, exec: runner(name) };
+	}
+	return { name: "npm", exec: runner("npm") };
+}
+
+function runner(name) {
+	if (name === "yarn") return ["yarn"];
+	return [name, "run"];
+}

package/src/lib/emit.mjs

@@ -0,0 +1,51 @@
+import chalk from "chalk";
+
+/**
+ * Emit a result either as machine-readable JSON or a human summary.
+ *
+ * When `json` is true, writes `JSON.stringify(data) + "\n"` to stdout.
+ * Otherwise, writes a chalk-formatted human summary: green ✓ for created
+ * files / ok statuses, red for errors.
+ */
+export function emit(data, { json = false } = {}) {
+	if (json) {
+		process.stdout.write(`${JSON.stringify(data)}\n`);
+		return;
+	}
+	process.stdout.write(`${humanize(data)}\n`);
+}
+
+function humanize(data) {
+	if (data == null) return chalk.green("✓ ok");
+
+	const lines = [];
+
+	if (Array.isArray(data.errors) && data.errors.length > 0) {
+		for (const err of data.errors) lines.push(chalk.red(`✗ ${format(err)}`));
+	}
+
+	if (Array.isArray(data.created) && data.created.length > 0) {
+		for (const file of data.created) lines.push(chalk.green(`✓ ${format(file)}`));
+	}
+
+	if (typeof data.message === "string") {
+		lines.push(chalk.green(`✓ ${data.message}`));
+	}
+
+	if (lines.length === 0) {
+		// Fall back to a readable, non-JSON key/value dump.
+		if (typeof data === "object") {
+			for (const [key, value] of Object.entries(data)) {
+				lines.push(`${chalk.dim(key)}: ${format(value)}`);
+			}
+		} else {
+			lines.push(chalk.green(`✓ ${format(data)}`));
+		}
+	}
+
+	return lines.join("\n") || chalk.green("✓ ok");
+}
+
+function format(value) {
+	return typeof value === "string" ? value : String(value);
+}

package/src/lib/project.mjs

@@ -0,0 +1,18 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Walk up from `cwd` to the nearest ancestor directory containing a
+ * `package.json`. Throws if none is found before the filesystem root.
+ * @returns {string} absolute path to the project root directory.
+ */
+export function resolveProjectRoot(cwd = process.cwd()) {
+	let dir = path.resolve(cwd);
+	while (true) {
+		if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	throw new Error("not inside a project (no package.json found)");
+}

package/src/lib/run.mjs

@@ -0,0 +1,17 @@
+import { spawnSync } from "node:child_process";
+import { detectPM } from "./detect-pm.mjs";
+
+/**
+ * Spawn `<pm> run <script> ...args` in cwd, forwarding stdio.
+ * @returns {number} the child process exit status (0 on success).
+ */
+export function run(script, args = [], { cwd = process.cwd() } = {}) {
+	const { exec } = detectPM(cwd);
+	const [command, ...prefixArgs] = exec;
+	const result = spawnSync(command, [...prefixArgs, script, ...args], {
+		cwd,
+		stdio: "inherit",
+		shell: false,
+	});
+	return result.status ?? 0;
+}