tegami 1.0.2 → 1.1.1

package/dist/plugins/cargo.js

@@ -1,77 +1,502 @@
 import { n as execFailure } from "../error-BhMYq9iW.js";
-import { n as WorkspacePackage } from "../graph-gThXu8Cz.js";
+import { t as _accessExpressionAsString } from "../_accessExpressionAsString-QhbUZzwv.js";
+import { t as _assertGuard } from "../_assertGuard-BBn2NbSz.js";
+import { n as WorkspacePackage } from "../graph-BmXTJZxx.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { x } from "tinyexec";
 import * as semver$1 from "semver";
-import z from "zod";
 import { glob } from "tinyglobby";
 import initToml, { edit, parse as parse$1 } from "@rainbowatcher/toml-edit-js";
 //#region src/plugins/cargo/schema.ts
-const baseDepSchema = z.object({
-	package: z.string().optional(),
-	features: z.array(z.string()).optional(),
-	optional: z.boolean().optional(),
-	"default-features": z.boolean().optional()
-});
-/** `{ workspace = true }` — inherit from `[workspace.dependencies]` */
-const workspaceDependencySchema = baseDepSchema.extend({ workspace: z.literal(true) });
-/** `{ path = "../lib" }` — optional `version` for publishing */
-const pathDependencySchema = baseDepSchema.extend({
-	path: z.string(),
-	version: z.string().optional()
-});
-/** `{ git = "…" }` — exactly one of `branch`, `tag`, or `rev` in practice */
-const gitDependencySchema = baseDepSchema.extend({
-	git: z.string(),
-	branch: z.string().optional(),
-	tag: z.string().optional(),
-	rev: z.string().optional(),
-	version: z.string().optional()
-});
-/** `{ version = "1.0" }` — crates.io or `[registries]` */
-const registryDependencySchema = baseDepSchema.extend({
-	version: z.string(),
-	registry: z.string().optional()
-});
-/**
-* @see https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
-*/
-const cargoDependencySchema = z.union([
-	z.string(),
-	workspaceDependencySchema,
-	pathDependencySchema,
-	gitDependencySchema,
-	registryDependencySchema
-]);
-const cargoInheritSchema = z.looseObject({ workspace: z.literal(true) });
-const cargoWorkspaceSchema = z.looseObject({
-	members: z.array(z.string()).optional(),
-	exclude: z.array(z.string()).optional(),
-	package: z.looseObject({
-		version: z.string().optional(),
-		publish: z.boolean().optional()
-	}).optional(),
-	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
-	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
-	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
-});
-const cargoManifestSchema = z.looseObject({
-	package: z.looseObject({
-		name: z.string(),
-		version: z.string().or(cargoInheritSchema),
-		publish: z.boolean().or(cargoInheritSchema).optional()
-	}).optional(),
-	workspace: cargoWorkspaceSchema.optional(),
-	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
-	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
-	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
-	target: z.record(z.string(), z.looseObject({
-		dependencies: z.record(z.string(), cargoDependencySchema).optional(),
-		"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
-		"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
-	})).optional()
-});
+const assertCargoManifest = (() => {
+	const _io0 = (input) => (void 0 === input["package"] || "object" === typeof input["package"] && null !== input["package"] && _io1(input["package"])) && (void 0 === input.workspace || "object" === typeof input.workspace && null !== input.workspace && false === Array.isArray(input.workspace) && _io3(input.workspace)) && (void 0 === input.dependencies || "object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) && _io5(input.dependencies)) && (void 0 === input["dev-dependencies"] || "object" === typeof input["dev-dependencies"] && null !== input["dev-dependencies"] && false === Array.isArray(input["dev-dependencies"]) && _io5(input["dev-dependencies"])) && (void 0 === input["build-dependencies"] || "object" === typeof input["build-dependencies"] && null !== input["build-dependencies"] && false === Array.isArray(input["build-dependencies"]) && _io5(input["build-dependencies"])) && (void 0 === input.target || "object" === typeof input.target && null !== input.target && false === Array.isArray(input.target) && _io10(input.target));
+	const _io1 = (input) => "string" === typeof input.name && null !== input.version && void 0 !== input.version && ("string" === typeof input.version || "object" === typeof input.version && null !== input.version && _io2(input.version)) && null !== input.publish && (void 0 === input.publish || "boolean" === typeof input.publish || "object" === typeof input.publish && null !== input.publish && _io2(input.publish));
+	const _io2 = (input) => true === input.workspace;
+	const _io3 = (input) => (void 0 === input.members || Array.isArray(input.members) && input.members.every((elem) => "string" === typeof elem)) && (void 0 === input.exclude || Array.isArray(input.exclude) && input.exclude.every((elem) => "string" === typeof elem)) && (void 0 === input["package"] || "object" === typeof input["package"] && null !== input["package"] && false === Array.isArray(input["package"]) && _io4(input["package"])) && (void 0 === input.dependencies || "object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) && _io5(input.dependencies)) && (void 0 === input["dev-dependencies"] || "object" === typeof input["dev-dependencies"] && null !== input["dev-dependencies"] && false === Array.isArray(input["dev-dependencies"]) && _io5(input["dev-dependencies"])) && (void 0 === input["build-dependencies"] || "object" === typeof input["build-dependencies"] && null !== input["build-dependencies"] && false === Array.isArray(input["build-dependencies"]) && _io5(input["build-dependencies"]));
+	const _io4 = (input) => (void 0 === input.version || "string" === typeof input.version) && (void 0 === input.publish || "boolean" === typeof input.publish);
+	const _io5 = (input) => Object.keys(input).every((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return null !== value && void 0 !== value && ("string" === typeof value || "object" === typeof value && null !== value && _iu0(value));
+	});
+	const _io6 = (input) => true === input.workspace && (void 0 === input["package"] || "string" === typeof input["package"]) && (void 0 === input.features || Array.isArray(input.features) && input.features.every((elem) => "string" === typeof elem)) && (void 0 === input.optional || "boolean" === typeof input.optional) && (void 0 === input["default-features"] || "boolean" === typeof input["default-features"]);
+	const _io7 = (input) => "string" === typeof input.path && (void 0 === input.version || "string" === typeof input.version) && (void 0 === input["package"] || "string" === typeof input["package"]) && (void 0 === input.features || Array.isArray(input.features) && input.features.every((elem) => "string" === typeof elem)) && (void 0 === input.optional || "boolean" === typeof input.optional) && (void 0 === input["default-features"] || "boolean" === typeof input["default-features"]);
+	const _io8 = (input) => "string" === typeof input.git && (void 0 === input.branch || "string" === typeof input.branch) && (void 0 === input.tag || "string" === typeof input.tag) && (void 0 === input.rev || "string" === typeof input.rev) && (void 0 === input.version || "string" === typeof input.version) && (void 0 === input["package"] || "string" === typeof input["package"]) && (void 0 === input.features || Array.isArray(input.features) && input.features.every((elem) => "string" === typeof elem)) && (void 0 === input.optional || "boolean" === typeof input.optional) && (void 0 === input["default-features"] || "boolean" === typeof input["default-features"]);
+	const _io9 = (input) => "string" === typeof input.version && (void 0 === input.registry || "string" === typeof input.registry) && (void 0 === input["package"] || "string" === typeof input["package"]) && (void 0 === input.features || Array.isArray(input.features) && input.features.every((elem) => "string" === typeof elem)) && (void 0 === input.optional || "boolean" === typeof input.optional) && (void 0 === input["default-features"] || "boolean" === typeof input["default-features"]);
+	const _io10 = (input) => Object.keys(input).every((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return "object" === typeof value && null !== value && false === Array.isArray(value) && _io11(value);
+	});
+	const _io11 = (input) => (void 0 === input.dependencies || "object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) && _io5(input.dependencies)) && (void 0 === input["dev-dependencies"] || "object" === typeof input["dev-dependencies"] && null !== input["dev-dependencies"] && false === Array.isArray(input["dev-dependencies"]) && _io5(input["dev-dependencies"])) && (void 0 === input["build-dependencies"] || "object" === typeof input["build-dependencies"] && null !== input["build-dependencies"] && false === Array.isArray(input["build-dependencies"]) && _io5(input["build-dependencies"]));
+	const _iu0 = (input) => (() => {
+		if (void 0 !== input.workspace) return _io6(input);
+		else if (void 0 !== input.path) return _io7(input);
+		else if (void 0 !== input.git) return _io8(input);
+		else return _io9(input);
+	})();
+	const _ao0 = (input, _path, _exceptionable = true) => (void 0 === input["package"] || ("object" === typeof input["package"] && null !== input["package"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"package\"]",
+		expected: "(__type | undefined)",
+		value: input["package"]
+	}, _errorFactory)) && _ao1(input["package"], _path + "[\"package\"]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"package\"]",
+		expected: "(__type | undefined)",
+		value: input["package"]
+	}, _errorFactory)) && (void 0 === input.workspace || ("object" === typeof input.workspace && null !== input.workspace && false === Array.isArray(input.workspace) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".workspace",
+		expected: "(CargoWorkspace | undefined)",
+		value: input.workspace
+	}, _errorFactory)) && _ao3(input.workspace, _path + ".workspace", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".workspace",
+		expected: "(CargoWorkspace | undefined)",
+		value: input.workspace
+	}, _errorFactory)) && (void 0 === input.dependencies || ("object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependencies",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input.dependencies
+	}, _errorFactory)) && _ao5(input.dependencies, _path + ".dependencies", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependencies",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input.dependencies
+	}, _errorFactory)) && (void 0 === input["dev-dependencies"] || ("object" === typeof input["dev-dependencies"] && null !== input["dev-dependencies"] && false === Array.isArray(input["dev-dependencies"]) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"dev-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["dev-dependencies"]
+	}, _errorFactory)) && _ao5(input["dev-dependencies"], _path + "[\"dev-dependencies\"]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"dev-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["dev-dependencies"]
+	}, _errorFactory)) && (void 0 === input["build-dependencies"] || ("object" === typeof input["build-dependencies"] && null !== input["build-dependencies"] && false === Array.isArray(input["build-dependencies"]) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"build-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["build-dependencies"]
+	}, _errorFactory)) && _ao5(input["build-dependencies"], _path + "[\"build-dependencies\"]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"build-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["build-dependencies"]
+	}, _errorFactory)) && (void 0 === input.target || ("object" === typeof input.target && null !== input.target && false === Array.isArray(input.target) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".target",
+		expected: "(Record<string, CargoTargetSection> | undefined)",
+		value: input.target
+	}, _errorFactory)) && _ao10(input.target, _path + ".target", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".target",
+		expected: "(Record<string, CargoTargetSection> | undefined)",
+		value: input.target
+	}, _errorFactory));
+	const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.name || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".name",
+		expected: "string",
+		value: input.name
+	}, _errorFactory)) && (null !== input.version || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "(CargoInherit | string)",
+		value: input.version
+	}, _errorFactory)) && (void 0 !== input.version || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "(CargoInherit | string)",
+		value: input.version
+	}, _errorFactory)) && ("string" === typeof input.version || ("object" === typeof input.version && null !== input.version || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "(CargoInherit | string)",
+		value: input.version
+	}, _errorFactory)) && _ao2(input.version, _path + ".version", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "(CargoInherit | string)",
+		value: input.version
+	}, _errorFactory)) && (null !== input.publish || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".publish",
+		expected: "(CargoInherit | boolean | undefined)",
+		value: input.publish
+	}, _errorFactory)) && (void 0 === input.publish || "boolean" === typeof input.publish || ("object" === typeof input.publish && null !== input.publish || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".publish",
+		expected: "(CargoInherit | boolean | undefined)",
+		value: input.publish
+	}, _errorFactory)) && _ao2(input.publish, _path + ".publish", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".publish",
+		expected: "(CargoInherit | boolean | undefined)",
+		value: input.publish
+	}, _errorFactory));
+	const _ao2 = (input, _path, _exceptionable = true) => true === input.workspace || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".workspace",
+		expected: "true",
+		value: input.workspace
+	}, _errorFactory);
+	const _ao3 = (input, _path, _exceptionable = true) => (void 0 === input.members || (Array.isArray(input.members) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".members",
+		expected: "(Array<string> | undefined)",
+		value: input.members
+	}, _errorFactory)) && input.members.every((elem, _index7) => "string" === typeof elem || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".members[" + _index7 + "]",
+		expected: "string",
+		value: elem
+	}, _errorFactory)) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".members",
+		expected: "(Array<string> | undefined)",
+		value: input.members
+	}, _errorFactory)) && (void 0 === input.exclude || (Array.isArray(input.exclude) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".exclude",
+		expected: "(Array<string> | undefined)",
+		value: input.exclude
+	}, _errorFactory)) && input.exclude.every((elem, _index8) => "string" === typeof elem || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".exclude[" + _index8 + "]",
+		expected: "string",
+		value: elem
+	}, _errorFactory)) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".exclude",
+		expected: "(Array<string> | undefined)",
+		value: input.exclude
+	}, _errorFactory)) && (void 0 === input["package"] || ("object" === typeof input["package"] && null !== input["package"] && false === Array.isArray(input["package"]) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"package\"]",
+		expected: "(__type.o1 | undefined)",
+		value: input["package"]
+	}, _errorFactory)) && _ao4(input["package"], _path + "[\"package\"]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"package\"]",
+		expected: "(__type.o1 | undefined)",
+		value: input["package"]
+	}, _errorFactory)) && (void 0 === input.dependencies || ("object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependencies",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input.dependencies
+	}, _errorFactory)) && _ao5(input.dependencies, _path + ".dependencies", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependencies",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input.dependencies
+	}, _errorFactory)) && (void 0 === input["dev-dependencies"] || ("object" === typeof input["dev-dependencies"] && null !== input["dev-dependencies"] && false === Array.isArray(input["dev-dependencies"]) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"dev-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["dev-dependencies"]
+	}, _errorFactory)) && _ao5(input["dev-dependencies"], _path + "[\"dev-dependencies\"]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"dev-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["dev-dependencies"]
+	}, _errorFactory)) && (void 0 === input["build-dependencies"] || ("object" === typeof input["build-dependencies"] && null !== input["build-dependencies"] && false === Array.isArray(input["build-dependencies"]) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"build-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["build-dependencies"]
+	}, _errorFactory)) && _ao5(input["build-dependencies"], _path + "[\"build-dependencies\"]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"build-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["build-dependencies"]
+	}, _errorFactory));
+	const _ao4 = (input, _path, _exceptionable = true) => (void 0 === input.version || "string" === typeof input.version || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "(string | undefined)",
+		value: input.version
+	}, _errorFactory)) && (void 0 === input.publish || "boolean" === typeof input.publish || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".publish",
+		expected: "(boolean | undefined)",
+		value: input.publish
+	}, _errorFactory));
+	const _ao5 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return (null !== value || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "(CargoGitDependency | CargoPathDependency | CargoRegistryDependency | CargoWorkspaceDependency | string)",
+			value
+		}, _errorFactory)) && (void 0 !== value || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "(CargoGitDependency | CargoPathDependency | CargoRegistryDependency | CargoWorkspaceDependency | string)",
+			value
+		}, _errorFactory)) && ("string" === typeof value || ("object" === typeof value && null !== value || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "(CargoGitDependency | CargoPathDependency | CargoRegistryDependency | CargoWorkspaceDependency | string)",
+			value
+		}, _errorFactory)) && _au0(value, _path + _accessExpressionAsString(key), _exceptionable) || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "(CargoGitDependency | CargoPathDependency | CargoRegistryDependency | CargoWorkspaceDependency | string)",
+			value
+		}, _errorFactory));
+	});
+	const _ao6 = (input, _path, _exceptionable = true) => (true === input.workspace || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".workspace",
+		expected: "true",
+		value: input.workspace
+	}, _errorFactory)) && (void 0 === input["package"] || "string" === typeof input["package"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"package\"]",
+		expected: "(string | undefined)",
+		value: input["package"]
+	}, _errorFactory)) && (void 0 === input.features || (Array.isArray(input.features) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features",
+		expected: "(Array<string> | undefined)",
+		value: input.features
+	}, _errorFactory)) && input.features.every((elem, _index9) => "string" === typeof elem || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features[" + _index9 + "]",
+		expected: "string",
+		value: elem
+	}, _errorFactory)) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features",
+		expected: "(Array<string> | undefined)",
+		value: input.features
+	}, _errorFactory)) && (void 0 === input.optional || "boolean" === typeof input.optional || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".optional",
+		expected: "(boolean | undefined)",
+		value: input.optional
+	}, _errorFactory)) && (void 0 === input["default-features"] || "boolean" === typeof input["default-features"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"default-features\"]",
+		expected: "(boolean | undefined)",
+		value: input["default-features"]
+	}, _errorFactory));
+	const _ao7 = (input, _path, _exceptionable = true) => ("string" === typeof input.path || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".path",
+		expected: "string",
+		value: input.path
+	}, _errorFactory)) && (void 0 === input.version || "string" === typeof input.version || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "(string | undefined)",
+		value: input.version
+	}, _errorFactory)) && (void 0 === input["package"] || "string" === typeof input["package"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"package\"]",
+		expected: "(string | undefined)",
+		value: input["package"]
+	}, _errorFactory)) && (void 0 === input.features || (Array.isArray(input.features) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features",
+		expected: "(Array<string> | undefined)",
+		value: input.features
+	}, _errorFactory)) && input.features.every((elem, _index10) => "string" === typeof elem || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features[" + _index10 + "]",
+		expected: "string",
+		value: elem
+	}, _errorFactory)) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features",
+		expected: "(Array<string> | undefined)",
+		value: input.features
+	}, _errorFactory)) && (void 0 === input.optional || "boolean" === typeof input.optional || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".optional",
+		expected: "(boolean | undefined)",
+		value: input.optional
+	}, _errorFactory)) && (void 0 === input["default-features"] || "boolean" === typeof input["default-features"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"default-features\"]",
+		expected: "(boolean | undefined)",
+		value: input["default-features"]
+	}, _errorFactory));
+	const _ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input.git || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".git",
+		expected: "string",
+		value: input.git
+	}, _errorFactory)) && (void 0 === input.branch || "string" === typeof input.branch || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".branch",
+		expected: "(string | undefined)",
+		value: input.branch
+	}, _errorFactory)) && (void 0 === input.tag || "string" === typeof input.tag || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".tag",
+		expected: "(string | undefined)",
+		value: input.tag
+	}, _errorFactory)) && (void 0 === input.rev || "string" === typeof input.rev || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".rev",
+		expected: "(string | undefined)",
+		value: input.rev
+	}, _errorFactory)) && (void 0 === input.version || "string" === typeof input.version || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "(string | undefined)",
+		value: input.version
+	}, _errorFactory)) && (void 0 === input["package"] || "string" === typeof input["package"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"package\"]",
+		expected: "(string | undefined)",
+		value: input["package"]
+	}, _errorFactory)) && (void 0 === input.features || (Array.isArray(input.features) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features",
+		expected: "(Array<string> | undefined)",
+		value: input.features
+	}, _errorFactory)) && input.features.every((elem, _index11) => "string" === typeof elem || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features[" + _index11 + "]",
+		expected: "string",
+		value: elem
+	}, _errorFactory)) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features",
+		expected: "(Array<string> | undefined)",
+		value: input.features
+	}, _errorFactory)) && (void 0 === input.optional || "boolean" === typeof input.optional || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".optional",
+		expected: "(boolean | undefined)",
+		value: input.optional
+	}, _errorFactory)) && (void 0 === input["default-features"] || "boolean" === typeof input["default-features"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"default-features\"]",
+		expected: "(boolean | undefined)",
+		value: input["default-features"]
+	}, _errorFactory));
+	const _ao9 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "string",
+		value: input.version
+	}, _errorFactory)) && (void 0 === input.registry || "string" === typeof input.registry || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".registry",
+		expected: "(string | undefined)",
+		value: input.registry
+	}, _errorFactory)) && (void 0 === input["package"] || "string" === typeof input["package"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"package\"]",
+		expected: "(string | undefined)",
+		value: input["package"]
+	}, _errorFactory)) && (void 0 === input.features || (Array.isArray(input.features) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features",
+		expected: "(Array<string> | undefined)",
+		value: input.features
+	}, _errorFactory)) && input.features.every((elem, _index12) => "string" === typeof elem || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features[" + _index12 + "]",
+		expected: "string",
+		value: elem
+	}, _errorFactory)) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".features",
+		expected: "(Array<string> | undefined)",
+		value: input.features
+	}, _errorFactory)) && (void 0 === input.optional || "boolean" === typeof input.optional || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".optional",
+		expected: "(boolean | undefined)",
+		value: input.optional
+	}, _errorFactory)) && (void 0 === input["default-features"] || "boolean" === typeof input["default-features"] || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"default-features\"]",
+		expected: "(boolean | undefined)",
+		value: input["default-features"]
+	}, _errorFactory));
+	const _ao10 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return ("object" === typeof value && null !== value && false === Array.isArray(value) || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "CargoTargetSection",
+			value
+		}, _errorFactory)) && _ao11(value, _path + _accessExpressionAsString(key), _exceptionable) || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "CargoTargetSection",
+			value
+		}, _errorFactory);
+	});
+	const _ao11 = (input, _path, _exceptionable = true) => (void 0 === input.dependencies || ("object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependencies",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input.dependencies
+	}, _errorFactory)) && _ao5(input.dependencies, _path + ".dependencies", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependencies",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input.dependencies
+	}, _errorFactory)) && (void 0 === input["dev-dependencies"] || ("object" === typeof input["dev-dependencies"] && null !== input["dev-dependencies"] && false === Array.isArray(input["dev-dependencies"]) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"dev-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["dev-dependencies"]
+	}, _errorFactory)) && _ao5(input["dev-dependencies"], _path + "[\"dev-dependencies\"]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"dev-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["dev-dependencies"]
+	}, _errorFactory)) && (void 0 === input["build-dependencies"] || ("object" === typeof input["build-dependencies"] && null !== input["build-dependencies"] && false === Array.isArray(input["build-dependencies"]) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"build-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["build-dependencies"]
+	}, _errorFactory)) && _ao5(input["build-dependencies"], _path + "[\"build-dependencies\"]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + "[\"build-dependencies\"]",
+		expected: "(Record<string, CargoDependency> | undefined)",
+		value: input["build-dependencies"]
+	}, _errorFactory));
+	const _au0 = (input, _path, _exceptionable = true) => (() => {
+		if (void 0 !== input.workspace) return _ao6(input, _path, _exceptionable);
+		else if (void 0 !== input.path) return _ao7(input, _path, _exceptionable);
+		else if (void 0 !== input.git) return _ao8(input, _path, _exceptionable);
+		else return _ao9(input, _path, _exceptionable);
+	})();
+	const __is = (input) => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
+	let _errorFactory;
+	return (input, errorFactory) => {
+		if (false === __is(input)) {
+			_errorFactory = errorFactory;
+			((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _assertGuard(true, {
+				method: "typia.createAssert",
+				path: _path + "",
+				expected: "CargoManifest",
+				value: input
+			}, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard(true, {
+				method: "typia.createAssert",
+				path: _path + "",
+				expected: "CargoManifest",
+				value: input
+			}, _errorFactory))(input, "$input", true);
+		}
+		return input;
+	};
+})();
 //#endregion
 //#region src/plugins/cargo.ts
 const DEP_FIELDS = [
@@ -79,17 +504,33 @@ const DEP_FIELDS = [
 	"dev-dependencies",
 	"build-dependencies"
 ];
+var CargoToml = class {
+	path;
+	content;
+	data;
+	dependencies;
+	workspace;
+	constructor(path, content, data) {
+		this.path = path;
+		this.content = content;
+		this.data = data;
+	}
+	listDependencies(graph) {
+		return this.dependencies ??= listDependencies(graph, this);
+	}
+	patch(path, value) {
+		this.content = edit(this.content, path, value);
+	}
+};
 var CargoPackage = class extends WorkspacePackage {
 	path;
 	file;
-	workspaceFile;
 	manager = "cargo";
 	manifest;
-	constructor(path, file, workspaceFile) {
+	constructor(path, file) {
 		super();
 		this.path = path;
 		this.file = file;
-		this.workspaceFile = workspaceFile;
 		this.manifest = file.data;
 	}
 	get name() {
@@ -98,7 +539,7 @@ var CargoPackage = class extends WorkspacePackage {
 	get version() {
 		const packageVersion = this.manifest.package.version;
 		if (typeof packageVersion === "string") return packageVersion;
-		const inherited = this.workspaceFile?.data.workspace.package;
+		const inherited = this.file.workspace?.data.workspace.package;
 		if (packageVersion.workspace && inherited?.version) return inherited.version;
 		throw new Error(`Invalid Cargo.toml in "${this.path}".`);
 	}
@@ -106,20 +547,17 @@ var CargoPackage = class extends WorkspacePackage {
 		const packageInfo = this.manifest.package;
 		if (typeof packageInfo.version === "string") {
 			packageInfo.version = version;
-			patchFile(this.file, "package.version", version);
+			this.file.patch("package.version", version);
 			return;
 		}
-		if (packageInfo.version.workspace && this.workspaceFile?.data.workspace.package) {
-			this.workspaceFile.data.workspace.package.version = version;
-			patchFile(this.workspaceFile, "workspace.package.version", version);
+		if (packageInfo.version.workspace && this.file.workspace?.data.workspace.package) {
+			this.file.workspace.data.workspace.package.version = version;
+			this.file.workspace.patch("workspace.package.version", version);
 			return;
 		}
 		throw new Error(`Invalid Cargo.toml in "${this.path}".`);
 	}
 };
-function patchFile(file, path, value) {
-	file.content = edit(file.content, path, value);
-}
 function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 	return {
 		name: "cargo",
@@ -141,13 +579,9 @@ function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 			if (!(pkg instanceof CargoPackage) || !this.cargo) return;
 			let shouldPublish = true;
 			if (typeof pkg.manifest.package.publish === "boolean") shouldPublish = pkg.manifest.package.publish;
-			else if (pkg.manifest.package.publish?.workspace) shouldPublish = pkg.workspaceFile?.data.workspace?.package?.publish ?? shouldPublish;
+			else if (pkg.manifest.package.publish?.workspace) shouldPublish = pkg.file.workspace?.data.workspace?.package?.publish ?? shouldPublish;
 			const wait = [];
-			for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [rawName, spec] of Object.entries(table)) {
-				const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, this.cargo.graph, tablePath, rawName, spec);
-				if (!resolved) continue;
-				wait.push(resolved.linked.id);
-			}
+			for (const { resolved } of pkg.file.listDependencies(this.cargo.graph)) if (resolved) wait.push(resolved.id);
 			return {
 				shouldPublish,
 				wait
@@ -181,14 +615,13 @@ function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
 				if (bumped) pkg.setVersion(bumped);
 			}
-			for (const pkg of graph.packages.values()) for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [rawName, spec] of Object.entries(table)) {
-				const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, graph, tablePath, rawName, spec);
-				if (!resolved || !resolved.range || !resolved.setRange || semver$1.satisfies(resolved.linked.version, resolved.range)) continue;
+			for (const file of graph.files.values()) for (const { range, resolved, setRange } of file.listDependencies(graph)) {
+				if (!resolved || !range || !setRange || semver$1.satisfies(resolved.version, range)) continue;
 				let updatedRange;
-				if (resolved.range.startsWith("^")) updatedRange = `^${resolved.linked.version}`;
-				else if (resolved.range.startsWith("~")) updatedRange = `~${resolved.linked.version}`;
-				else updatedRange = resolved.linked.version;
-				table[rawName] = resolved.setRange(updatedRange);
+				if (range.startsWith("^")) updatedRange = `^${resolved.version}`;
+				else if (range.startsWith("~")) updatedRange = `~${resolved.version}`;
+				else updatedRange = resolved.version;
+				setRange(updatedRange);
 			}
 			await Promise.all(Array.from(graph.files.values(), (file) => writeFile(file.path, file.content + "\n")));
 		},
@@ -199,7 +632,7 @@ function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 		}
 	};
 }
