@effected/github 0.1.0

package/GraphQL.js

@@ -0,0 +1,183 @@
+import { retryAfterMillisFrom } from "./internal/headers.js";
+import { Schema } from "effect";
+
+//#region src/GraphQL.ts
+/**
+* One entry from a GraphQL response's `errors` array.
+*
+* @public
+*/
+var GraphQLErrorEntry = class extends Schema.Class("GraphQLErrorEntry")({
+	/** GitHub's prose. */
+	message: Schema.String,
+	/** GitHub's own classification, e.g. `"NOT_FOUND"` or `"FORBIDDEN"`. */
+	type: Schema.optionalKey(Schema.String)
+}) {};
+/**
+* A GraphQL call failed.
+*
+* @remarks
+* Separate from `GitHubError` because GraphQL genuinely answers differently:
+* a 200 response can still carry failures, and it carries a **list** of them.
+* `errors` is the one structured field a surveyed consumer actually read.
+*
+* @public
+*/
+var GitHubGraphQLError = class GitHubGraphQLError extends Schema.TaggedErrorClass()("GitHubGraphQLError", {
+	/**
+	* Structural routing, mirroring `GitHubError`'s.
+	*
+	* @remarks
+	* `"alreadyExists"` exists here for the same reason it exists on the REST
+	* error: without it a consumer lowercases the message and greps it for
+	* `"already"` and `"exists"`, which is exactly what one surveyed repo did to
+	* make project creation idempotent.
+	*/
+	kind: Schema.Literals([
+		"alreadyExists",
+		"notFound",
+		"rejected",
+		"unauthorized",
+		"rateLimited",
+		"transport",
+		"decode"
+	]),
+	/** The document's name, e.g. `"linkedIssues"` — never the literal `"graphql"`. */
+	operation: Schema.String,
+	/** Human-readable cause, for logs. */
+	reason: Schema.String,
+	/** Everything GitHub reported, in order. */
+	errors: Schema.Array(GraphQLErrorEntry),
+	/** A server-advised delay in milliseconds, read only by the retry schedule. */
+	retryAfterMillis: Schema.optionalKey(Schema.Int),
+	/** The underlying throwable, when one exists. */
+	cause: Schema.optionalKey(Schema.Defect())
+}) {
+	get message() {
+		return `${this.operation} failed: ${this.reason}`;
+	}
+	/** Whether retrying could plausibly succeed. Derived, like the REST error's. */
+	get retryable() {
+		return this.kind === "transport" || this.kind === "rateLimited";
+	}
+	/** A response arrived but did not match the document's declared schema. */
+	static decode(operation, reason, cause) {
+		return new GitHubGraphQLError({
+			kind: "decode",
+			operation,
+			reason,
+			errors: [],
+			...cause !== void 0 ? { cause } : {}
+		});
+	}
+	/**
+	* Classify anything the GraphQL transport threw.
+	*
+	* @remarks
+	* octokit surfaces two different failures here: a `GraphqlResponseError`,
+	* which is an HTTP 200 whose body carries `errors`, and an ordinary HTTP
+	* failure with a `status`. Both arrive as throwables and both are read
+	* structurally, for the same reason the REST classifier does it — the error
+	* classes live in packages this one does not declare.
+	*/
+	static fromThrowable(operation, error, nowMillis) {
+		const record = typeof error === "object" && error !== null ? error : void 0;
+		const status = typeof record?.status === "number" ? record.status : void 0;
+		const headers = asRecord(record?.headers) ?? asRecord(asRecord(record?.response)?.headers);
+		const entries = readEntries(record?.errors);
+		const reason = entries.length > 0 ? entries.map((entry) => entry.message).join("; ") : typeof record?.message === "string" ? record.message : String(error);
+		const retryAfterMillis = retryAfterMillisFrom(headers, nowMillis);
+		return new GitHubGraphQLError({
+			kind: classify(status, entries, reason, retryAfterMillis),
+			operation,
+			reason,
+			errors: entries,
+			...retryAfterMillis !== void 0 ? { retryAfterMillis } : {},
+			cause: error
+		});
+	}
+};
+const asRecord = (value) => typeof value === "object" && value !== null ? value : void 0;
+const readEntries = (value) => {
+	if (!Array.isArray(value)) return [];
+	const entries = [];
+	for (const raw of value) {
+		const record = asRecord(raw);
+		if (record === void 0) continue;
+		const message = typeof record.message === "string" ? record.message : String(raw);
+		const type = typeof record.type === "string" ? record.type : void 0;
+		entries.push(GraphQLErrorEntry.make({
+			message,
+			...type !== void 0 ? { type } : {}
+		}));
+	}
+	return entries;
+};
+const classify = (status, entries, reason, retryAfterMillis) => {
+	if (reason.toLowerCase().includes("already exists") || entries.some((entry) => entry.message.toLowerCase().includes("already exists"))) return "alreadyExists";
+	if (entries.some((entry) => entry.type === "NOT_FOUND")) return "notFound";
+	if (entries.some((entry) => entry.type === "FORBIDDEN" || entry.type === "UNAUTHORIZED")) return "unauthorized";
+	if (entries.some((entry) => entry.type === "RATE_LIMITED")) return "rateLimited";
+	if (status === void 0) return entries.length > 0 ? "rejected" : "transport";
+	if (status === 404) return "notFound";
+	if (status === 401) return "unauthorized";
+	if (status === 429) return "rateLimited";
+	if (status === 403) return retryAfterMillis !== void 0 ? "rateLimited" : "unauthorized";
+	if (status >= 500) return "transport";
+	return "rejected";
+};
+/**
+* A named GraphQL document, its variables, and how to read its answer.
+*
+* @remarks
+* This is the mechanism that makes `client.graphql` return a **domain value**
+* rather than an `unknown` the caller casts. The package this replaces took a
+* query string and a caller-chosen type parameter with nothing connecting them,
+* so every consumer wrote its own response interface and hoped.
+*
+* The kit owns the documents its resources need; a consumer with a domain of
+* its own — silk-sync-action's ProjectV2 work, for instance — builds its own
+* `GraphQLDocument` and gets the same typing and the same error taxonomy
+* without this package having to know about its schema.
+*
+* @example
+* ```ts
+* import { GraphQLDocument } from "@effected/github";
+* import { Schema } from "effect";
+*
+* const ViewerLogin = GraphQLDocument.make({
+*   name: "viewerLogin",
+*   document: `query { viewer { login } }`,
+*   response: Schema.Struct({ viewer: Schema.Struct({ login: Schema.String }) }),
+* })<{ readonly login: string }>();
+* ```
+*
+* @public
+*/
+var GraphQLDocument = class GraphQLDocument {
+	name;
+	document;
+	decode;
+	encodeVariables;
+	constructor(name, document, decode, encodeVariables) {
+		this.name = name;
+		this.document = document;
+		this.decode = decode;
+		this.encodeVariables = encodeVariables;
+	}
+	/**
+	* Build a document from a response schema.
+	*
+	* @remarks
+	* Curried, because `A` is inferred from `response` while `V` is stated:
+	* TypeScript takes explicit type arguments all-or-nothing, so a single call
+	* would force the caller to spell out the decoded type as well.
+	*/
+	static make(options) {
+		const decode = Schema.decodeUnknownEffect(options.response);
+		return (encodeVariables) => new GraphQLDocument(options.name, options.document, (raw) => decode(raw), encodeVariables ?? ((variables) => variables));
+	}
+};
+
+//#endregion
+export { GitHubGraphQLError, GraphQLDocument, GraphQLErrorEntry };

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Spencer Beggs
+
+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/PullRequest.js

