tegami 1.0.2 → 1.1.1

package/dist/_accessExpressionAsString-QhbUZzwv.js

@@ -0,0 +1,44 @@
+//#region ../../node_modules/.pnpm/typia@12.1.1_@types+node@26.0.1_typescript@6.0.3/node_modules/typia/lib/internal/_accessExpressionAsString.mjs
+const _accessExpressionAsString = (str) => variable(str) ? `.${str}` : `[${JSON.stringify(str)}]`;
+const variable = (str) => reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+const reserved = (str) => RESERVED.has(str);
+const RESERVED = /* @__PURE__ */ new Set([
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with"
+]);
+//#endregion
+export { _accessExpressionAsString as t };

package/dist/_assertGuard-BBn2NbSz.js

@@ -0,0 +1,91 @@
+//#region ../../node_modules/.pnpm/typia@12.1.1_@types+node@26.0.1_typescript@6.0.3/node_modules/typia/lib/TypeGuardError.mjs
+/**
+* Error thrown when type assertion fails.
+*
+* Thrown by {@link assert}, {@link assertGuard}, and other assert-family
+* functions when input doesn't match expected type `T`. Contains detailed
+* information about the first assertion failure:
+*
+* - `method`: Which typia function threw (e.g., `"typia.assert"`)
+* - `path`: Property path where error occurred (e.g., `"input.user.age"`)
+* - `expected`: Expected type string (e.g., `"number & ExclusiveMinimum<19>"`)
+* - `value`: Actual value that failed validation
+*
+* @template T Expected type (for type safety)
+*/
+var TypeGuardError = class extends Error {
+	/**
+	* Name of the typia method that threw this error.
+	*
+	* E.g., `"typia.assert"`, `"typia.assertEquals"`, `"typia.assertGuard"`.
+	*/
+	method;
+	/**
+	* Property path where assertion failed.
+	*
+	* Uses dot notation for nested properties. `undefined` if error occurred at
+	* root level.
+	*
+	* E.g., `"input.age"`, `"input.profile.email"`, `"input[0].name"`.
+	*/
+	path;
+	/**
+	* String representation of expected type.
+	*
+	* E.g., `"string"`, `"number & ExclusiveMinimum<19>"`, `"{ name: string; age:
+	* number }"`.
+	*/
+	expected;
+	/**
+	* Actual value that failed assertion.
+	*
+	* The raw value at the error path, useful for debugging.
+	*/
+	value;
+	/**
+	* Optional human-readable error description.
+	*
+	* Primarily for AI agent libraries or custom validation scenarios needing
+	* additional context. Standard assertions rely on `path`, `expected`, and
+	* `value` for error reporting.
+	*/
+	description;
+	/**
+	* Phantom property for TypeScript type safety.
+	*
+	* Not used at runtime—exists only to preserve generic type `T` in the type
+	* system. Always `undefined`.
+	*
+	* @internal
+	*/
+	fake_expected_typed_value_;
+	/**
+	* Creates a new TypeGuardError instance.
+	*
+	* @param props Error properties
+	*/
+	constructor(props) {
+		super(props.message || `Error on ${props.method}(): invalid type${props.path ? ` on ${props.path}` : ""}, expect to be ${props.expected}`);
+		const proto = new.target.prototype;
+		if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+		else this.__proto__ = proto;
+		this.method = props.method;
+		this.path = props.path;
+		this.expected = props.expected;
+		this.value = props.value;
+		if (props.description || props.value === void 0) this.description = props.description ?? [
+			"The value at this path is `undefined`.",
+			"",
+			`Please fill the \`${props.expected}\` typed value next time.`
+		].join("\n");
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/typia@12.1.1_@types+node@26.0.1_typescript@6.0.3/node_modules/typia/lib/internal/_assertGuard.mjs
+const _assertGuard = (exceptionable, props, factory) => {
+	if (exceptionable === true) if (factory) throw factory(props);
+	else throw new TypeGuardError(props);
+	return false;
+};
+//#endregion
+export { _assertGuard as t };

package/dist/_createStandardSchema-BGQyz-uA.js

@@ -0,0 +1,89 @@
+//#region ../../node_modules/.pnpm/typia@12.1.1_@types+node@26.0.1_typescript@6.0.3/node_modules/typia/lib/internal/_validateReport.mjs
+const _validateReport = (array) => {
+	const reportable = (path) => {
+		if (array.length === 0) return true;
+		const last = array[array.length - 1].path;
+		return path.length > last.length || last.substring(0, path.length) !== path;
+	};
+	return (exceptable, error) => {
+		if (exceptable && reportable(error.path)) {
+			if (error.value === void 0) error.description ??= [
+				"The value at this path is `undefined`.",
+				"",
+				`Please fill the \`${error.expected}\` typed value next time.`
+			].join("\n");
+			array.push(error);
+		}
+		return false;
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/typia@12.1.1_@types+node@26.0.1_typescript@6.0.3/node_modules/typia/lib/internal/_createStandardSchema.mjs
+const _createStandardSchema = (fn) => Object.assign(fn, { "~standard": {
+	version: 1,
+	vendor: "typia",
+	validate: (input) => {
+		const result = fn(input);
+		if (result.success) return { value: result.data };
+		else return { issues: result.errors.map((error) => ({
+			message: `expected ${error.expected}, got ${error.value}`,
+			path: typiaPathToStandardSchemaPath(error.path)
+		})) };
+	}
+} });
+var PathParserState;
+(function(PathParserState) {
+	PathParserState[PathParserState["Start"] = 0] = "Start";
+	PathParserState[PathParserState["Property"] = 1] = "Property";
+	PathParserState[PathParserState["StringKey"] = 2] = "StringKey";
+	PathParserState[PathParserState["NumberKey"] = 3] = "NumberKey";
+})(PathParserState || (PathParserState = {}));
+const typiaPathToStandardSchemaPath = (path) => {
+	if (!path.startsWith("$input")) throw new Error(`Invalid path: ${JSON.stringify(path)}`);
+	const segments = [];
+	let currentSegment = "";
+	let state = PathParserState.Start;
+	let index = 5;
+	while (index < path.length - 1) {
+		index++;
+		const char = path[index];
+		if (state === PathParserState.Property) if (char === "." || char === "[") {
+			segments.push({ key: currentSegment });
+			state = PathParserState.Start;
+		} else if (index === path.length - 1) {
+			currentSegment += char;
+			segments.push({ key: currentSegment });
+			index++;
+			state = PathParserState.Start;
+		} else currentSegment += char;
+		else if (state === PathParserState.StringKey) if (char === "\"") {
+			segments.push({ key: JSON.parse(currentSegment + char) });
+			index += 2;
+			state = PathParserState.Start;
+		} else if (char === "\\") {
+			currentSegment += path[index];
+			index++;
+			currentSegment += path[index];
+		} else currentSegment += char;
+		else if (state === PathParserState.NumberKey) if (char === "]") {
+			segments.push({ key: Number.parseInt(currentSegment) });
+			index++;
+			state = PathParserState.Start;
+		} else currentSegment += char;
+		if (state === PathParserState.Start && index < path.length - 1) {
+			const newChar = path[index];
+			currentSegment = "";
+			if (newChar === "[") if (path[index + 1] === "\"") {
+				state = PathParserState.StringKey;
+				index++;
+				currentSegment = "\"";
+			} else state = PathParserState.NumberKey;
+			else if (newChar === ".") state = PathParserState.Property;
+			else throw new Error("Unreachable: pointer points invalid character");
+		}
+	}
+	if (state !== PathParserState.Start) throw new Error(`Failed to parse path: ${JSON.stringify(path)}`);
+	return segments;
+};
+//#endregion
+export { _validateReport as n, _createStandardSchema as t };

package/dist/cli/index.d.ts

@@ -1,4 +1,4 @@
-import { k as Draft, p as Tegami, t as Awaitable, y as PublishPlan } from "../types-DHddSAez.js";
+import { k as Draft, p as Tegami, t as Awaitable, y as PublishPlan } from "../types-VvvN6oyT.js";
 
 //#region src/cli/index.d.ts
 interface TegamiCLIOptions {

package/dist/cli/index.js

@@ -1,6 +1,6 @@
-import { n as generateFromCommits, t as changelogFilename } from "../generate-Rvz4Lu98.js";
+import { n as generateFromCommits, t as changelogFilename } from "../generate-Bg86OJP4.js";
 import { o as isCI, r as handlePluginError, t as CancelledError } from "../error-BhMYq9iW.js";
-import { n as renderChangelog } from "../shared-C92toqVI.js";
+import { t as renderChangelog } from "../shared-C_iSTp_s.js";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path, { join, relative } from "node:path";
 import { x } from "tinyexec";

package/dist/{draft-BqHcSCeX.js → draft-DsxZOCOb.js}

@@ -1,12 +1,14 @@
 import { a as maxBump } from "./semver-EKJ8yK5U.js";
 import { r as handlePluginError } from "./error-BhMYq9iW.js";
-import { n as renderChangelog, t as changelogFrontmatterSchema } from "./shared-C92toqVI.js";
+import { t as _accessExpressionAsString } from "./_accessExpressionAsString-QhbUZzwv.js";
+import { n as _validateReport, t as _createStandardSchema } from "./_createStandardSchema-BGQyz-uA.js";
+import { n as validateChangelogFrontmatter, t as renderChangelog } from "./shared-C_iSTp_s.js";
+import { t as _assertGuard } from "./_assertGuard-BBn2NbSz.js";
 import { simpleGenerator } from "./generators/simple.js";
 import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path, { basename, dirname, join } from "node:path";
 import * as semver$1 from "semver";
-import z from "zod";
-import { dump, load, visit } from "js-yaml";
+import { parse as parse$1, stringify } from "yaml";
 //#region src/utils/frontmatter.ts
 /**
 * Inspired by https://github.com/jonschlinkert/gray-matter
@@ -25,7 +27,7 @@ function frontmatter(input) {
 	if (!match) return output;
 	output.matter = match[0];
 	output.content = input.slice(match[0].length);
-	output.data = load(match[1]) ?? {};
+	output.data = parse$1(match[1]) ?? {};
 	return output;
 }
 //#endregion
@@ -45,8 +47,11 @@ async function readChangelogEntries(context) {
 /** Parse one changelog markdown file into release entries. */
 function parseChangelogFile(filename, content) {
 	const parsed = frontmatter(content);
-	const { success, data } = changelogFrontmatterSchema.safeParse(parsed.data);
-	if (!success || !data.packages) return;
+	const validated = validateChangelogFrontmatter(parsed.data);
+	if (!validated.success) return;
+	const { packages: packagesConfig } = validated.data;
+	if (!packagesConfig) return;
+	const data = validated.data;
 	let headingBump;
 	const packages = /* @__PURE__ */ new Map();
 	const sections = [];
@@ -60,10 +65,10 @@ function parseChangelogFile(filename, content) {
 		});
 	}
 	if (sections.length === 0) return;
-	if (Array.isArray(data.packages)) {
+	if (Array.isArray(packagesConfig)) {
 		if (!headingBump) return;
-		for (const pkg of data.packages) packages.set(pkg, { type: headingBump });
-	} else for (const [k, v] of Object.entries(data.packages)) {
+		for (const pkg of packagesConfig) packages.set(pkg, { type: headingBump });
+	} else for (const [k, v] of Object.entries(packagesConfig)) {
 		let config;
 		if (typeof v === "string") config = { type: v };
 		else if (v === null) config = { type: headingBump };
@@ -87,18 +92,33 @@ function parseChangelogFile(filename, content) {
 	};
 	return entry;
 }
+function formatReplayCondition(condition) {
+	switch (condition.on) {
+		case "exit-prerelease": return `exit-prerelease(${condition.name})`;
+		case "enter-prerelease": return `prerelease(${condition.name})`;
+		case "version": return `${condition.name}@${condition.version}`;
+	}
+}
 function parseReplayCondition(condition) {
-	if (condition.startsWith("exit prerelease:")) return {
-		type: "on-exit-prerelease",
-		name: condition.slice(16).trimStart()
+	let match;
+	if (match = /^exit-prerelease\((.+)\)$/.exec(condition)) return {
+		on: "exit-prerelease",
+		name: match[1]
 	};
-	const idx = condition.lastIndexOf("@");
-	if (idx <= 0) return null;
-	return {
-		type: "on-version",
-		name: condition.slice(0, idx),
-		version: condition.slice(idx + 1)
+	if (match = /^prerelease\((.+)\)$/.exec(condition)) return {
+		on: "enter-prerelease",
+		name: match[1]
 	};
+	if (match = /^exit prerelease:\s*(.+)$/.exec(condition)) return {
+		on: "exit-prerelease",
+		name: match[1]
+	};
+	if (match = /^(.+)@([^@]+)$/.exec(condition)) return {
+		on: "version",
+		name: match[1],
+		version: match[2]
+	};
+	return null;
 }
 function parseMarkdownSections(markdown) {
 	const sections = [];
@@ -155,20 +175,6 @@ function headingToBump(depth) {
 }
 //#endregion
 //#region src/plans/lock.ts
-function inlineMultilineScalars(documents) {
-	visit(documents, (node) => {
-		if (node.kind !== "scalar" || !node.value.includes("\n")) return;
-		node.style.doubleQuoted = true;
-		node.style.literal = false;
-		node.style.folded = false;
-		node.style.singleQuoted = false;
-	});
-}
-const lockDumpOptions = {
-	sortKeys: true,
-	lineWidth: -1,
-	transform: inlineMultilineScalars
-};
 /**
 * the data structure of `publish-lock.yaml` file.
 */
@@ -193,24 +199,64 @@ var PublishLock = class {
 		return this.data.get(namespace)?.length ?? 0;
 	}
 	serialize() {
-		let res = dump(Object.fromEntries(this.data.entries()), lockDumpOptions);
+		let res = stringify(this.data, {
+			sortMapEntries: true,
+			lineWidth: 0,
+			blockQuote: false,
+			doubleQuotedAsJSON: true
+		});
 		if (!res.endsWith("\n")) res += "\n";
 		return res;
 	}
 };
-const baseSchema = z.record(z.string(), z.array(z.unknown()));
+const assertPublishLockData = (() => {
+	const _io0 = (input) => Object.keys(input).every((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return Array.isArray(value);
+	});
+	const _ao0 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return Array.isArray(value) || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "Array<unknown>",
+			value
+		}, _errorFactory);
+	});
+	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: "Record<string, Array<unknown>>",
+				value: input
+			}, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard(true, {
+				method: "typia.createAssert",
+				path: _path + "",
+				expected: "Record<string, Array<unknown>>",
+				value: input
+			}, _errorFactory))(input, "$input", true);
+		}
+		return input;
+	};
+})();
 function parsePublishLock(content) {
-	const data = baseSchema.parse(load(content));
+	const data = assertPublishLockData(parse$1(content));
 	return new PublishLock(new Map(Object.entries(data)));
 }
 //#endregion
 //#region src/plans/policy.ts