-function depsPolicy({ graph, cargo }, getBumpDepType = ({ kind }) => {
+function depsPolicy({ cargo }, getBumpDepType = ({ kind }) => {
 	switch (kind) {
 		case "dependencies": return "patch";
 		case "build-dependencies":
@@ -208,25 +641,24 @@ function depsPolicy({ graph, cargo }, getBumpDepType = ({ kind }) => {
 }) {
 	const cargoGraph = cargo.graph;
 	const dependentMap = /* @__PURE__ */ new Map();
-	for (const pkg of cargoGraph.packages.values()) for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [name, spec] of Object.entries(table)) {
-		const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, cargoGraph, tablePath, name, spec);
+	for (const pkg of cargoGraph.packages.values()) for (const { resolved, path, spec, range } of pkg.file.listDependencies(cargoGraph)) {
 		if (!resolved) continue;
-		const id = resolved.linked.id;
-		const refs = dependentMap.get(id);
-		const kind = tablePath.at(-1);
+		const refs = dependentMap.get(resolved.id);
+		const kind = path[path.length - 2];
+		const name = path[path.length - 1];
 		if (refs) refs.push({
 			dependent: pkg,
 			kind,
 			name,
 			spec,
-			version: resolved.range
+			version: range
 		});
-		else dependentMap.set(id, [{
+		else dependentMap.set(resolved.id, [{
 			dependent: pkg,
 			kind,
 			name,
 			spec,
-			version: resolved.range
+			version: range
 		}]);
 	}
 	return {
@@ -235,11 +667,10 @@ function depsPolicy({ graph, cargo }, getBumpDepType = ({ kind }) => {
 			if (!(pkg instanceof CargoPackage)) return;
 			const deps = dependentMap.get(pkg.id);
 			if (!deps) return;
-			const group = graph.getPackageGroup(pkg.id);
 			const bumped = plan.bumpVersion(pkg);
 			if (!bumped) return;
 			for (const dep of deps) {
-				if (group?.options.syncBump && graph.getPackageGroup(dep.dependent.id) === group) continue;
+				if (pkg.group?.options.syncBump && dep.dependent.group === pkg.group) continue;
 				if (dep.version && semver$1.satisfies(bumped, dep.version)) continue;
 				const bumpType = getBumpDepType(dep);
 				if (bumpType === false) continue;
@@ -261,11 +692,7 @@ async function buildEntry(dir) {
 	try {
 		const filePath = path.join(dir, "Cargo.toml");
 		const content = await readFile(filePath, "utf8");
-		return {
-			path: filePath,
-			data: cargoManifestSchema.parse(parse$1(content)),
-			content
-		};
+		return new CargoToml(filePath, content, assertCargoManifest(parse$1(content)));
 	} catch {
 		return;
 	}
@@ -277,21 +704,23 @@ async function resolveCargoGraph(cwd) {
 	};
 	const root = await buildEntry(cwd);
 	if (!root) return out;
-	const rootWorkspace = root.data.workspace;
 	out.files.set(root.path, root);
 	if (root.data.package) {
-		const pkg = new CargoPackage(cwd, root, rootWorkspace ? root : void 0);
+		const pkg = new CargoPackage(cwd, root);
 		out.packages.set(pkg.name, pkg);
 	}
-	if (!rootWorkspace || !rootWorkspace.members) return out;
-	const dirs = await expandWorkspaceMembers(cwd, rootWorkspace.members, rootWorkspace.exclude);
-	await Promise.all(dirs.map(async (dir) => {
-		const entry = await buildEntry(dir);
-		if (!entry || !entry.data.package) return;
-		const pkg = new CargoPackage(dir, entry, root);
-		out.files.set(entry.path, entry);
-		out.packages.set(pkg.name, pkg);
-	}));
+	if (root.data.workspace?.members) {
+		root.workspace = root;
+		const dirs = await expandWorkspaceMembers(cwd, root.data.workspace.members, root.data.workspace.exclude);
+		await Promise.all(dirs.map(async (dir) => {
+			const entry = await buildEntry(dir);
+			if (!entry || !entry.data.package) return;
+			entry.workspace = root;
+			const pkg = new CargoPackage(dir, entry);
+			out.files.set(entry.path, entry);
+			out.packages.set(pkg.name, pkg);
+		}));
+	}
 	return out;
 }
 async function expandWorkspaceMembers(cwd, members, exclude = []) {
@@ -307,41 +736,41 @@ async function expandWorkspaceMembers(cwd, members, exclude = []) {
 		return item.endsWith(path.sep) ? item.slice(0, -1) : item;
 	});
 }
-function dependencyTables(manifest, prefix = []) {
-	const tables = [];
-	for (const field of DEP_FIELDS) {
-		const table = manifest[field];
-		if (!table) continue;
-		tables.push({
-			table,
-			tablePath: [...prefix, field]
-		});
-	}
-	const target = manifest.target;
-	if (target) for (const [targetKey, targetConfig] of Object.entries(target)) for (const field of DEP_FIELDS) {
-		const table = targetConfig[field];
-		if (!table) continue;
-		tables.push({
-			table,
-			tablePath: [
-				...prefix,
-				"target",
-				targetKey,
-				field
-			]
-		});
+function listDependencies(graph, file) {
+	const out = [];
+	function scan(obj, prefix = []) {
+		for (const field of DEP_FIELDS) {
+			const table = obj[field];
+			if (!table) continue;
+			const tablePath = [...prefix, field];
+			for (const [key, spec] of Object.entries(table)) {
+				const { linked, range, setRange } = resolveLinkedDep(file, graph, tablePath, key, spec) ?? {};
+				out.push({
+					path: [...tablePath, key],
+					spec,
+					resolved: linked,
+					range,
+					setRange: setRange && ((v) => {
+						table[key] = setRange(v);
+					})
+				});
+			}
+		}
 	}
-	return tables;
+	scan(file.data);
+	if (file.data.target) for (const [key, config] of Object.entries(file.data.target)) scan(config, ["target", key]);
+	if (file.data.workspace) scan(file.data.workspace);
+	return out;
 }
-function resolveLinkedDep(workspaceFile, file, graph, tablePath, rawName, spec) {
+function resolveLinkedDep(file, graph, tablePath, key, spec) {
 	if (typeof spec === "string") {
-		const linked = graph.packages.get(rawName);
+		const linked = graph.packages.get(key);
 		if (!linked) return;
 		return {
 			linked,
 			range: spec,
 			setRange(v) {
-				patchFile(file, [...tablePath, rawName].join("."), v);
+				file.patch([...tablePath, key].join("."), v);
 				return v;
 			}
 		};
@@ -349,17 +778,12 @@ function resolveLinkedDep(workspaceFile, file, graph, tablePath, rawName, spec)
 	if ("git" in spec) return;
 	if ("workspace" in spec) {
 		const kind = tablePath[tablePath.length - 1];
-		const entry = workspaceFile?.data.workspace?.[kind]?.[rawName];
+		const entry = file.workspace?.data.workspace?.[kind]?.[key];
 		if (!entry) return;
-		const resolved = resolveLinkedDep(void 0, workspaceFile, graph, ["workspace", kind], rawName, entry);
-		if (!resolved || !resolved.setRange) return resolved;
-		return {
-			...resolved,
-			setRange(v) {
-				workspaceFile.data.workspace[kind][rawName] = resolved.setRange(v);
-				return spec;
-			}
-		};
+		const resolved = resolveLinkedDep(file.workspace, graph, ["workspace", kind], key, entry);
+		if (!resolved) return;
+		delete resolved.setRange;
+		return resolved;
 	}
 	if ("path" in spec) {
 		const pkgPath = path.resolve(path.dirname(file.path), spec.path);
@@ -369,9 +793,9 @@ function resolveLinkedDep(workspaceFile, file, graph, tablePath, rawName, spec)
 				linked: pkg,
 				range: spec.version,
 				setRange(v) {
-					patchFile(file, [
+					file.patch([
 						...tablePath,
-						rawName,
+						key,
 						"version"
 					].join("."), v);
 					return {
@@ -383,15 +807,15 @@ function resolveLinkedDep(workspaceFile, file, graph, tablePath, rawName, spec)
 		}
 		return;
 	}
-	const linked = graph.packages.get(spec.package ?? rawName);
+	const linked = graph.packages.get(spec.package ?? key);
 	if (!linked) return;
 	return {
 		linked,
 		range: spec.version,
 		setRange(v) {
-			patchFile(file, [
+			file.patch([
 				...tablePath,
-				rawName,
+				key,
 				"version"
 			].join("."), v);
 			return {