tegami 1.1.0 → 1.1.2

package/dist/plugins/cargo.d.ts

@@ -1,2 +1,2 @@
-import { C as CargoPackage, S as CargoGraph, T as cargo, w as CargoPluginOptions } from "../types-BoQR7Hlg.js";
+import { D as cargo, E as CargoPluginOptions, T as CargoPackage, w as CargoGraph } from "../types-B50RK1rR.js";
 export { CargoGraph, CargoPackage, CargoPluginOptions, cargo };

package/dist/plugins/cargo.js

@@ -1,77 +1,502 @@
 import { n as execFailure } from "../error-BhMYq9iW.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 = [
@@ -267,7 +692,7 @@ async function buildEntry(dir) {
 	try {
 		const filePath = path.join(dir, "Cargo.toml");
 		const content = await readFile(filePath, "utf8");
-		return new CargoToml(filePath, content, cargoManifestSchema.parse(parse$1(content)));
+		return new CargoToml(filePath, content, assertCargoManifest(parse$1(content)));
 	} catch {
 		return;
 	}

package/dist/plugins/git.d.ts

@@ -1,4 +1,4 @@
-import { s as TegamiPlugin } from "../types-BoQR7Hlg.js";
+import { s as TegamiPlugin } from "../types-B50RK1rR.js";
 
 //#region src/plugins/git.d.ts
 interface GitPluginOptions {

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { O as WorkspacePackage, k as Draft, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-BoQR7Hlg.js";
+import { A as WorkspacePackage, b as TegamiContext, j as Draft, s as TegamiPlugin, t as Awaitable, v as PublishPlan } from "../types-B50RK1rR.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts