@maizzle/framework 6.0.0-rc.8 → 6.0.0

package/node_modules/maizzle/dist/commands/make/stubs/component.vue

@@ -1,7 +1,5 @@
-<script setup lang="ts">
-  defineProps({
-    //
-  })
+<script setup>
+
 </script>
 
 <template>

package/node_modules/maizzle/dist/commands/make/stubs/config.ts

@@ -1,9 +1,5 @@
 import { defineConfig } from '@maizzle/framework'
 
 export default defineConfig({
-  css: {
-    purge: true,
-    inline: true,
-    shorthand: true,
-  },
+
 })

package/node_modules/maizzle/dist/commands/make/template.mjs

@@ -19,9 +19,9 @@ async function makeTemplate(filePath) {
 		path: () => p.text({
 			message: "Directory to place it in",
 			placeholder: "./emails",
+			initialValue: "./emails",
 			validate: (value) => {
 				if (!value) return "Please enter a path.";
-				if (value[0] !== ".") return "Please enter a relative path.";
 			}
 		})
 	}, { onCancel });

package/node_modules/maizzle/dist/commands/new.mjs

@@ -3,56 +3,9 @@ import color from "picocolors";
 import * as p from "@clack/prompts";
 import { rm } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-import { detectPackageManager, installDependencies } from "nypm";
+import { execSync } from "node:child_process";
+import { installDependencies } from "nypm";
 //#region src/commands/new.ts
-const starters = [
-	{
-		label: "Default",
-		value: "maizzle/maizzle",
-		path: "gh:maizzle/maizzle#master"
-	},
-	{
-		label: "v4.x",
-		value: "maizzle/starter-v4",
-		path: "gh:maizzle/starter-v4#master"
-	},
-	{
-		label: "API",
-		value: "maizzle/starter-api",
-		path: "gh:maizzle/starter-api#main"
-	},
-	{
-		label: "AMP4Email",
-		value: "maizzle/starter-amp4email",
-		path: "gh:maizzle/starter-amp4email#master"
-	},
-	{
-		label: "Liquid",
-		value: "maizzle/starter-liquid",
-		path: "gh:maizzle/starter-liquid#master"
-	},
-	{
-		label: "Mailchimp",
-		value: "maizzle/starter-mailchimp",
-		path: "gh:maizzle/starter-mailchimp#main"
-	},
-	{
-		label: "Markdown",
-		value: "maizzle/starter-markdown",
-		path: "gh:maizzle/starter-markdown#main"
-	},
-	{
-		label: "RSS",
-		value: "maizzle/starter-rss",
-		path: "gh:maizzle/starter-rss#master"
-	},
-	{
-		label: "WordPress API",
-		value: "maizzle/starter-wordpress-api",
-		path: "gh:maizzle/starter-wordpress-api#master"
-	}
-];
 function renderHeader() {
 	const lines = [
 		" ███╗   ███╗  █████╗  ██╗ ███████╗ ███████╗ ██╗      ███████╗",
@@ -160,113 +113,71 @@ async function newProject(starterArg, dirArg, options = {}) {
 			path: () => p.text({
 				message: "Where should we create your project?",
 				placeholder: "./maizzle",
+				initialValue: "./maizzle",
 				validate: (value) => {
 					if (!value) return "Please enter a path.";
-					if (value[0] !== ".") return "Please enter a relative path.";
 					if (existsSync(value)) return "That directory already exists. Please enter a different path.";
 				}
 			}),
 			starter: async () => {
 				const starter = await p.select({
 					message: "Select a Starter",
-					initialValue: "maizzle/maizzle",
-					options: [
-						{
-							value: "maizzle/maizzle",
-							label: "Default"
-						},
-						{
-							value: "custom",
-							label: "Custom"
-						},
-						{
-							value: "maizzle6-beta",
-							label: "Maizzle 6 (beta)"
-						}
-					]
+					initialValue: "maizzle/maizzle#next",
+					options: [{
+						value: "maizzle/maizzle#next",
+						label: "Default"
+					}, {
+						value: "custom",
+						label: "Custom"
+					}]
+				});
+				if (starter === "custom") return p.text({
+					message: "Enter a GitHub `user/repo` path or a full Git repository URL.",
+					validate: (value) => {
+						if (!value) return "Please enter a value.";
+					}
 				});
-				if (starter === "maizzle6-beta") return "maizzle/maizzle#next";
-				if (starter === "custom") {
-					const customStarter = await p.select({
-						message: "Select a custom Starter",
-						initialValue: "maizzle/maizzle",
-						options: [...starters, {
-							value: "git",
-							label: "Git",
-							hint: "user/repo"
-						}]
-					});
-					if (customStarter === "git") return p.text({
-						message: "Enter a `user/repo` path or a full Git repository URL.",
-						validate: (value) => {
-							if (!value) return "Please enter a value.";
-						}
-					});
-					return customStarter;
-				}
 				return starter;
 			},
 			install: () => p.confirm({
 				message: "Install dependencies?",
 				initialValue: true
 			}),
-			pm: async ({ results }) => {
-				if (!results.install) return "npm";
-				const detected = await detectPackageManager(process.cwd()).catch(() => null);
-				return p.select({
-					message: "Select a package manager",
-					initialValue: detected?.name || "npm",
-					options: [
-						{
-							value: "npm",
-							label: "npm"
-						},
-						{
-							value: "pnpm",
-							label: "pnpm"
-						},
-						{
-							value: "yarn",
-							label: "yarn"
-						},
-						{
-							value: "bun",
-							label: "bun"
-						}
-					]
-				});
-			}
+			pm: async () => options.pm || "npm"
 		}, { onCancel: () => {
 			p.cancel("💀");
 			process.exit(0);
 		} });
 	}
