@tegami/dart 0.0.0-tegami-trusted-publish-setup → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fuma Nama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+import { Document } from "yaml";
+import { BumpType, TegamiPlugin, WorkspacePackage } from "tegami";
+
+//#region src/schema.d.ts
+type DartDependency = string | {
+  version?: string;
+  hosted?: string | {
+    name?: string;
+    url: string;
+  };
+  path?: string;
+  git?: unknown;
+  sdk?: string;
+  [key: string]: unknown;
+};
+interface Pubspec {
+  name?: string;
+  version?: string;
+  publish_to?: string;
+  resolution?: string;
+  workspace?: string[];
+  dependencies?: Record<string, DartDependency>;
+  dev_dependencies?: Record<string, DartDependency>;
+  dependency_overrides?: Record<string, DartDependency>;
+}
+//#endregion
+//#region src/index.d.ts
+declare const DEP_FIELDS: readonly ["dependencies", "dev_dependencies", "dependency_overrides"];
+interface PubspecFile {
+  path: string;
+  doc: Document;
+  data: Pubspec;
+}
+declare class DartPackage extends WorkspacePackage {
+  readonly path: string;
+  readonly file: PubspecFile;
+  readonly manager = "dart";
+  constructor(path: string, file: PubspecFile);
+  get name(): string;
+  get version(): string | undefined;
+  get publishTo(): string | undefined;
+  setVersion(version: string): void;
+  write(): Promise<void>;
+}
+interface DependentRef {
+  dependent: DartPackage;
+  kind: (typeof DEP_FIELDS)[number];
+  name: string;
+  spec: DartDependency;
+  table: Record<string, DartDependency>;
+  linked: DartPackage;
+}
+interface DartPluginOptions {
+  /**
+   * Update the pub workspace resolution after versioning.
+   *
+   * @default true
+   */
+  updateLockFile?: boolean;
+  /**
+   * Decide how to bump the dependents of a bumped package.
+   */
+  bumpDep?: (opts: DependentRef) => BumpType | false;
+}
+declare function dart({
+  updateLockFile,
+  bumpDep: getBumpDepType
+}?: DartPluginOptions): TegamiPlugin;
+declare function updateConstraintRange(range: string, version: string): string;
+declare function isPackagePublished(name: string, version: string, hostedUrl: string): Promise<boolean>;
+//#endregion
+export { DartPackage, DartPluginOptions, dart, isPackagePublished, updateConstraintRange };

package/dist/index.js