@@ -0,0 +1,300 @@
+import { GitHubError } from "./GitHubError.js";
+import { GraphQLDocument } from "./GraphQL.js";
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { PageOptions } from "./Rest.js";
+import { Context, DateTime, Effect, Layer, Option, Schema } from "effect";
+
+//#region src/PullRequest.ts
+/** How a pull request is merged. @public */
+const MergeMethod = Schema.Literals([
+	"merge",
+	"squash",
+	"rebase"
+]);
+/**
+* A pull request, projected to what callers read.
+*
+* @public
+*/
+var PullRequestInfo = class extends Schema.Class("PullRequestInfo")({
+	/** The number in `#123`. */
+	number: Schema.Int,
+	/** The GraphQL node id, which the auto-merge mutations need. */
+	nodeId: Schema.String,
+	/** The web URL. */
+	url: Schema.String,
+	title: Schema.String,
+	state: Schema.Literals(["open", "closed"]),
+	/** The source branch name. */
+	head: Schema.String,
+	/** The target branch name. */
+	base: Schema.String,
+	draft: Schema.Boolean,
+	merged: Schema.Boolean,
+	/**
+	* When it merged, if it did.
+	*
+	* @remarks
+	* An `Option`, not an optional field. Whether a pull request has merged is a
+	* fact GitHub always reports, so modelling it as "maybe absent" would be
+	* modelling a gap in our fixtures rather than a gap in the domain.
+	*/
+	mergedAt: Schema.Option(Schema.DateTimeUtcFromString),
+	/** The description, when GitHub sent one. */
+	body: Schema.optionalKey(Schema.String),
+	/** The merge commit, once there is one. */
+	mergeCommitSha: Schema.optionalKey(Schema.String)
+}) {};
+const AutoMergeResponse = Schema.Struct({});
+const EnableAutoMerge = GraphQLDocument.make({
+	name: "enablePullRequestAutoMerge",
+	document: `mutation ($pullRequestId: ID!, $mergeMethod: PullRequestMergeMethod!) {
+  enablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId, mergeMethod: $mergeMethod }) {
+    clientMutationId
+  }
+}`,
+	response: AutoMergeResponse
+})();
+const DisableAutoMerge = GraphQLDocument.make({
+	name: "disablePullRequestAutoMerge",
+	document: `mutation ($pullRequestId: ID!) {
+  disablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId }) { clientMutationId }
+}`,
+	response: AutoMergeResponse
+})();
+/** GraphQL spells the merge methods in capitals. */
+const GRAPHQL_MERGE_METHOD = {
+	merge: "MERGE",
+	squash: "SQUASH",
+	rebase: "REBASE"
+};
+/**
+* Pull requests.
+*
+* @public
+*/
+var PullRequest = class PullRequest extends Context.Service()("@effected/github/PullRequest") {
+	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")),
+		listFiles: overrides.listFiles ?? (() => unstubbed("listFiles")),
+		listAssociatedWithCommit: overrides.listAssociatedWithCommit ?? (() => unstubbed("listAssociatedWithCommit")),
+		create: overrides.create ?? (() => unstubbed("create")),
+		update: overrides.update ?? (() => unstubbed("update")),
+		upsert: overrides.upsert ?? (() => unstubbed("upsert")),
+		merge: overrides.merge ?? (() => unstubbed("merge")),
+		addLabels: overrides.addLabels ?? (() => unstubbed("addLabels")),
+		requestReviewers: overrides.requestReviewers ?? (() => unstubbed("requestReviewers")),
+		setAutoMerge: overrides.setAutoMerge ?? (() => unstubbed("setAutoMerge"))
+	});
+	/** {@link PullRequest.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(PullRequest, PullRequest.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`PullRequest.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+const project = (raw) => Effect.try({
+	try: () => PullRequestInfo.make({
+		number: raw.number,
+		nodeId: raw.node_id,
+		url: raw.html_url,
+		title: raw.title,
+		state: raw.state === "closed" ? "closed" : "open",
+		head: raw.head.ref,
+		base: raw.base.ref,
+		draft: raw.draft ?? false,
+		merged: raw.merged ?? raw.merged_at != null,
+		mergedAt: raw.merged_at == null ? Option.none() : Option.some(DateTime.makeUnsafe(raw.merged_at)),
+		...raw.body != null ? { body: raw.body } : {},
+		...raw.merge_commit_sha != null ? { mergeCommitSha: raw.merge_commit_sha } : {}
+	}),
+	catch: (error) => GitHubError.decode("PullRequest", "GitHub returned an unexpected pull request", error)
+});
+/** `owner:branch` is what GitHub's `head` filter wants for a cross-fork search. */
+const qualifyHead = (owner, head) => head.includes(":") ? head : `${owner}:${head}`;
+const make = (client) => {
+	const list = Effect.fn("PullRequest.list")(function* (options) {
+		const { owner, repo } = yield* Repo;
+		const raw = yield* client.paginate("GET /repos/{owner}/{repo}/pulls", {
+			owner,
+			repo,
+			...options?.state !== void 0 ? { state: options.state } : {},
+			...options?.head !== void 0 ? { head: qualifyHead(owner, options.head) } : {},
+			...options?.base !== void 0 ? { base: options.base } : {}
+		}, options?.page);
+		return yield* Effect.forEach(raw, project);
+	});
+	const create = Effect.fn("PullRequest.create")(function* (input) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			head: input.head,
+			base: input.base
+		});
+		const created = yield* client.request("POST /repos/{owner}/{repo}/pulls", {
+			owner,
+			repo,
+			title: input.title,
+			head: input.head,
+			base: input.base,
+			...input.body !== void 0 ? { body: input.body } : {},
+			...input.draft !== void 0 ? { draft: input.draft } : {}
+		});
+		return yield* project(created);
+	});
+	const update = Effect.fn("PullRequest.update")(function* (number, patch) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			number
+		});
+		const updated = yield* client.request("PATCH /repos/{owner}/{repo}/pulls/{pull_number}", {
+			owner,
+			repo,
+			pull_number: number,
+			...patch.title !== void 0 ? { title: patch.title } : {},
+			...patch.body !== void 0 ? { body: patch.body } : {},
+			...patch.state !== void 0 ? { state: patch.state } : {},
+			...patch.base !== void 0 ? { base: patch.base } : {}
+		});
+		return yield* project(updated);
+	});
+	return {
+		list,
+		create,
+		update,
+		get: Effect.fn("PullRequest.get")(function* (number) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				number
+			});
+			const raw = yield* client.request("GET /repos/{owner}/{repo}/pulls/{pull_number}", {
+				owner,
+				repo,
+				pull_number: number
+			});
+			return yield* project(raw);
+		}),
+		listFiles: Effect.fn("PullRequest.listFiles")(function* (number, options) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				number
+			});
+			return (yield* client.paginate("GET /repos/{owner}/{repo}/pulls/{pull_number}/files", {
+				owner,
+				repo,
+				pull_number: number
+			}, options?.page)).map((file) => file.filename);
+		}),
+		listAssociatedWithCommit: Effect.fn("PullRequest.listAssociatedWithCommit")(function* (sha, options) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				sha
+			});
+			const raw = yield* client.paginate("GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", {
+				owner,
+				repo,
+				commit_sha: sha
+			}, options?.page);
+			return yield* Effect.forEach(raw, project);
+		}),
+		upsert: Effect.fn("PullRequest.upsert")(function* (input) {
+			const found = (yield* list({
+				head: input.head,
+				base: input.base,
+				state: "open",
+				page: PageOptions.make({
+					perPage: 1,
+					maxPages: 1
+				})
+			}))[0];
+			if (found === void 0) return {
+				pullRequest: yield* create(input),
+				created: true
+			};
+			const patch = {
+				title: input.title,
+				...input.body !== void 0 ? { body: input.body } : {}
+			};
+			return {
+				pullRequest: yield* update(found.number, patch),
+				created: false
+			};
+		}),
+		merge: Effect.fn("PullRequest.merge")(function* (number, options) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				number,
+				method: options?.method ?? "merge"
+			});
+			return (yield* client.request("PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge", {
+				owner,
+				repo,
+				pull_number: number,
+				...options?.method !== void 0 ? { merge_method: options.method } : {},
+				...options?.commitTitle !== void 0 ? { commit_title: options.commitTitle } : {},
+				...options?.commitMessage !== void 0 ? { commit_message: options.commitMessage } : {}
+			})).sha;
+		}),
+		addLabels: Effect.fn("PullRequest.addLabels")(function* (number, labels) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				number,
+				labels: labels.length
+			});
+			yield* client.request("POST /repos/{owner}/{repo}/issues/{issue_number}/labels", {
+				owner,
+				repo,
+				issue_number: number,
+				labels: [...labels]
+			});
+		}),
+		requestReviewers: Effect.fn("PullRequest.requestReviewers")(function* (number, reviewers) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				number
+			});
+			yield* client.request("POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", {
+				owner,
+				repo,
+				pull_number: number,
+				...reviewers.users !== void 0 ? { reviewers: [...reviewers.users] } : {},
+				...reviewers.teams !== void 0 ? { team_reviewers: [...reviewers.teams] } : {}
+			});
+		}),
+		setAutoMerge: Effect.fn("PullRequest.setAutoMerge")(function* (pullRequest, method) {
+			yield* Effect.annotateCurrentSpan({
+				number: pullRequest.number,
+				method
+			});
+			if (method === "off") {
+				yield* client.graphql(DisableAutoMerge, { pullRequestId: pullRequest.nodeId });
+				return;
+			}
+			yield* client.graphql(EnableAutoMerge, {
+				pullRequestId: pullRequest.nodeId,
+				mergeMethod: GRAPHQL_MERGE_METHOD[method]
+			});
+		})
+	};
+};
+
+//#endregion
+export { MergeMethod, PullRequest, PullRequestInfo };

