@effected/github 0.1.0

package/ArtifactMetadata.js

@@ -0,0 +1,62 @@
+import { GitHubClient } from "./GitHubClient.js";
+import { Context, Effect, Layer, Schema } from "effect";
+
+//#region src/ArtifactMetadata.ts
+/**
+* What to record about a published artifact.
+*
+* @remarks
+* These are the fields the endpoint actually accepts. The version this replaces
+* declared a `version` field the endpoint has no notion of — a fabricated key
+* that a `Record<string, unknown>` body accepted silently and the generated
+* types reject outright.
+*
+* @public
+*/
+var StorageRecordInput = class extends Schema.Class("StorageRecordInput")({
+	/** The artifact's package URL (purl). */
+	name: Schema.NonEmptyString,
+	/** Its content digest, as `algorithm:hex`. */
+	digest: Schema.NonEmptyString,
+	/** The registry's base URL. */
+	registryUrl: Schema.NonEmptyString,
+	/** The repository name **within the registry**. */
+	repository: Schema.NonEmptyString,
+	/** Where the artifact is stored, when there is a direct URL. */
+	artifactUrl: Schema.optionalKey(Schema.String),
+	/** The artifact's path within the registry, when there is one. */
+	path: Schema.optionalKey(Schema.String)
+}) {};
+/**
+* Artifact metadata.
+*
+* @public
+*/
+var ArtifactMetadata = class ArtifactMetadata extends Context.Service()("@effected/github/ArtifactMetadata") {
+	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
+	/** An in-memory double; unstubbed members die naming themselves. */
+	static makeTest = (overrides = {}) => ({ createStorageRecord: overrides.createStorageRecord ?? (() => unstubbed("createStorageRecord")) });
+	/** {@link ArtifactMetadata.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(ArtifactMetadata, ArtifactMetadata.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`ArtifactMetadata.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+const make = (client) => ({ createStorageRecord: Effect.fn("ArtifactMetadata.createStorageRecord")(function* (org, input) {
+	yield* Effect.annotateCurrentSpan({
+		org,
+		artifact: input.name
+	});
+	return ((yield* client.request("POST /orgs/{org}/artifacts/metadata/storage-record", {
+		org,
+		name: input.name,
+		digest: input.digest,
+		registry_url: input.registryUrl,
+		repository: input.repository,
+		...input.artifactUrl !== void 0 ? { artifact_url: input.artifactUrl } : {},
+		...input.path !== void 0 ? { path: input.path } : {}
+	})).storage_records ?? []).flatMap((record) => typeof record.id === "number" ? [record.id] : []);
+}) });
+
+//#endregion
+export { ArtifactMetadata, StorageRecordInput };

package/Attestation.js

@@ -0,0 +1,106 @@
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { Context, Effect, Layer, Schema } from "effect";
+
+//#region src/Attestation.ts
+/**
+* The api-version this surface pins.
+*
+* @remarks
+* The legacy shape, which inlines the whole bundle in the listing, is deprecated
+* with a stated sunset. Pinning the version means the response is on a contract
+* the generated types do not describe — which is why this module is the one that
+* uses `requestDecoded` with owned schemas rather than the route table.
+*/
+const API_VERSION = "2026-03-10";
+/**
+* A stored attestation.
+*
+* @public
+*/
+var AttestationRecord = class extends Schema.Class("AttestationRecord")({
+	/** GitHub's id for it, when the response carried one. */
+	id: Schema.optionalKey(Schema.Int),
+	/** Where a human can look at it. */
+	url: Schema.String
+}) {};
+/**
+* One entry from an attestation listing.
+*
+* @public
+*/
+var AttestationListEntry = class extends Schema.Class("AttestationListEntry")({
+	/** Where the bundle lives. */
+	url: Schema.String,
+	/** The in-toto predicate type, when the listing reported one. */
+	predicateType: Schema.optionalKey(Schema.String)
+}) {};
+const UploadResponse = Schema.Struct({ id: Schema.optionalKey(Schema.Int) });
+const ListResponse = Schema.Struct({ attestations: Schema.optionalKey(Schema.Array(Schema.Struct({
+	id: Schema.optionalKey(Schema.Int),
+	bundle_url: Schema.optionalKey(Schema.String),
+	predicate_type: Schema.optionalKey(Schema.String)
+}))) });
+/**
+* Attestations.
+*
+* @public
+*/
+var Attestation = class Attestation extends Context.Service()("@effected/github/Attestation") {
+	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
+	/** An in-memory double; unstubbed members die naming themselves. */
+	static makeTest = (overrides = {}) => ({
+		upload: overrides.upload ?? (() => unstubbed("upload")),
+		listForSubject: overrides.listForSubject ?? (() => unstubbed("listForSubject"))
+	});
+	/** {@link Attestation.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(Attestation, Attestation.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`Attestation.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+const make = (client) => ({
+	upload: Effect.fn("Attestation.upload")(function* (bundle) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo
+		});
+		const stored = yield* client.requestDecoded("POST /repos/{owner}/{repo}/attestations", {
+			owner,
+			repo,
+			bundle,
+			headers: { "x-github-api-version": API_VERSION }
+		}, UploadResponse);
+		return AttestationRecord.make({
+			...stored.id !== void 0 ? { id: stored.id } : {},
+			url: `https://github.com/${owner}/${repo}/attestations/${stored.id ?? ""}`
+		});
+	}),
+	listForSubject: Effect.fn("Attestation.listForSubject")(function* (sha256, options) {
+		const { owner, repo } = yield* Repo;
+		const digest = sha256.startsWith("sha256:") ? sha256 : `sha256:${sha256}`;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			digest
+		});
+		return ((yield* client.requestDecoded("GET /repos/{owner}/{repo}/attestations/{subject_digest}", {
+			owner,
+			repo,
+			subject_digest: digest,
+			...options?.predicateType !== void 0 ? { predicate_type: options.predicateType } : {},
+			headers: { "x-github-api-version": API_VERSION }
+		}, ListResponse).pipe(Effect.catchIf((error) => error.kind === "notFound" || error.status === 422 && error.kind === "rejected", () => Effect.succeed({ attestations: [] })))).attestations ?? []).flatMap((entry) => {
+			const url = entry.bundle_url ?? (entry.id !== void 0 ? `https://github.com/${owner}/${repo}/attestations/${entry.id}` : void 0);
+			if (url === void 0) return [];
+			return [AttestationListEntry.make({
+				url,
+				...entry.predicate_type !== void 0 ? { predicateType: entry.predicate_type } : {}
+			})];
+		});
+	})
+});
+
+//#endregion
+export { Attestation, AttestationListEntry, AttestationRecord };

package/CheckRun.js

@@ -0,0 +1,286 @@
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { Cause, Context, Effect, Exit, Layer, Ref, Schema } from "effect";
+
+//#region src/CheckRun.ts
+/** How a check run finished. @public */
+const CheckConclusion = Schema.Literals([
+	"success",
+	"failure",
+	"neutral",
+	"cancelled",
+	"timed_out",
+	"action_required",
+	"skipped"
+]);
+/** How serious an annotation is. @public */
+const AnnotationLevel = Schema.Literals([
+	"notice",
+	"warning",
+	"failure"
+]);
+/**
+* One annotation on a check run.
+*
+* @public
+*/
+var Annotation = class extends Schema.Class("Annotation")({
+	/** Repository-relative path. */
+	path: Schema.String,
+	/** First line of the range, 1-based. */
+	startLine: Schema.Int,
+	/** Last line of the range, 1-based. */
+	endLine: Schema.Int,
+	level: AnnotationLevel,
+	message: Schema.String,
+	title: Schema.optionalKey(Schema.String)
+}) {};
+/**
+* A check run's rendered output.
+*
+* @remarks
+* GitHub's limits are **byte** limits, and that distinction is the whole reason
+* this class exists rather than a struct: `✅`, `❌`, `🦋` and `│` cost several
+* bytes each, so a character-count check passes while the request comes back
+* 422 saying *"summary exceeds a maximum bytesize of 65535"*. One consumer hit
+* exactly that and wrote the truncation by hand.
+*
+* @public
+*/
+var CheckRunOutput = class CheckRunOutput extends Schema.Class("CheckRunOutput")({
+	title: Schema.String,
+	/** Markdown shown under the title. Capped at 65535 **bytes**. */
+	summary: Schema.String,
+	/** Longer markdown. Capped at 65535 **bytes**. */
+	text: Schema.optionalKey(Schema.String),
+	/** At most 50 per request; the rest are dropped by {@link CheckRunOutput.truncated}. */
+	annotations: Schema.optionalKey(Schema.Array(Annotation))
+}) {
+	/** GitHub's cap on `summary` and `text`, in UTF-8 bytes. */
+	static LIMIT_BYTES = 65535;
+	/** GitHub's cap on annotations per request. */
+	static MAX_ANNOTATIONS = 50;
+	/** Appended when a field had to be cut. */
+	static NOTICE = "\n\n_…truncated (exceeded GitHub's 65535-byte check limit)._";
+	/**
+	* This output, cut to fit GitHub's limits.
+	*
+	* @remarks
+	* Pure, so the byte arithmetic is testable with no client, no layer and no
+	* network — which is what lets a property test hammer it with arbitrary
+	* multi-byte input.
+	*/
+	truncated() {
+		const annotations = this.annotations;
+		return CheckRunOutput.make({
+			title: this.title,
+			summary: capBytes(this.summary),
+			...this.text !== void 0 ? { text: capBytes(this.text) } : {},
+			...annotations !== void 0 ? { annotations: annotations.slice(0, CheckRunOutput.MAX_ANNOTATIONS) } : {}
+		});
+	}
+};
+/**
+* Cut `value` to GitHub's byte budget without leaving a broken code point.
+*
+* @remarks
+* Slicing a UTF-8 buffer mid-character decodes to U+FFFD. Splitting a four-byte
+* code point can produce **more than one** replacement character, so the trim
+* loops rather than dropping a single one — which is the hardening this needed
+* over the hand-written version it replaces.
+*/
+const capBytes = (value) => {
+	if (Buffer.byteLength(value, "utf8") <= CheckRunOutput.LIMIT_BYTES) return value;
+	const budget = CheckRunOutput.LIMIT_BYTES - Buffer.byteLength(CheckRunOutput.NOTICE, "utf8");
+	let cut = Buffer.from(value, "utf8").subarray(0, budget).toString("utf8");
+	while (cut.endsWith("�")) cut = cut.slice(0, -1);
+	return `${cut}${CheckRunOutput.NOTICE}`;
+};
+/**
+* A check run as GitHub reports it.
+*
+* @public
+*/
+var CheckRunRef = class extends Schema.Class("CheckRunRef")({
+	id: Schema.Int,
+	name: Schema.String,
+	/** The web URL. */
+	url: Schema.String,
+	status: Schema.String
+}) {};
+/**
+* Check runs.
+*
+* @public
+*/
+var CheckRun = class CheckRun extends Context.Service()("@effected/github/CheckRun") {
+	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")),
+		get: overrides.get ?? (() => unstubbed("get")),
+		update: overrides.update ?? (() => unstubbed("update")),
+		complete: overrides.complete ?? (() => unstubbed("complete")),
+		withCheckRun: overrides.withCheckRun ?? (() => unstubbed("withCheckRun"))
+	});
+	/** {@link CheckRun.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(CheckRun, CheckRun.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`CheckRun.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+const wireOutput = (output) => {
+	const capped = output.truncated();
+	return {
+		title: capped.title,
+		summary: capped.summary,
+		...capped.text !== void 0 ? { text: capped.text } : {},
+		...capped.annotations !== void 0 ? { annotations: capped.annotations.map((annotation) => ({
+			path: annotation.path,
+			start_line: annotation.startLine,
+			end_line: annotation.endLine,
+			annotation_level: annotation.level,
+			message: annotation.message,
+			...annotation.title !== void 0 ? { title: annotation.title } : {}
+		})) } : {}
+	};
+};
+/**
+* What the bracket concludes when `use` recorded nothing.
+*
+* @remarks
+* **Exit-aware, because a `tap`/`tapError` pair is not.** Those two fire on
+* success and on a *typed* failure; an interrupted `use` — a cancelled
+* workflow, a job timeout, a losing branch of a race — and a defect hit
+* neither, and the run stayed `in_progress` forever. GitHub never reaps such a
+* run, so it blocks branch protection until a human deletes it by hand.
+*/
+const defaultConclusion = (name, exit) => {
+	if (Exit.isSuccess(exit)) return {
+		conclusion: "success",
+		output: CheckRunOutput.make({
+			title: name,
+			summary: "Completed successfully."
+		})
+	};
+	const cancelled = Cause.hasInterruptsOnly(exit.cause);
+	return {
+		conclusion: cancelled ? "cancelled" : "failure",
+		output: CheckRunOutput.make({
+			title: name,
+			summary: cancelled ? "Cancelled before completion." : "Failed."
+		})
+	};
+};
+/**
+* Conclude a bracketed run: the verdict `use` recorded, or the exit's default.
+*
+* @remarks
+* **`recorded` wins on every exit path**, including failure and interruption.
+* How the *check* ran and how the surrounding *program* ended are different
+* questions, and only `use` knows the first one — a findings-derived
+* `"neutral"` must not be overwritten by a `"cancelled"` just because the job
+* was torn down afterwards.
+*
+* `Effect.onExit` runs its finalizer **uninterruptibly**, which is what lets
+* the concluding request survive the interrupt that triggered it.
+*
+* Only the success path keeps the error channel: failing to record a success
+* is a real failure the caller should see. On the other paths the call is
+* ignored, because neither an interrupt nor an existing failure should be
+* replaced by whatever went wrong while reporting it — and that choice is the
+* **exit's**, independent of whose verdict is being written.
+*/
+const concludeFor = (name, id, exit, recorded, complete) => {
+	const settled = recorded ?? defaultConclusion(name, exit);
+	const write = complete(id, settled.conclusion, settled.output);
+	return Exit.isSuccess(exit) ? write : Effect.ignore(write);
+};
+const refOf = (raw) => CheckRunRef.make({
+	id: raw.id,
+	name: raw.name,
+	url: raw.html_url ?? "",
+	status: raw.status
+});
+const make = (client) => {
+	const create = Effect.fn("CheckRun.create")(function* (name, headSha) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			name,
+			headSha
+		});
+		const created = yield* client.request("POST /repos/{owner}/{repo}/check-runs", {
+			owner,
+			repo,
+			name,
+			head_sha: headSha,
+			status: "in_progress",
+			started_at: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return refOf(created);
+	});
+	const complete = Effect.fn("CheckRun.complete")(function* (id, conclusion, output) {
+		const { owner, repo } = yield* Repo;
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			id,
+			conclusion
+		});
+		yield* client.request("PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}", {
+			owner,
+			repo,
+			check_run_id: id,
+			status: "completed",
+			conclusion,
+			completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+			...output !== void 0 ? { output: wireOutput(output) } : {}
+		});
+	});
+	return {
+		create,
+		complete,
+		get: Effect.fn("CheckRun.get")(function* (id) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				id
+			});
+			const raw = yield* client.request("GET /repos/{owner}/{repo}/check-runs/{check_run_id}", {
+				owner,
+				repo,
+				check_run_id: id
+			});
+			return refOf(raw);
+		}),
+		update: Effect.fn("CheckRun.update")(function* (id, output) {
+			const { owner, repo } = yield* Repo;
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				id
+			});
+			yield* client.request("PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}", {
+				owner,
+				repo,
+				check_run_id: id,
+				output: wireOutput(output)
+			});
+		}),
+		withCheckRun: (name, headSha, use) => Effect.gen(function* () {
+			const run = yield* create(name, headSha);
+			const recorded = yield* Ref.make(void 0);
+			const conclude = (conclusion, output) => Ref.set(recorded, {
+				conclusion,
+				output
+			});
+			return yield* use(run.id, conclude).pipe(Effect.onExit((exit) => Effect.flatMap(Ref.get(recorded), (chosen) => concludeFor(name, run.id, exit, chosen, complete))));
+		})
+	};
+};
+
+//#endregion
+export { Annotation, AnnotationLevel, CheckConclusion, CheckRun, CheckRunOutput, CheckRunRef };