@@ -0,0 +1,630 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import * as semver from "semver";
+import { glob } from "tinyglobby";
+import { x } from "tinyexec";
+import { parseDocument } from "yaml";
+import { WorkspacePackage } from "tegami";
+import { execFailure, isCI, joinPath } from "tegami/utils";
+//#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
+//#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
+//#region src/schema.ts
+const assertPubspec = (() => {
+	const _io0 = (input) => (void 0 === input.name || "string" === typeof input.name) && (void 0 === input.version || "string" === typeof input.version) && (void 0 === input.publish_to || "string" === typeof input.publish_to) && (void 0 === input.resolution || "string" === typeof input.resolution) && (void 0 === input.workspace || Array.isArray(input.workspace) && input.workspace.every((elem) => "string" === typeof elem)) && (void 0 === input.dependencies || "object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) && _io1(input.dependencies)) && (void 0 === input.dev_dependencies || "object" === typeof input.dev_dependencies && null !== input.dev_dependencies && false === Array.isArray(input.dev_dependencies) && _io1(input.dev_dependencies)) && (void 0 === input.dependency_overrides || "object" === typeof input.dependency_overrides && null !== input.dependency_overrides && false === Array.isArray(input.dependency_overrides) && _io1(input.dependency_overrides));
+	const _io1 = (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 && false === Array.isArray(value) && _io2(value));
+	});
+	const _io2 = (input) => (void 0 === input.version || "string" === typeof input.version) && null !== input.hosted && (void 0 === input.hosted || "string" === typeof input.hosted || "object" === typeof input.hosted && null !== input.hosted && _io3(input.hosted)) && (void 0 === input.path || "string" === typeof input.path) && (void 0 === input.sdk || "string" === typeof input.sdk) && Object.keys(input).every((key) => {
+		if ([
+			"version",
+			"hosted",
+			"path",
+			"git",
+			"sdk"
+		].some((prop) => key === prop)) return true;
+		if (void 0 === input[key]) return true;
+		return true;
+	});
+	const _io3 = (input) => (void 0 === input.name || "string" === typeof input.name) && "string" === typeof input.url;
+	const _ao0 = (input, _path, _exceptionable = true) => (void 0 === input.name || "string" === typeof input.name || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".name",
+		expected: "(string | undefined)",
+		value: input.name
+	}, _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.publish_to || "string" === typeof input.publish_to || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".publish_to",
+		expected: "(string | undefined)",
+		value: input.publish_to
+	}, _errorFactory)) && (void 0 === input.resolution || "string" === typeof input.resolution || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".resolution",
+		expected: "(string | undefined)",
+		value: input.resolution
+	}, _errorFactory)) && (void 0 === input.workspace || (Array.isArray(input.workspace) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".workspace",
+		expected: "(Array<string> | undefined)",
+		value: input.workspace
+	}, _errorFactory)) && input.workspace.every((elem, _index2) => "string" === typeof elem || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".workspace[" + _index2 + "]",
+		expected: "string",
+		value: elem
+	}, _errorFactory)) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".workspace",
+		expected: "(Array<string> | 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, DartDependency> | undefined)",
+		value: input.dependencies
+	}, _errorFactory)) && _ao1(input.dependencies, _path + ".dependencies", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependencies",
+		expected: "(Record<string, DartDependency> | 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, DartDependency> | undefined)",
+		value: input.dev_dependencies
+	}, _errorFactory)) && _ao1(input.dev_dependencies, _path + ".dev_dependencies", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dev_dependencies",
+		expected: "(Record<string, DartDependency> | undefined)",
+		value: input.dev_dependencies
+	}, _errorFactory)) && (void 0 === input.dependency_overrides || ("object" === typeof input.dependency_overrides && null !== input.dependency_overrides && false === Array.isArray(input.dependency_overrides) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependency_overrides",
+		expected: "(Record<string, DartDependency> | undefined)",
+		value: input.dependency_overrides
+	}, _errorFactory)) && _ao1(input.dependency_overrides, _path + ".dependency_overrides", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".dependency_overrides",
+		expected: "(Record<string, DartDependency> | undefined)",
+		value: input.dependency_overrides
+	}, _errorFactory));
+	const _ao1 = (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: "(__type | string)",
+			value
+		}, _errorFactory)) && (void 0 !== value || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "(__type | string)",
+			value
+		}, _errorFactory)) && ("string" === typeof value || ("object" === typeof value && null !== value && false === Array.isArray(value) || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "(__type | string)",
+			value
+		}, _errorFactory)) && _ao2(value, _path + _accessExpressionAsString(key), _exceptionable) || _assertGuard(_exceptionable, {
+			method: "typia.createAssert",
+			path: _path + _accessExpressionAsString(key),
+			expected: "(__type | string)",
+			value
+		}, _errorFactory));
+	});
+	const _ao2 = (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)) && (null !== input.hosted || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".hosted",
+		expected: "(__type.o1 | string | undefined)",
+		value: input.hosted
+	}, _errorFactory)) && (void 0 === input.hosted || "string" === typeof input.hosted || ("object" === typeof input.hosted && null !== input.hosted || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".hosted",
+		expected: "(__type.o1 | string | undefined)",
+		value: input.hosted
+	}, _errorFactory)) && _ao3(input.hosted, _path + ".hosted", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".hosted",
+		expected: "(__type.o1 | string | undefined)",
+		value: input.hosted
+	}, _errorFactory)) && (void 0 === input.path || "string" === typeof input.path || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".path",
+		expected: "(string | undefined)",
+		value: input.path
+	}, _errorFactory)) && (void 0 === input.sdk || "string" === typeof input.sdk || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".sdk",
+		expected: "(string | undefined)",
+		value: input.sdk
+	}, _errorFactory)) && (false === _exceptionable || Object.keys(input).every((key) => {
+		if ([
+			"version",
+			"hosted",
+			"path",
+			"git",
+			"sdk"
+		].some((prop) => key === prop)) return true;
+		if (void 0 === input[key]) return true;
+		return true;
+	}));
+	const _ao3 = (input, _path, _exceptionable = true) => (void 0 === input.name || "string" === typeof input.name || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".name",
+		expected: "(string | undefined)",
+		value: input.name
+	}, _errorFactory)) && ("string" === typeof input.url || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".url",
+		expected: "string",
+		value: input.url
+	}, _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: "Pubspec",
+				value: input
+			}, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard(true, {
+				method: "typia.createAssert",
+				path: _path + "",
+				expected: "Pubspec",
+				value: input
+			}, _errorFactory))(input, "$input", true);
+		}
+		return input;
+	};
+})();
+const assertHostedPackage = (() => {
+	const _io0 = (input) => void 0 === input.versions || Array.isArray(input.versions) && input.versions.every((elem) => "object" === typeof elem && null !== elem && _io1(elem));
+	const _io1 = (input) => "string" === typeof input.version;
+	const _ao0 = (input, _path, _exceptionable = true) => void 0 === input.versions || (Array.isArray(input.versions) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".versions",
+		expected: "(Array<__type> | undefined)",
+		value: input.versions
+	}, _errorFactory)) && input.versions.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".versions[" + _index2 + "]",
+		expected: "__type",
+		value: elem
+	}, _errorFactory)) && _ao1(elem, _path + ".versions[" + _index2 + "]", _exceptionable) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".versions[" + _index2 + "]",
+		expected: "__type",
+		value: elem
+	}, _errorFactory)) || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".versions",
+		expected: "(Array<__type> | undefined)",
+		value: input.versions
+	}, _errorFactory);
+	const _ao1 = (input, _path, _exceptionable = true) => "string" === typeof input.version || _assertGuard(_exceptionable, {
+		method: "typia.createAssert",
+		path: _path + ".version",
+		expected: "string",
+		value: input.version
+	}, _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: "HostedPackage",
+				value: input
+			}, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard(true, {
+				method: "typia.createAssert",
+				path: _path + "",
+				expected: "HostedPackage",
+				value: input
+			}, _errorFactory))(input, "$input", true);
+		}
+		return input;
+	};
+})();
+//#endregion
+//#region src/index.ts
+const DEP_FIELDS = [
+	"dependencies",
+	"dev_dependencies",
+	"dependency_overrides"
+];
+const DEFAULT_HOSTED_URL = "https://pub.dev";
+var DartPackage = class extends WorkspacePackage {
+	path;
+	file;
+	manager = "dart";
+	constructor(path, file) {
+		super();
+		this.path = path;
+		this.file = file;
+	}
+	get name() {
+		return this.file.data.name;
+	}
+	get version() {
+		return this.file.data.version;
+	}
+	get publishTo() {
+		return this.file.data.publish_to;
+	}
+	setVersion(version) {
+		this.file.data.version = version;
+		this.file.doc.setIn(["version"], version);
+	}
+	async write() {
+		await writeFile(path.join(this.path, "pubspec.yaml"), this.file.doc.toString({ lineWidth: 0 }));
+	}
+};
+function dart({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
+	let active = false;
+	return {
+		name: "dart",
+		enforce: "post",
+		async resolve() {
+			const packages = await discoverDartPackages(this.cwd);
+			for (const pkg of packages) this.graph.add(pkg);
+			active = packages.length > 0;
+		},
+		initDraft(draft) {
+			if (!active) return;
+			draft.addPolicy(depsPolicy(this, getBumpDepType));
+		},
+		publishPreflight({ pkg }) {
+			if (!(pkg instanceof DartPackage)) return;
+			const wait = dependencyRefs(this.graph, pkg).filter((ref) => ref.kind === "dependencies").map((ref) => ref.linked.id);
+			return {
+				shouldPublish: pkg.version !== void 0 && pkg.publishTo !== "none",
+				wait
+			};
+		},
+		resolvePlanStatus({ plan }) {
+			return Array.from(plan.packages, async ([id, { preflight }]) => {
+				if (!preflight.shouldPublish) return;
+				const pkg = this.graph.get(id);
+				if (!(pkg instanceof DartPackage) || !pkg.version) return;
+				if (!await isPackagePublished(pkg.name, pkg.version, pkg.publishTo ?? DEFAULT_HOSTED_URL)) return "pending";
+			});
+		},
+		async publish({ pkg }) {
+			if (!(pkg instanceof DartPackage)) return;
+			const result = await x("dart", [
+				"pub",
+				"publish",
+				...isCI() ? ["--force"] : []
+			], { nodeOptions: { cwd: pkg.path } });
+			if (result.exitCode !== 0) {
+				if (/already exists|already published|version already exists/i.test(`${result.stdout}\n${result.stderr}`)) return { type: "skipped" };
+				return {
+					type: "failed",
+					error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}.`, result).message
+				};
+			}
+			return { type: "published" };
+		},
+		async applyDraft(draft) {
+			if (!active) return;
+			for (const pkg of this.graph.getPackages()) {
+				if (!(pkg instanceof DartPackage)) continue;
+				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
+				if (bumped) pkg.setVersion(bumped);
+			}
+			const writes = [];
+			for (const pkg of this.graph.getPackages()) {
+				if (!(pkg instanceof DartPackage)) continue;
+				for (const ref of dependencyRefs(this.graph, pkg)) {
+					if (!ref.linked.version) continue;
+					const range = getDependencyRange(ref.spec);
+					if (!range || satisfiesDartRange(ref.linked.version, range)) continue;
+					const nextRange = updateConstraintRange(range, ref.linked.version);
+					ref.table[ref.name] = setDependencyRange(ref.spec, nextRange);
+					ref.dependent.file.doc.setIn(typeof ref.spec === "object" && ref.spec !== null ? [
+						ref.kind,
+						ref.name,
+						"version"
+					] : [ref.kind, ref.name], nextRange);
+				}
+				writes.push(pkg.write());
+			}
+			await Promise.all(writes);
+		},
+		async applyCliDraft() {
+			if (!active || !updateLockFile) return;
+			const result = await x("dart", ["pub", "get"], { nodeOptions: { cwd: this.cwd } });
+			if (result.exitCode !== 0) throw execFailure("Failed to update Dart pub resolution.", result);
+		}
+	};
+}
+function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
+	switch (kind) {
+		case "dependencies":
+		case "dependency_overrides": return "patch";
+		case "dev_dependencies": return false;
+	}
+}) {
+	const dependentMap = /* @__PURE__ */ new Map();
+	for (const pkg of graph.getPackages()) {
+		if (!(pkg instanceof DartPackage)) continue;
+		for (const ref of dependencyRefs(graph, pkg)) {
+			const refs = dependentMap.get(ref.linked.id);
+			if (refs) refs.push(ref);
+			else dependentMap.set(ref.linked.id, [ref]);
+		}
+	}
+	return {
+		id: "dart:deps",
+		onUpdate({ pkg, packageDraft: plan }) {
+			if (!(pkg instanceof DartPackage)) return;
+			const deps = dependentMap.get(pkg.id);
+			if (!deps) return;
+			const group = graph.getPackageGroup(pkg.id);
+			if (!plan.bumpVersion(pkg)) return;
+			for (const dep of deps) {
+				if (group?.options.syncBump && graph.getPackageGroup(dep.dependent.id) === group) continue;
+				const bumpType = getBumpDepType(dep);
+				if (bumpType === false) continue;
+				this.bumpPackage(dep.dependent, {
+					type: bumpType,
+					reason: `update dependency "${dep.name}"`
+				});
+			}
+		}
+	};
+}
+function dependencyRefs(graph, pkg) {
+	const refs = [];
+	for (const { kind, table } of dependencyTables(pkg.file.data)) for (const [name, spec] of Object.entries(table)) {
+		const linked = resolveLinkedPackage(graph, name);
+		if (!linked || linked === pkg) continue;
+		refs.push({
+			dependent: pkg,
+			kind,
+			name,
+			spec,
+			table,
+			linked
+		});
+	}
+	return refs;
+}
+function resolveLinkedPackage(graph, name) {
+	return graph.getPackages().find((candidate) => candidate instanceof DartPackage && candidate.name === name);
+}
+function dependencyTables(manifest) {
+	const tables = [];
+	for (const kind of DEP_FIELDS) {
+		const table = manifest[kind];
+		if (table) tables.push({
+			kind,
+			table
+		});
+	}
+	return tables;
+}
+function getDependencyRange(spec) {
+	if (typeof spec === "string") return spec;
+	return spec.version;
+}
+function setDependencyRange(spec, range) {
+	if (typeof spec !== "object" || spec === null) return range;
+	spec.version = range;
+	return spec;
+}
+function updateConstraintRange(range, version) {
+	const trimmed = range.trim();
+	if (trimmed.startsWith("^")) return `^${version}`;
+	if (trimmed.startsWith("~")) return `~${version}`;
+	const lowerBound = /^(>=|>)\s*([0-9A-Za-z.+-]+)/.exec(trimmed);
+	if (lowerBound) return trimmed.replace(lowerBound[0], `${lowerBound[1]}${version}`);
+	return version;
+}
+function satisfiesDartRange(version, range) {
+	const trimmed = range.trim();
+	if (trimmed === "any") return true;
+	if (!semver.validRange(trimmed, { loose: true })) return false;
+	return semver.satisfies(version, trimmed, {
+		includePrerelease: true,
+		loose: true
+	});
+}
+async function discoverDartPackages(cwd) {
+	const root = await readPubspec(cwd);
+	if (!root?.data.workspace?.length) return [];
+	const files = /* @__PURE__ */ new Map();
+	files.set(root.path, root);
+	await collectWorkspaceFiles(root, files);
+	return Array.from(files.values()).filter((file) => Boolean(file.data.name)).map((file) => new DartPackage(path.dirname(file.path), file));
+}
+async function collectWorkspaceFiles(root, files) {
+	const rootDir = path.dirname(root.path);
+	const members = root.data.workspace;
+	if (!members?.length) return;
+	const paths = await glob(members, {
+		absolute: true,
+		cwd: rootDir,
+		onlyDirectories: true,
+		onlyFiles: false,
+		ignore: ["**/.dart_tool/**", "**/build/**"]
+	});
+	await Promise.all(paths.map(async (dir) => {
+		const file = await readPubspec(dir);
+		if (!file || files.has(file.path)) return;
+		files.set(file.path, file);
+		await collectWorkspaceFiles(file, files);
+	}));
+}
+async function readPubspec(dir) {
+	const filePath = path.join(dir, "pubspec.yaml");
+	try {
+		const doc = parseDocument(await readFile(filePath, "utf8"));
+		return {
+			path: filePath,
+			doc,
+			data: assertPubspec(doc.toJS())
+		};
+	} catch {
+		return;
+	}
+}
+async function isPackagePublished(name, version, hostedUrl) {
+	const url = joinPath(hostedUrl, "api/packages", encodeURIComponent(name));
+	const response = await fetch(url, { headers: {
+		Accept: "application/vnd.pub.v2+json",
+		"User-Agent": "tegami-dart"
+	} });
+	if (response.status === 404) return false;
+	if (!response.ok) return false;
+	return assertHostedPackage(await response.json()).versions?.some((entry) => entry.version === version) ?? false;
+}
+//#endregion
+export { DartPackage, dart, isPackagePublished, updateConstraintRange };

package/package.json

@@ -1,5 +1,48 @@
 {
   "name": "@tegami/dart",
-  "version": "0.0.0-tegami-trusted-publish-setup",
-  "description": "Placeholder published by Tegami for npm trusted publishing setup."
-}
+  "version": "1.1.1",
+  "description": "Dart pub workspace support and pub.dev publishing for Tegami",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "repository": {
+    "type": "git",
+    "url": "github:fuma-nama/tegami"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "semver": "^7.8.5",
+    "tinyexec": "^1.2.4",
+    "tinyglobby": "^0.2.17",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "@types/semver": "^7.7.1",
+    "tsdown": "^0.22.3",
+    "typescript": "6.0.3",
+    "typia": "^12.1.1",
+    "@repo/typescript-config": "0.0.0",
+    "tegami": "1.1.1"
+  },
+  "peerDependencies": {
+    "tegami": "1.1.1"
+  },
+  "inlinedDependencies": {
+    "typia": "12.1.1"
+  },
+  "scripts": {
+    "types:check": "tsc --noEmit",
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  }
+}

package/README.md

@@ -1,5 +0,0 @@
-# Placeholder package
-
-This empty package was published by [Tegami](https://tegami.fuma-nama.dev) to configure npm trusted publishing.
-
-The real package contents will be published via CI with OIDC.