package/PullRequestComment.js

@@ -0,0 +1,132 @@
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { Context, Effect, Layer, Option, Schema } from "effect";
+
+//#region src/PullRequestComment.ts
+/**
+* The hidden marker that makes a comment findable again.
+*
+* @remarks
+* A pure class, not a hardcoded string. The surface this replaces baked
+* `<!-- savvy-web:${key} -->` into the library — one vendor's name, inside a
+* package meant to be general. Here the namespace is the caller's, the marker is
+* testable without a client, and the library has no opinion about whose comments
+* these are.
+*
+* @public
+*/
+var CommentMarker = class extends Schema.Class("CommentMarker")({
+	/** Whose comments these are, e.g. your action's name. */
+	namespace: Schema.NonEmptyString,
+	/** Which comment, within that namespace. */
+	key: Schema.NonEmptyString
+}) {
+	/** The HTML comment appended to a body so the comment can be found again. */
+	get html() {
+		return `<!-- ${this.namespace}:${this.key} -->`;
+	}
+	/** Does this body carry the marker? */
+	matches(body) {
+		return body.includes(this.html);
+	}
+};
+/**
+* A comment this package wrote or found.
+*
+* @public
+*/
+var CommentRecord = class extends Schema.Class("CommentRecord")({
+	id: Schema.Int,
+	body: Schema.String,
+	url: Schema.String
+}) {};
+/**
+* Sticky comments.
+*
+* @public
+*/
+var PullRequestComment = class PullRequestComment extends Context.Service()("@effected/github/PullRequestComment") {
+	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")),
+		find: overrides.find ?? (() => unstubbed("find")),
+		delete: overrides.delete ?? (() => unstubbed("delete"))
+	});
+	/** {@link PullRequestComment.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(PullRequestComment, PullRequestComment.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`PullRequestComment.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+const recordOf = (raw) => CommentRecord.make({
+	id: raw.id,
+	body: raw.body ?? "",
+	url: raw.html_url
+});
+const make = (client) => {
+	const create = Effect.fn("PullRequestComment.create")(function* (issueNumber, body) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			issueNumber
+		});
+		const created = yield* client.request("POST /repos/{owner}/{repo}/issues/{issue_number}/comments", {
+			owner,
+			repo,
+			issue_number: issueNumber,
+			body
+		});
+		return recordOf(created);
+	});
+	const find = Effect.fn("PullRequestComment.find")(function* (issueNumber, marker, options) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			issueNumber,
+			marker: marker.key
+		});
+		const found = (yield* client.paginate("GET /repos/{owner}/{repo}/issues/{issue_number}/comments", {
+			owner,
+			repo,
+			issue_number: issueNumber
+		}, options?.page)).find((comment) => marker.matches(comment.body ?? ""));
+		return found === void 0 ? Option.none() : Option.some(recordOf(found));
+	});
+	return {
+		create,
+		find,
+		upsert: Effect.fn("PullRequestComment.upsert")(function* (issueNumber, marker, body) {
+			const { owner, repo } = yield* Repo;
+			const marked = `${body}\n\n${marker.html}`;
+			const existing = yield* find(issueNumber, marker);
+			if (Option.isNone(existing)) return yield* create(issueNumber, marked);
+			const updated = yield* client.request("PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}", {
+				owner,
+				repo,
+				comment_id: existing.value.id,
+				body: marked
+			});
+			return recordOf(updated);
+		}),
+		delete: Effect.fn("PullRequestComment.delete")(function* (commentId) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				commentId
+			});
+			yield* client.request("DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}", {
+				owner,
+				repo,
+				comment_id: commentId
+			});
+		})
+	};
+};
+
+//#endregion
+export { CommentMarker, CommentRecord, PullRequestComment };