package/GitBranch.js

@@ -0,0 +1,171 @@
+import { GitHubError } from "./GitHubError.js";
+import { GraphQLDocument } from "./GraphQL.js";
+import { GitHubClient } from "./GitHubClient.js";
+import { Repo } from "./Repo.js";
+import { Context, Effect, Layer, Option, Schema } from "effect";
+
+//#region src/GitBranch.ts
+const CreateLinkedBranch = GraphQLDocument.make({
+	name: "createLinkedBranch",
+	document: `mutation ($issueId: ID!, $name: String!, $oid: GitObjectID!, $repositoryId: ID!) {
+  createLinkedBranch(input: { issueId: $issueId, name: $name, oid: $oid, repositoryId: $repositoryId }) {
+    linkedBranch { id }
+  }
+}`,
+	response: Schema.Struct({})
+})();
+/**
+* Branches, as refs.
+*
+* @public
+*/
+var GitBranch = class GitBranch extends Context.Service()("@effected/github/GitBranch") {
+	/**
+	* @remarks
+	* The callback is written `(client) => make(client)` rather than passed as
+	* `make` directly, and that is load-bearing: a static initializer runs while
+	* the module body is still evaluating, so naming a `const` declared further
+	* down throws `Cannot access 'make' before initialization` **at import time**,
+	* with a clean typecheck. Wrapping it in an arrow defers the read to when the
+	* layer is built.
+	*/
+	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")),
+		exists: overrides.exists ?? (() => unstubbed("exists")),
+		sha: overrides.sha ?? (() => unstubbed("sha")),
+		shaOption: overrides.shaOption ?? (() => unstubbed("shaOption")),
+		reset: overrides.reset ?? (() => unstubbed("reset")),
+		delete: overrides.delete ?? (() => unstubbed("delete")),
+		createLinked: overrides.createLinked ?? (() => unstubbed("createLinked"))
+	});
+	/** {@link GitBranch.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(GitBranch, GitBranch.makeTest(overrides));
+};
+const unstubbed = (member) => {
+	throw new Error(`GitBranch.makeTest: ${member}() was called but not stubbed — pass an override.`);
+};
+/**
+* `main`, `refs/heads/main` and `heads/main` all name the same branch.
+*
+* @remarks
+* GitHub's own API is inconsistent here — creation wants the full
+* `refs/heads/x`, every other operation wants `heads/x` — so callers routinely
+* pass whichever they last saw. Normalizing once is cheaper than documenting it
+* seven times.
+*/
+const shortName = (name) => name.replace(/^refs\/heads\//, "").replace(/^heads\//, "");
+const rejectEmpty = (operation, name) => {
+	const short = shortName(name).trim();
+	return short === "" ? Effect.fail(GitHubError.rejected(operation, 422, "a branch name is required")) : Effect.succeed(short);
+};
+/**
+* Every method resolves {@link Repo} per call rather than once at layer
+* construction.
+*
+* @remarks
+* This is what makes `Repo.provide(other)` mean something. Capturing the
+* coordinate when the layer is built would give each method `R = never` — the
+* house pattern for a stable dependency — but it would also make a scoped
+* override silently do nothing, because the resource would already hold the
+* repository it was built with. The repository is precisely the dependency that
+* is *not* stable: silk-sync-action loops one program over many target
+* repositories.
+*
+* The client stays resolved at construction, so this costs one context read per
+* call and nothing else.
+*/
+const make = (client) => {
+	const create = Effect.fn("GitBranch.create")(function* (branch, sha) {
+		const { owner, repo } = yield* Repo;
+		const short = yield* rejectEmpty("GitBranch.create", branch);
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			branch: short
+		});
+		yield* client.request("POST /repos/{owner}/{repo}/git/refs", {
+			owner,
+			repo,
+			ref: `refs/heads/${short}`,
+			sha
+		});
+	});
+	const reset = Effect.fn("GitBranch.reset")(function* (branch, sha) {
+		const { owner, repo } = yield* Repo;
+		const short = yield* rejectEmpty("GitBranch.reset", branch);
+		yield* Effect.annotateCurrentSpan({
+			owner,
+			repo,
+			branch: short
+		});
+		yield* client.request("PATCH /repos/{owner}/{repo}/git/refs/{ref}", {
+			owner,
+			repo,
+			ref: `heads/${short}`,
+			sha,
+			force: true
+		});
+	});
+	const upsert = Effect.fn("GitBranch.upsert")(function* (branch, sha) {
+		const short = yield* rejectEmpty("GitBranch.upsert", branch);
+		yield* Effect.annotateCurrentSpan({ branch: short });
+		return yield* create(short, sha).pipe(Effect.as("created"), Effect.catchIf(GitHubError.hasKind("alreadyExists"), () => Effect.as(reset(short, sha), "reset")));
+	});
+	const readRef = (operation, branch) => Effect.gen(function* () {
+		const { owner, repo } = yield* Repo;
+		const short = yield* rejectEmpty(operation, branch);
+		return yield* client.request("GET /repos/{owner}/{repo}/git/ref/{ref}", {
+			owner,
+			repo,
+			ref: `heads/${short}`
+		});
+	});
+	const shaOption = Effect.fn("GitBranch.shaOption")(function* (branch) {
+		yield* Effect.annotateCurrentSpan({ branch });
+		return yield* readRef("GitBranch.shaOption", branch).pipe(Effect.map((ref) => Option.some(ref.object.sha)), Effect.catchIf(GitHubError.hasKind("notFound"), () => Effect.succeed(Option.none())));
+	});
+	return {
+		create,
+		upsert,
+		reset,
+		exists: Effect.fn("GitBranch.exists")(function* (branch) {
+			yield* Effect.annotateCurrentSpan({ branch });
+			return yield* Effect.map(shaOption(branch), Option.isSome);
+		}),
+		sha: Effect.fn("GitBranch.sha")(function* (branch) {
+			yield* Effect.annotateCurrentSpan({ branch });
+			return (yield* readRef("GitBranch.sha", branch)).object.sha;
+		}),
+		shaOption,
+		createLinked: Effect.fn("GitBranch.createLinked")(function* (input) {
+			const short = shortName(input.name);
+			yield* Effect.annotateCurrentSpan({ branch: short });
+			yield* client.graphql(CreateLinkedBranch, {
+				issueId: input.issueNodeId,
+				repositoryId: input.repositoryNodeId,
+				name: short,
+				oid: input.sha
+			});
+		}),
+		delete: Effect.fn("GitBranch.delete")(function* (branch) {
+			const { owner, repo } = yield* Repo;
+			const short = yield* rejectEmpty("GitBranch.delete", branch);
+			yield* Effect.annotateCurrentSpan({
+				owner,
+				repo,
+				branch: short
+			});
+			yield* client.request("DELETE /repos/{owner}/{repo}/git/refs/{ref}", {
+				owner,
+				repo,
+				ref: `heads/${short}`
+			});
+		})
+	};
+};
+
+//#endregion
+export { GitBranch };