-	const spinner = p.spinner();
-	spinner.start("Creating project");
-	const starter = starters.find((s) => s.value === project.starter);
-	const source = starter ? starter.path : project.starter;
-	await downloadTemplate(source.includes(":") ? source : `gh:${source}`, { dir: project.path });
-	await rm(`${project.path}/.github`, {
-		recursive: true,
-		force: true
-	});
-	spinner.stop(`Created project in ${project.path}`);
-	if (project.install) {
-		try {
-			execFileSync(project.pm, ["--version"], { stdio: "ignore" });
-		} catch {
-			p.log.error(`${project.pm} is not installed. Please install it first.`);
-			process.exit(1);
-		}
-		spinner.start("Installing dependencies");
-		const startTime = Date.now();
-		await installDependencies({
-			cwd: project.path,
-			silent: true,
-			packageManager: project.pm
-		});
-		spinner.stop(`Installed dependencies ${color.gray((Date.now() - startTime) / 1e3 + "s")}`);
+	if (project.install) try {
+		execSync(`${project.pm} --version`, { stdio: "ignore" });
+	} catch {
+		p.log.error(`${project.pm} is not installed. Please install it first.`);
+		process.exit(1);
 	}
+	await p.tasks([{
+		title: "Creating project",
+		task: async () => {
+			await downloadTemplate(project.starter.includes(":") ? project.starter : `gh:${project.starter}`, { dir: project.path });
+			await rm(`${project.path}/.github`, {
+				recursive: true,
+				force: true
+			});
+			return `Created project in ${project.path}`;
+		}
+	}, {
+		title: "Installing dependencies",
+		enabled: project.install,
+		task: async () => {
+			const startTime = Date.now();
+			await installDependencies({
+				cwd: project.path,
+				silent: true,
+				packageManager: project.pm
+			});
+			return `Installed dependencies ${color.gray((Date.now() - startTime) / 1e3 + "s")}`;
+		}
+	}]);
 	const pm = project.pm || "npm";
 	const runCmd = pm === "yarn" ? "yarn dev" : `${pm} run dev`;
 	const nextSteps = `cd ${project.path}        \n\n${project.install ? "" : `${pm} install\n\n`}${runCmd}`;

package/node_modules/maizzle/dist/index.d.mts

@@ -2,6 +2,7 @@
 interface Framework {
   serve: (options?: any) => Promise<any>;
   build: (options?: any) => Promise<any>;
+  prepare: (options?: any) => Promise<any>;
 }
 declare function bootstrap(framework?: Framework): Promise<void>;
 //#endregion

package/node_modules/maizzle/dist/index.mjs

@@ -7,20 +7,43 @@ import { Command } from "commander";
 //#region src/index.ts
 async function bootstrap(framework) {
 	const program = new Command();
-	program.name("maizzle").description("Maizzle CLI").version("1.0.0");
+	program.name("maizzle").description("Maizzle CLI").version("1.2.0");
 	if (framework) {
-		program.command("serve").description("Start the Maizzle dev server with HMR").option("-c, --config <path>", "Path to maizzle config file").option("-p, --port <number>", "Dev server port").option("--host [address]", "Expose on network").action(async (options) => {
+		program.command("serve").alias("dev").description("Start the Maizzle dev server with HMR").option("-c, --config <path>", "Path to a Maizzle config file").option("-p, --port <number>", "Dev server port").option("--host [address]", "Expose on network").action(async (options) => {
 			await framework.serve({
 				config: options.config,
 				port: options.port ? parseInt(options.port, 10) : void 0,
 				host: options.host
 			});
 		});
-		program.command("build").description("Build email templates to HTML").option("-c, --config <path>", "Path to maizzle config file").option("-o, --output <path>", "Output directory").action(async (options) => {
-			await framework.build({
-				config: options.config,
-				output: options.output
-			});
+		program.command("build").description("Build email templates to HTML").option("-c, --config <path>", "Path to a Maizzle config file").option("-o, --output <path>", "Output directory").option("--pretty", "Pretty-print HTML output").option("--minify", "Minify HTML output").option("--plaintext", "Generate plaintext versions").option("--dir <path>", "Source directory for email templates").option("--ext <extension>", "Output file extension").action(async (options) => {
+			if (options.config) {
+				await framework.build(options.config);
+				return;
+			}
+			const overrides = {};
+			if (options.output) overrides.output = {
+				...overrides.output,
+				path: options.output
+			};
+			if (options.ext) overrides.output = {
+				...overrides.output,
+				extension: options.ext
+			};
+			if (options.pretty) overrides.html = {
+				...overrides.html,
+				format: true
+			};
+			if (options.minify) overrides.html = {
+				...overrides.html,
+				minify: true
+			};
+			if (options.plaintext) overrides.plaintext = true;
+			if (options.dir) overrides.content = [`${options.dir}/**/*.{vue,md}`];
+			await framework.build(Object.keys(overrides).length ? overrides : void 0);
+		});
+		program.command("prepare").description("Generate IDE type definitions in .maizzle/").option("-c, --config <path>", "Path to a Maizzle config file").action(async (options) => {
+			await framework.prepare({ config: options.config });
 		});
 	}
 	program.command("new [starter] [directory]").description("Create a new Maizzle project").option("-i, --install", "Install dependencies").option("--pm <manager>", "Package manager to use").action(async (starter, directory, options) => {

package/node_modules/maizzle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maizzle",
-  "version": "1.0.1",
+  "version": "1.2.1",
   "description": "CLI tool for the Maizzle Email Framework",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,8 @@
   ],
   "scripts": {
     "build": "tsdown",
-    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run build",
     "dev": "vitest",
     "test": "vitest run --coverage",
     "release": "npm run build && npx np"
@@ -34,8 +35,8 @@
   "devDependencies": {
     "@types/node": "^25.2.3",
     "@vitest/coverage-v8": "^4.1.3",
-    "tsdown": "^0.21.7",
-    "typescript": "^5.9.3",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.2",
     "vitest": "^4.1.3"
   },
   "repository": {

package/node_modules/nypm/dist/cli.mjs

@@ -8,7 +8,7 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join as join$1 } from "node:path";
 var name = "nypm";
-var version = "0.6.4";
+var version = "0.6.5";
 var description = "Unified Package Manager for Node.js";
 const packageManagers = [
 	{
@@ -86,11 +86,32 @@ async function findup(cwd, match, options = {}) {
 		segments.pop();
 	}
 }
-async function readPackageJSON(cwd) {
+async function readPackageJSON(cwd, options = {}) {
 	return findup(cwd, (p) => {
 		const pkgPath = join$1(p, "package.json");
 		if (existsSync(pkgPath)) return readFile(pkgPath, "utf8").then((data) => JSON.parse(data));
-	});
+	}, options);
+}
+async function readInstalledPackageJSON(pkgName, cwd) {
+	const pkgJSONPath = await findup(cwd, (p) => {
+		const candidate = join$1(p, "node_modules", pkgName, "package.json");
+		if (existsSync(candidate)) return candidate;
+	}, { includeParentDirs: true });
+	if (!pkgJSONPath) return null;
+	try {
+		return JSON.parse(await readFile(pkgJSONPath, "utf8"));
+	} catch {
+		return null;
+	}
+}
+async function readPackageJSONFromResolver(requireFn, pkgName) {
+	let resolved;
+	try {
+		resolved = requireFn.resolve(pkgName);
+	} catch {
+		return null;
+	}
+	return readPackageJSON(resolved, { includeParentDirs: true });
 }
 function cached(fn) {
 	let v;
@@ -222,8 +243,10 @@ async function addDependency(name, options = {}) {
 		const _require = createRequire(join$1(resolvedOptions.cwd, "/_.js"));
 		for (const _name of names) {
 			const pkgName = _name.match(/^(.[^@]+)/)?.[0];
-			const pkg = await readPackageJSON(_require.resolve(pkgName));
-			if (!pkg?.peerDependencies || pkg?.name !== pkgName) continue;
+			if (!pkgName) continue;
+			let pkg = await readPackageJSONFromResolver(_require, pkgName);
+			if (pkg?.name !== pkgName) pkg = await readInstalledPackageJSON(pkgName, resolvedOptions.cwd);
+			if (!pkg?.peerDependencies) continue;
 			for (const [peerDependency, version] of Object.entries(pkg.peerDependencies)) {
 				if (pkg.peerDependenciesMeta?.[peerDependency]?.optional) continue;
 				if (existingPkg?.dependencies?.[peerDependency] || existingPkg?.devDependencies?.[peerDependency]) continue;

package/node_modules/nypm/dist/index.d.mts

@@ -1,4 +1,3 @@
-//#region src/types.d.ts
 type PackageManagerName = "npm" | "yarn" | "pnpm" | "bun" | "deno";
 type PackageManager = {
   name: PackageManagerName;
@@ -27,8 +26,6 @@ type OperationResult = {
     args: string[];
   };
 };
-//#endregion
-//#region src/package-manager.d.ts
 type DetectPackageManagerOptions = {
   /**
    * Whether to ignore the lock file
@@ -64,8 +61,6 @@ declare const packageManagers: PackageManager[];
 declare function detectPackageManager(cwd: string, options?: DetectPackageManagerOptions): Promise<(PackageManager & {
   warnings?: string[];
 }) | undefined>;
-//#endregion
-//#region src/api.d.ts
 /**
  * Installs project dependencies.
  *
@@ -172,8 +167,6 @@ declare function dlx(name: string, options?: Pick<OperationOptions, "cwd" | "env
   short?: boolean;
   packages?: string[];
 }): Promise<OperationResult>;
-//#endregion
-//#region src/cmd.d.ts
 /**
  * Get the command to install dependencies with the package manager.
  */
@@ -205,5 +198,4 @@ declare function dlxCommand(packageManager: PackageManagerName, name: string, op
   short?: boolean;
   packages?: string[];
 }): string;
-//#endregion
 export { DetectPackageManagerOptions, OperationOptions, OperationResult, PackageManager, PackageManagerName, addDependency, addDependencyCommand, addDevDependency, dedupeDependencies, detectPackageManager, dlx, dlxCommand, ensureDependencyInstalled, installDependencies, installDependenciesCommand, packageManagers, removeDependency, runScript, runScriptCommand };

package/node_modules/nypm/dist/index.mjs

@@ -13,11 +13,32 @@ async function findup(cwd, match, options = {}) {
 		segments.pop();
 	}
 }
-async function readPackageJSON(cwd) {
+async function readPackageJSON(cwd, options = {}) {
 	return findup(cwd, (p) => {
 		const pkgPath = join$1(p, "package.json");
 		if (existsSync(pkgPath)) return readFile(pkgPath, "utf8").then((data) => JSON.parse(data));
-	});
+	}, options);
+}
+async function readInstalledPackageJSON(pkgName, cwd) {
+	const pkgJSONPath = await findup(cwd, (p) => {
+		const candidate = join$1(p, "node_modules", pkgName, "package.json");
+		if (existsSync(candidate)) return candidate;
+	}, { includeParentDirs: true });
+	if (!pkgJSONPath) return null;
+	try {
+		return JSON.parse(await readFile(pkgJSONPath, "utf8"));
+	} catch {
+		return null;
+	}
+}
+async function readPackageJSONFromResolver(requireFn, pkgName) {
+	let resolved;
+	try {
+		resolved = requireFn.resolve(pkgName);
+	} catch {
+		return null;
+	}
+	return readPackageJSON(resolved, { includeParentDirs: true });
 }
 function cached(fn) {
 	let v;
@@ -307,8 +328,10 @@ async function addDependency(name, options = {}) {
 		const _require = createRequire(join$1(resolvedOptions.cwd, "/_.js"));
 		for (const _name of names) {
 			const pkgName = _name.match(/^(.[^@]+)/)?.[0];
-			const pkg = await readPackageJSON(_require.resolve(pkgName));
-			if (!pkg?.peerDependencies || pkg?.name !== pkgName) continue;
+			if (!pkgName) continue;
+			let pkg = await readPackageJSONFromResolver(_require, pkgName);
+			if (pkg?.name !== pkgName) pkg = await readInstalledPackageJSON(pkgName, resolvedOptions.cwd);
+			if (!pkg?.peerDependencies) continue;
 			for (const [peerDependency, version] of Object.entries(pkg.peerDependencies)) {
 				if (pkg.peerDependenciesMeta?.[peerDependency]?.optional) continue;
 				if (existingPkg?.dependencies?.[peerDependency] || existingPkg?.devDependencies?.[peerDependency]) continue;

package/node_modules/nypm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nypm",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "Unified Package Manager for Node.js",
   "license": "MIT",
   "repository": "unjs/nypm",
@@ -18,25 +18,25 @@
     ".": "./dist/index.mjs"
   },
   "dependencies": {
-    "citty": "^0.2.0",
+    "citty": "^0.2.2",
     "pathe": "^2.0.3",
-    "tinyexec": "^1.0.2"
+    "tinyexec": "^1.1.1"
   },
   "devDependencies": {
-    "@types/node": "^25.2.1",
-    "@typescript/native-preview": "^7.0.0-dev.20260205.1",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@types/node": "^25.6.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260424.1",
+    "@vitest/coverage-v8": "^4.1.5",
     "automd": "^0.4.3",
     "changelogen": "^0.6.2",
     "eslint-config-unjs": "^0.6.2",
-    "obuild": "^0.4.22",
-    "oxfmt": "^0.28.0",
-    "oxlint": "^1.43.0",
+    "obuild": "^0.4.33",
+    "oxfmt": "^0.46.0",
+    "oxlint": "^1.61.0",
     "pkg-types": "^2.3.0",
-    "std-env": "^3.10.0",
-    "typescript": "^5.9.3",
+    "std-env": "^4.1.0",
+    "typescript": "^6.0.3",
     "ufo": "^1.6.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.5"
   },
   "engines": {
     "node": ">=18"

package/node_modules/tinyexec/README.md

@@ -63,10 +63,11 @@ The options object can have the following properties:
 - `stdin` - `string` or another `Result` that will be used as the input to the process
 - `nodeOptions` - any valid options to node's underlying `spawn` function
 - `throwOnError` - if true, non-zero exit codes will throw an error
+- `nodePath` - if `false`, `node_modules/.bin` directories and the current node executable's directory will not be prepended to `PATH` (defaults to `true`)
 
 ### Passing a string to stdin
 
-You can pass a string to `stdin`, which is useful for whitespace-sensitive values and for secrets you shouldn’t be exposed in shell history:
+You can pass a string to `stdin`, which is useful for whitespace-sensitive values and for secrets that shouldn’t be exposed in shell history:
 
 ```ts
 const result = await x('gh', ['auth', 'login', '--with-token'], {
@@ -123,6 +124,13 @@ await x('eslint', ['.']);
 
 In this example, `eslint` will come from the locally installed `node_modules`.
 
+If you'd rather not have `node_modules/.bin` (or the directory of the current
+`node` executable) prepended to `PATH`, pass `nodePath: false`:
+
+```ts
+await x('eslint', ['.'], {nodePath: false});
+```
+
 ### Using an abort signal
 
 An abort signal can be passed to a process in order to abort it at a later

package/node_modules/tinyexec/dist/main.d.mts

@@ -1,6 +1,20 @@
 import { ChildProcess, SpawnOptions, SpawnSyncOptions } from "node:child_process";
 import { Readable } from "node:stream";
 
+//#region src/normalize.d.ts
+interface NormalizedSpawnCommand {
+  command: string;
+  args: readonly string[];
+  options: SpawnOptions;
+}
+/**
+ * Normalizes the command and arguments to work cross-platform.
+ * On Windows, this basically handles things like shebangs, calling
+ * `node_modules/.bin` commands, and escaping meta characters.
+ * On other platforms, it just returns the command and arguments as-is.
+ */
+declare function normalizeSpawnCommand(command: string, args?: readonly string[], options?: SpawnOptions): NormalizedSpawnCommand;
+//#endregion
 //#region src/non-zero-exit-error.d.ts
 declare class NonZeroExitError extends Error {
   readonly result: CommonOutputApi;
@@ -25,7 +39,7 @@ interface CommonOutputApi {
 interface OutputApi extends AsyncIterable<string>, CommonOutputApi {
   process: ChildProcess | undefined;
   get aborted(): boolean;
-  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+  pipe(command: string, args?: readonly string[], options?: Partial<PipeOptions>): Result;
   kill(signal?: KillSignal): boolean;
 }
 interface OutputApiSync extends Iterable<string>, CommonOutputApi {}
@@ -34,6 +48,7 @@ type SyncResult = Output & OutputApiSync;
 interface CommonOptions {
   timeout: number;
   throwOnError: boolean;
+  nodePath: boolean;
 }
 interface Options extends CommonOptions {
   signal: AbortSignal;
@@ -45,25 +60,25 @@ interface SyncOptions extends CommonOptions {
   nodeOptions: SpawnSyncOptions;
 }
 interface TinyExec {
-  (command: string, args?: string[], options?: Partial<Options>): Result;
+  (command: string, args?: readonly string[], options?: Partial<Options>): Result;
 }
 declare class ExecProcess implements Result {
   protected _process?: ChildProcess;
   protected _aborted: boolean;
   protected _options: Partial<Options>;
   protected _command: string;
-  protected _args: string[];
+  protected _args: readonly string[];
   protected _resolveClose?: () => void;
   protected _processClosed: Promise<void>;
   protected _thrownError?: Error;
   get process(): ChildProcess | undefined;
   get pid(): number | undefined;
   get exitCode(): number | undefined;
-  constructor(command: string, args?: string[], options?: Partial<Options>);
+  constructor(command: string, args?: readonly string[], options?: Partial<Options>);
   kill(signal?: KillSignal): boolean;
   get aborted(): boolean;
   get killed(): boolean;
-  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+  pipe(command: string, args?: readonly string[], options?: Partial<PipeOptions>): Result;
   [Symbol.asyncIterator](): AsyncIterator<string>;
   protected _waitForOutput(): Promise<Output>;
   then<TResult1 = Output, TResult2 = never>(onfulfilled?: ((value: Output) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
@@ -74,9 +89,9 @@ declare class ExecProcess implements Result {
   protected _onError: (err: Error) => void;
   protected _onClose: () => void;
 }
-declare function xSync(command: string, args?: string[], options?: Partial<SyncOptions>): SyncResult;
+declare function xSync(command: string, args?: readonly string[], options?: Partial<SyncOptions>): SyncResult;
 declare const x: TinyExec;
 declare const exec: TinyExec;
 declare const execSync: typeof xSync;
 //#endregion
-export { CommonOptions, CommonOutputApi, ExecProcess, KillSignal, NonZeroExitError, Options, Output, OutputApi, OutputApiSync, PipeOptions, Result, SyncOptions, SyncResult, TinyExec, exec, execSync, x, xSync };
+export { CommonOptions, CommonOutputApi, ExecProcess, KillSignal, NonZeroExitError, Options, Output, OutputApi, OutputApiSync, PipeOptions, Result, SyncOptions, SyncResult, TinyExec, exec, execSync, normalizeSpawnCommand, x, xSync };