@effected/github 0.1.0

package/GitHubIssue.js

@@ -0,0 +1,216 @@
+import { GraphQLDocument } from "./GraphQL.js";
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { Context, Effect, Layer, Schema } from "effect";
+
+//#region src/GitHubIssue.ts
+/**
+* An issue, projected to what callers read.
+*
+* @public
+*/
+var IssueInfo = class extends Schema.Class("IssueInfo")({
+	number: Schema.Int,
+	title: Schema.String,
+	state: Schema.Literals(["open", "closed"]),
+	/** Label names, normalized from GitHub's `string | { name }` union. */
+	labels: Schema.Array(Schema.String),
+	url: Schema.String,
+	/** The GraphQL node id. */
+	nodeId: Schema.String
+}) {};
+/**
+* An issue a pull request closes.
+*
+* @public
+*/
+var LinkedIssue = class extends Schema.Class("LinkedIssue")({
+	number: Schema.Int,
+	title: Schema.String,
+	state: Schema.String,
+	url: Schema.String,
+	nodeId: Schema.String,
+	/**
+	* Whether a human wrote the link, rather than GitHub inferring it from the
+	* branch or commit messages.
+	*
+	* @remarks
+	* This is the field the whole document exists for. The version this replaces
+	* could not express `userLinkedOnly`, so one consumer re-declared the query
+	* with the field aliased twice to get it — the single largest duplicated
+	* document in the survey.
+	*/
+	userLinked: Schema.Boolean
+}) {};
+const IssueNodes = Schema.Struct({
+	id: Schema.String,
+	number: Schema.Int,
+	title: Schema.String,
+	state: Schema.String,
+	url: Schema.String
+});
+const LinkedIssuesResponse = Schema.Struct({ repository: Schema.Struct({ pullRequest: Schema.Struct({
+	allLinked: Schema.Struct({ nodes: Schema.Array(IssueNodes) }),
+	manuallyLinked: Schema.Struct({ nodes: Schema.Array(IssueNodes) })
+}) }) });
+const LinkedIssuesDocument = GraphQLDocument.make({
+	name: "linkedIssues",
+	document: `query ($owner: String!, $repo: String!, $prNumber: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $prNumber) {
+      allLinked: closingIssuesReferences(first: 50) { nodes { id number title state url } }
+      manuallyLinked: closingIssuesReferences(first: 50, userLinkedOnly: true) { nodes { id number title state url } }
+    }
+  }
+}`,
+	response: LinkedIssuesResponse
+})();
+const CrossReferencedResponse = Schema.Struct({ repository: Schema.Struct({ issue: Schema.Struct({ timelineItems: Schema.Struct({ nodes: Schema.Array(Schema.Struct({ source: Schema.optionalKey(Schema.Struct({
+	__typename: Schema.optionalKey(Schema.String),
+	number: Schema.optionalKey(Schema.Int)
+})) })) }) }) }) });
+const CrossReferencedDocument = GraphQLDocument.make({
+	name: "issueCrossReferences",
+	document: `query ($owner: String!, $repo: String!, $issueNumber: Int!) {
+  repository(owner: $owner, name: $repo) {
+    issue(number: $issueNumber) {
+      timelineItems(last: 50, itemTypes: CROSS_REFERENCED_EVENT) {
+        nodes {
+          __typename
+          ... on CrossReferencedEvent { source { __typename ... on PullRequest { number } } }
+        }
+      }
+    }
+  }
+}`,
+	response: CrossReferencedResponse
+})();
+/**
+* Issues.
+*
+* @public
+*/
+var GitHubIssue = class GitHubIssue extends Context.Service()("@effected/github/GitHubIssue") {
+	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
+	/** An in-memory double; unstubbed members die naming themselves. */
+	static makeTest = (overrides = {}) => ({
+		get: overrides.get ?? (() => unstubbed("get")),
+		list: overrides.list ?? (() => unstubbed("list")),
+		close: overrides.close ?? (() => unstubbed("close")),
+		comment: overrides.comment ?? (() => unstubbed("comment")),
+		linkedIssues: overrides.linkedIssues ?? (() => unstubbed("linkedIssues")),
+		isCrossReferencedBy: overrides.isCrossReferencedBy ?? (() => unstubbed("isCrossReferencedBy"))
+	});
+	/** {@link GitHubIssue.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(GitHubIssue, GitHubIssue.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`GitHubIssue.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+/** GitHub sends a label as either a string or an object; callers want the name. */
+const labelNames = (labels) => labels.flatMap((label) => typeof label === "string" ? [label] : label.name !== void 0 ? [label.name] : []);
+const project = (raw) => IssueInfo.make({
+	number: raw.number,
+	title: raw.title,
+	state: raw.state === "closed" ? "closed" : "open",
+	labels: labelNames(raw.labels),
+	url: raw.html_url,
+	nodeId: raw.node_id
+});
+const make = (client) => ({
+	get: Effect.fn("GitHubIssue.get")(function* (number) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			number
+		});
+		const raw = yield* client.request("GET /repos/{owner}/{repo}/issues/{issue_number}", {
+			owner,
+			repo,
+			issue_number: number
+		});
+		return project(raw);
+	}),
+	list: Effect.fn("GitHubIssue.list")(function* (options) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo
+		});
+		return (yield* client.paginate("GET /repos/{owner}/{repo}/issues", {
+			owner,
+			repo,
+			...options?.state !== void 0 ? { state: options.state } : {},
+			...options?.labels !== void 0 ? { labels: options.labels.join(",") } : {}
+		}, options?.page)).map(project);
+	}),
+	close: Effect.fn("GitHubIssue.close")(function* (number, reason) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			number
+		});
+		yield* client.request("PATCH /repos/{owner}/{repo}/issues/{issue_number}", {
+			owner,
+			repo,
+			issue_number: number,
+			state: "closed",
+			...reason !== void 0 ? { state_reason: reason } : {}
+		});
+	}),
+	comment: Effect.fn("GitHubIssue.comment")(function* (number, body) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			number
+		});
+		return (yield* client.request("POST /repos/{owner}/{repo}/issues/{issue_number}/comments", {
+			owner,
+			repo,
+			issue_number: number,
+			body
+		})).id;
+	}),
+	linkedIssues: Effect.fn("GitHubIssue.linkedIssues")(function* (prNumber) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			prNumber
+		});
+		const result = yield* client.graphql(LinkedIssuesDocument, {
+			owner,
+			repo,
+			prNumber
+		});
+		const manual = new Set(result.repository.pullRequest.manuallyLinked.nodes.map((node) => node.number));
+		return result.repository.pullRequest.allLinked.nodes.map((node) => LinkedIssue.make({
+			number: node.number,
+			title: node.title,
+			state: node.state,
+			url: node.url,
+			nodeId: node.id,
+			userLinked: manual.has(node.number)
+		}));
+	}),
+	isCrossReferencedBy: Effect.fn("GitHubIssue.isCrossReferencedBy")(function* (issueNumber, prNumber) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			issueNumber,
+			prNumber
+		});
+		return (yield* client.graphql(CrossReferencedDocument, {
+			owner,
+			repo,
+			issueNumber
+		})).repository.issue.timelineItems.nodes.some((node) => node.source?.__typename === "PullRequest" && node.source.number === prNumber);
+	})
+});
+
+//#endregion
+export { GitHubIssue, IssueInfo, LinkedIssue };