-function groupPolicy({ graph }) {
+function groupPolicy(_ctx) {
 	return {
 		id: "group",
 		onUpdate({ pkg, packageDraft }) {
 			if (!packageDraft.type) return;
-			const group = graph.getPackageGroup(pkg.id);
+			const group = pkg.group;
 			if (!group || !group.options.syncBump) return;
 			for (const member of group.packages) {
 				if (member === pkg) continue;
@@ -224,16 +270,116 @@ function groupPolicy({ graph }) {
 }
 //#endregion
 //#region src/plans/draft.ts
-const changelogStoreSchema = z.object({
-	v: z.literal("0.0.0"),
-	filename: z.string(),
-	content: z.string()
-});
-const packageStoreSchema = z.object({
-	id: z.string(),
-	updated: z.boolean(),
-	changelogIds: z.array(z.string()).optional()
-});
+const validateChangelogStore = (() => {
+	const _io0 = (input) => "0.0.0" === input.v && "string" === typeof input.filename && "string" === typeof input.content;
+	const _vo0 = (input, _path, _exceptionable = true) => [
+		"0.0.0" === input.v || _report(_exceptionable, {
+			path: _path + ".v",
+			expected: "\"0.0.0\"",
+			value: input.v
+		}),
+		"string" === typeof input.filename || _report(_exceptionable, {
+			path: _path + ".filename",
+			expected: "string",
+			value: input.filename
+		}),
+		"string" === typeof input.content || _report(_exceptionable, {
+			path: _path + ".content",
+			expected: "string",
+			value: input.content
+		})
+	].every((flag) => flag);
+	const __is = (input) => "object" === typeof input && null !== input && _io0(input);
+	let errors;
+	let _report;
+	return _createStandardSchema((input) => {
+		if (false === __is(input)) {
+			errors = [];
+			_report = _validateReport(errors);
+			((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+				path: _path + "",
+				expected: "ChangelogStore",
+				value: input
+			})) && _vo0(input, _path + "", true) || _report(true, {
+				path: _path + "",
+				expected: "ChangelogStore",
+				value: input
+			}))(input, "$input", true);
+			const success = 0 === errors.length;
+			return success ? {
+				success,
+				data: input
+			} : {
+				success,
+				errors,
+				data: input
+			};
+		}
+		return {
+			success: true,
+			data: input
+		};
+	});
+})();
+const validatePackageStore = (() => {
+	const _io0 = (input) => "string" === typeof input.id && "boolean" === typeof input.updated && (void 0 === input.changelogIds || Array.isArray(input.changelogIds) && input.changelogIds.every((elem) => "string" === typeof elem));
+	const _vo0 = (input, _path, _exceptionable = true) => [
+		"string" === typeof input.id || _report(_exceptionable, {
+			path: _path + ".id",
+			expected: "string",
+			value: input.id
+		}),
+		"boolean" === typeof input.updated || _report(_exceptionable, {
+			path: _path + ".updated",
+			expected: "boolean",
+			value: input.updated
+		}),
+		void 0 === input.changelogIds || (Array.isArray(input.changelogIds) || _report(_exceptionable, {
+			path: _path + ".changelogIds",
+			expected: "(Array<string> | undefined)",
+			value: input.changelogIds
+		})) && input.changelogIds.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
+			path: _path + ".changelogIds[" + _index2 + "]",
+			expected: "string",
+			value: elem
+		})).every((flag) => flag) || _report(_exceptionable, {
+			path: _path + ".changelogIds",
+			expected: "(Array<string> | undefined)",
+			value: input.changelogIds
+		})
+	].every((flag) => flag);
+	const __is = (input) => "object" === typeof input && null !== input && _io0(input);
+	let errors;
+	let _report;
+	return _createStandardSchema((input) => {
+		if (false === __is(input)) {
+			errors = [];
+			_report = _validateReport(errors);
+			((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+				path: _path + "",
+				expected: "PackageStore",
+				value: input
+			})) && _vo0(input, _path + "", true) || _report(true, {
+				path: _path + "",
+				expected: "PackageStore",
+				value: input
+			}))(input, "$input", true);
+			const success = 0 === errors.length;
+			return success ? {
+				success,
+				data: input
+			} : {
+				success,
+				errors,
+				data: input
+			};
+		}
+		return {
+			success: true,
+			data: input
+		};
+	});
+})();
 /** a draft describes all operations to perform before the actual publishing, such as version bumps. */
 var Draft = class {
 	context;
@@ -279,7 +425,7 @@ var Draft = class {
 		const existing = this.packages.get(pkg.id);
 		if (existing) return existing;
 		this.packages.set(pkg.id, pkg.initDraft());
-		return this.dispatchPackage(pkg, (draft) => pkg.configureDraft(draft, this.context.graph.getPackageGroup(pkg.id)), (draft) => {
+		return this.dispatchPackage(pkg, (draft) => pkg.configureDraft({ draft }), (draft) => {
 			(draft.bumpReasons ??= /* @__PURE__ */ new Set()).add("align with script-level configs");
 		});
 	}
@@ -387,15 +533,26 @@ var Draft = class {
 		const { graph } = this.context;
 		const defaultReplays = (name) => {
 			const replay = [];
-			for (const pkg of graph.getByName(name)) if (this.packages.get(pkg.id)?.prerelease) replay.push(`exit prerelease: ${pkg.id}`);
+			for (const pkg of graph.getByName(name)) if (this.packages.get(pkg.id)?.prerelease) replay.push(formatReplayCondition({
+				on: "exit-prerelease",
+				name: pkg.id
+			}));
 			return replay;
 		};
 		const isMatch = (condition) => {
-			if (condition.type === "on-exit-prerelease") return graph.getByName(condition.name).some((pkg) => {
-				const previous = snapshots.get(pkg.id);
-				return previous?.version && semver$1.inc(previous.version, "release") === pkg.version;
-			});
-			return graph.getByName(condition.name).some((pkg) => pkg.version === condition.version);
+			switch (condition.on) {
+				case "enter-prerelease": return graph.getByName(condition.name).some((pkg) => {
+					const previous = snapshots.get(pkg.id);
+					if (!pkg.version || !previous?.version) return false;
+					return !semver$1.prerelease(previous.version) && semver$1.prerelease(pkg.version);
+				});
+				case "exit-prerelease": return graph.getByName(condition.name).some((pkg) => {
+					const previous = snapshots.get(pkg.id);
+					if (!pkg.version || !previous?.version) return false;
+					return semver$1.inc(previous.version, "release") === pkg.version;
+				});
+				case "version": return graph.getByName(condition.name).some((pkg) => pkg.version === condition.version);
+			}
 		};
 		for (const entry of this.changelogs.values()) {
 			const updatedPackages = /* @__PURE__ */ new Map();
@@ -461,4 +618,4 @@ function attachChangelog(draft, entry) {
 	draft.changelogs.push(entry);
 }
 //#endregion
-export { parseChangelogFile as a, parsePublishLock as i, createDraft as n, readChangelogEntries as o, packageStoreSchema as r, changelogStoreSchema as t };
+export { parseChangelogFile as a, parsePublishLock as i, validateChangelogStore as n, readChangelogEntries as o, validatePackageStore as r, createDraft as t };

package/dist/{generate-Rvz4Lu98.js → generate-Bg86OJP4.js}

@@ -1,6 +1,6 @@
 import { a as maxBump, t as bumpDepth } from "./semver-EKJ8yK5U.js";
 import { n as execFailure } from "./error-BhMYq9iW.js";
-import { n as renderChangelog } from "./shared-C92toqVI.js";
+import { t as renderChangelog } from "./shared-C_iSTp_s.js";
 import { x } from "tinyexec";
 //#region src/utils/conventional-commit.ts
 /**

package/dist/generators/simple.d.ts

@@ -1,4 +1,4 @@
-import { r as LogGenerator } from "../types-DHddSAez.js";
+import { r as LogGenerator } from "../types-VvvN6oyT.js";
 
 //#region src/generators/simple.d.ts
 declare function simpleGenerator(): LogGenerator;