package/GitHubRelease.js

@@ -0,0 +1,188 @@
+import { GitHubError } from "./GitHubError.js";
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { Context, Effect, Layer, Option, Schema } from "effect";
+
+//#region src/GitHubRelease.ts
+/**
+* A release.
+*
+* @public
+*/
+var ReleaseInfo = class extends Schema.Class("ReleaseInfo")({
+	id: Schema.Int,
+	tag: Schema.String,
+	name: Schema.String,
+	body: Schema.String,
+	draft: Schema.Boolean,
+	prerelease: Schema.Boolean,
+	/** The web URL. */
+	url: Schema.String,
+	/** The templated upload endpoint GitHub hands back for assets. */
+	uploadUrl: Schema.String
+}) {};
+/**
+* A file attached to a release.
+*
+* @public
+*/
+var ReleaseAsset = class extends Schema.Class("ReleaseAsset")({
+	id: Schema.Int,
+	name: Schema.String,
+	/** The browser download URL. */
+	url: Schema.String,
+	/** Size in bytes. */
+	size: Schema.Int
+}) {};
+/**
+* Releases.
+*
+* @public
+*/
+var GitHubRelease = class GitHubRelease extends Context.Service()("@effected/github/GitHubRelease") {
+	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
+	/** An in-memory double; unstubbed members die naming themselves. */
+	static makeTest = (overrides = {}) => ({
+		create: overrides.create ?? (() => unstubbed("create")),
+		getByTag: overrides.getByTag ?? (() => unstubbed("getByTag")),
+		getByTagOption: overrides.getByTagOption ?? (() => unstubbed("getByTagOption")),
+		list: overrides.list ?? (() => unstubbed("list")),
+		update: overrides.update ?? (() => unstubbed("update")),
+		uploadAsset: overrides.uploadAsset ?? (() => unstubbed("uploadAsset")),
+		listAssets: overrides.listAssets ?? (() => unstubbed("listAssets"))
+	});
+	/** {@link GitHubRelease.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(GitHubRelease, GitHubRelease.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`GitHubRelease.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+const project = (raw) => ReleaseInfo.make({
+	id: raw.id,
+	tag: raw.tag_name,
+	name: raw.name ?? "",
+	body: raw.body ?? "",
+	draft: raw.draft,
+	prerelease: raw.prerelease,
+	url: raw.html_url,
+	uploadUrl: raw.upload_url
+});
+const AssetResponse = Schema.Struct({
+	id: Schema.Int,
+	name: Schema.String,
+	browser_download_url: Schema.String,
+	size: Schema.Int
+});
+const assetOf = (raw) => ReleaseAsset.make({
+	id: raw.id,
+	name: raw.name,
+	url: raw.browser_download_url,
+	size: raw.size
+});
+const make = (client) => {
+	const getByTag = Effect.fn("GitHubRelease.getByTag")(function* (tag) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			tag
+		});
+		const raw = yield* client.request("GET /repos/{owner}/{repo}/releases/tags/{tag}", {
+			owner,
+			repo,
+			tag
+		});
+		return project(raw);
+	});
+	return {
+		getByTag,
+		create: Effect.fn("GitHubRelease.create")(function* (input) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				tag: input.tag
+			});
+			const created = yield* client.request("POST /repos/{owner}/{repo}/releases", {
+				owner,
+				repo,
+				tag_name: input.tag,
+				...input.name !== void 0 ? { name: input.name } : {},
+				...input.body !== void 0 ? { body: input.body } : {},
+				...input.draft !== void 0 ? { draft: input.draft } : {},
+				...input.prerelease !== void 0 ? { prerelease: input.prerelease } : {},
+				...input.generateReleaseNotes !== void 0 ? { generate_release_notes: input.generateReleaseNotes } : {}
+			});
+			return project(created);
+		}),
+		getByTagOption: Effect.fn("GitHubRelease.getByTagOption")(function* (tag) {
+			return yield* getByTag(tag).pipe(Effect.map(Option.some), Effect.catchIf(GitHubError.hasKind("notFound"), () => Effect.succeed(Option.none())));
+		}),
+		list: Effect.fn("GitHubRelease.list")(function* (options) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo
+			});
+			return (yield* client.paginate("GET /repos/{owner}/{repo}/releases", {
+				owner,
+				repo
+			}, options?.page)).map(project);
+		}),
+		update: Effect.fn("GitHubRelease.update")(function* (id, patch) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				id
+			});
+			const updated = yield* client.request("PATCH /repos/{owner}/{repo}/releases/{release_id}", {
+				owner,
+				repo,
+				release_id: id,
+				...patch.name !== void 0 ? { name: patch.name } : {},
+				...patch.body !== void 0 ? { body: patch.body } : {},
+				...patch.draft !== void 0 ? { draft: patch.draft } : {},
+				...patch.prerelease !== void 0 ? { prerelease: patch.prerelease } : {}
+			});
+			return project(updated);
+		}),
+		uploadAsset: Effect.fn("GitHubRelease.uploadAsset")(function* (release, asset) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				release: release.id,
+				asset: asset.name
+			});
+			const raw = yield* client.requestDecoded("POST /repos/{owner}/{repo}/releases/{release_id}/assets", {
+				owner,
+				repo,
+				release_id: release.id,
+				name: asset.name,
+				data: asset.data,
+				baseUrl: UPLOADS_BASE_URL,
+				headers: { "content-type": asset.contentType }
+			}, AssetResponse);
+			return assetOf(raw);
+		}),
+		listAssets: Effect.fn("GitHubRelease.listAssets")(function* (id, options) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				id
+			});
+			return (yield* client.paginate("GET /repos/{owner}/{repo}/releases/{release_id}/assets", {
+				owner,
+				repo,
+				release_id: id
+			}, options?.page)).map(assetOf);
+		})
+	};
+};
+/** Release assets do not go to the API host. */
+const UPLOADS_BASE_URL = "https://uploads.github.com";
+
+//#endregion
+export { GitHubRelease, ReleaseAsset, ReleaseInfo };

package/GitHubRepository.js

@@ -0,0 +1,59 @@
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/GitHubRepository.ts
+/**
+* Repository settings and coordinates.
+*
+* @public
+*/
+var GitHubRepository = class GitHubRepository extends Context.Service()("@effected/github/GitHubRepository") {
+	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
+	/** An in-memory double; unstubbed members die naming themselves. */
+	static makeTest = (overrides = {}) => ({
+		settings: overrides.settings ?? Effect.sync(() => unstubbed("settings")),
+		updateSettings: overrides.updateSettings ?? (() => unstubbed("updateSettings")),
+		defaultBranch: overrides.defaultBranch ?? Effect.sync(() => unstubbed("defaultBranch")),
+		nodeId: overrides.nodeId ?? Effect.sync(() => unstubbed("nodeId"))
+	});
+	/** {@link GitHubRepository.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(GitHubRepository, GitHubRepository.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`GitHubRepository.makeTest: ${member} was read but not stubbed — pass an override.`);
+};
+const make = (client) => {
+	const settings = Effect.fn("GitHubRepository.settings")(function* () {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo
+		});
+		return yield* client.request("GET /repos/{owner}/{repo}", {
+			owner,
+			repo
+		});
+	})();
+	return {
+		settings,
+		updateSettings: Effect.fn("GitHubRepository.updateSettings")(function* (patch) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				fields: Object.keys(patch).length
+			});
+			return yield* client.request("PATCH /repos/{owner}/{repo}", {
+				...patch,
+				owner,
+				repo
+			});
+		}),
+		defaultBranch: Effect.map(settings, (repository) => repository.default_branch),
+		nodeId: Effect.map(settings, (repository) => repository.node_id)
+	};
+};
+
+//#endregion
+export { GitHubRepository };

package/GitTag.js

@@ -0,0 +1,191 @@
+import { GitHubError } from "./GitHubError.js";
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { Context, Effect, Layer, Option, Result, Schema, Stream } from "effect";
+import { SemVer } from "@effected/semver";
+
+//#region src/GitTag.ts
+/** How many annotated-tag dereferences to follow before giving up. */
+const MAX_TAG_PEEL = 5;
+/**
+* A tag and the commit it ultimately points at.
+*
+* @public
+*/
+var TagRef = class extends Schema.Class("TagRef")({
+	/** The tag name, without `refs/tags/`. */
+	tag: Schema.NonEmptyString,
+	/** The **commit** sha, with annotated tags already dereferenced. */
+	sha: Schema.String
+}) {};
+/**
+* A tag whose name carries a version.
+*
+* @public
+*/
+var SemverTag = class extends Schema.Class("SemverTag")({
+	/** The tag name as GitHub has it. */
+	tag: Schema.NonEmptyString,
+	/** The commit sha. */
+	sha: Schema.String,
+	/** The version read out of the name. */
+	version: SemVer
+}) {};
+/** The default {@link VersionFromTag}. @public */
+const versionFromTag = (tag) => {
+	const at = tag.lastIndexOf("@");
+	const candidate = at > 0 ? tag.slice(at + 1) : tag;
+	const stripped = candidate.startsWith("v") ? candidate.slice(1) : candidate;
+	return stripped === "" ? Option.none() : Option.some(stripped);
+};
+/**
+* Tags.
+*
+* @public
+*/
+var GitTag = class GitTag extends Context.Service()("@effected/github/GitTag") {
+	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
+	/** An in-memory double; unstubbed members die naming themselves. */
+	static makeTest = (overrides = {}) => ({
+		create: overrides.create ?? (() => unstubbed("create")),
+		upsert: overrides.upsert ?? (() => unstubbed("upsert")),
+		delete: overrides.delete ?? (() => unstubbed("delete")),
+		list: overrides.list ?? (() => unstubbed("list")),
+		resolve: overrides.resolve ?? (() => unstubbed("resolve")),
+		latestSemver: overrides.latestSemver ?? (() => unstubbed("latestSemver"))
+	});
+	/** {@link GitTag.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(GitTag, GitTag.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`GitTag.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+const shortTag = (tag) => tag.replace(/^refs\/tags\//, "").replace(/^tags\//, "");
+const rejectEmpty = (operation, tag) => {
+	const short = shortTag(tag).trim();
+	return short === "" ? Effect.fail(GitHubError.rejected(operation, 422, "a tag name is required")) : Effect.succeed(short);
+};
+const make = (client) => {
+	const create = Effect.fn("GitTag.create")(function* (tag, sha) {
+		const { owner, repo } = yield* Repo;
+		const short = yield* rejectEmpty("GitTag.create", tag);
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			tag: short
+		});
+		yield* client.request("POST /repos/{owner}/{repo}/git/refs", {
+			owner,
+			repo,
+			ref: `refs/tags/${short}`,
+			sha
+		});
+	});
+	const reset = (tag, sha) => Effect.gen(function* () {
+		const { owner, repo } = yield* Repo;
+		yield* client.request("PATCH /repos/{owner}/{repo}/git/refs/{ref}", {
+			owner,
+			repo,
+			ref: `tags/${tag}`,
+			sha,
+			force: true
+		});
+	});
+	const listStream = (options) => Stream.unwrap(Effect.map(Repo, ({ owner, repo }) => client.paginateStream("GET /repos/{owner}/{repo}/tags", {
+		owner,
+		repo
+	}, options?.page)));
+	const list = Effect.fn("GitTag.list")(function* (options) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			prefix: options?.prefix ?? ""
+		});
+		const tags = yield* Stream.runCollect(listStream(options));
+		const prefix = options?.prefix;
+		return tags.filter((entry) => prefix === void 0 || entry.name.startsWith(prefix)).map((entry) => TagRef.make({
+			tag: entry.name,
+			sha: entry.commit.sha
+		}));
+	});
+	return {
+		create,
+		upsert: Effect.fn("GitTag.upsert")(function* (tag, sha) {
+			const short = yield* rejectEmpty("GitTag.upsert", tag);
+			yield* Effect.annotateCurrentSpan({ tag: short });
+			yield* create(short, sha).pipe(Effect.catchIf(GitHubError.hasKind("alreadyExists"), () => reset(short, sha)));
+		}),
+		delete: Effect.fn("GitTag.delete")(function* (tag) {
+			const { owner, repo } = yield* Repo;
+			const short = yield* rejectEmpty("GitTag.delete", tag);
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				tag: short
+			});
+			yield* client.request("DELETE /repos/{owner}/{repo}/git/refs/{ref}", {
+				owner,
+				repo,
+				ref: `tags/${short}`
+			});
+		}),
+		list,
+		resolve: Effect.fn("GitTag.resolve")(function* (tag) {
+			const { owner, repo } = yield* Repo;
+			const short = yield* rejectEmpty("GitTag.resolve", tag);
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				tag: short
+			});
+			const ref = yield* client.request("GET /repos/{owner}/{repo}/git/ref/{ref}", {
+				owner,
+				repo,
+				ref: `tags/${short}`
+			});
+			let sha = ref.object.sha;
+			let type = ref.object.type;
+			for (let peeled = 0; type === "tag"; peeled += 1) {
+				if (peeled >= MAX_TAG_PEEL) return yield* Effect.fail(GitHubError.rejected("GitTag.resolve", 422, `tag ${short} nests deeper than ${MAX_TAG_PEEL} levels`));
+				const annotated = yield* client.request("GET /repos/{owner}/{repo}/git/tags/{tag_sha}", {
+					owner,
+					repo,
+					tag_sha: sha
+				});
+				sha = annotated.object.sha;
+				type = annotated.object.type;
+			}
+			if (type !== "commit") return yield* Effect.fail(GitHubError.rejected("GitTag.resolve", 422, `tag ${short} points at a ${type}, not a commit`));
+			return sha;
+		}),
+		latestSemver: Effect.fn("GitTag.latestSemver")(function* (options) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				prefix: options?.prefix ?? ""
+			});
+			const extract = options?.extract ?? versionFromTag;
+			let best;
+			yield* Stream.runForEach(listStream({ page: options?.page }), (entry) => Effect.sync(() => {
+				if (options?.prefix !== void 0 && !entry.name.startsWith(options.prefix)) return;
+				const raw = extract(entry.name);
+				if (Option.isNone(raw)) return;
+				const parsed = SemVer.parseResult(raw.value);
+				if (Result.isFailure(parsed)) return;
+				const version = parsed.success;
+				if (version.prerelease.length > 0 && options?.includePrerelease !== true) return;
+				if (best === void 0 || version.compare(best.version) === 1) best = SemverTag.make({
+					tag: entry.name,
+					sha: entry.commit.sha,
+					version
+				});
+			}));
+			return Option.fromUndefinedOr(best);
+		})
+	};
+};
+
+//#endregion
+export { GitTag, SemverTag, TagRef, versionFromTag };