@effected/github 0.23.0 → 0.24.0

package/ActionsOidc.js

@@ -191,10 +191,23 @@ const testClaims = (overrides = {}) => ({
 *
 * @public
 */
-const ActionsOidc = {
-	issuer: ISSUER,
-	verify,
-	testClaims
+var ActionsOidc = class {
+	constructor() {}
+	/** The Actions OIDC issuer, `https://token.actions.githubusercontent.com`. */
+	static issuer = ISSUER;
+	/** Verify a runner-issued OIDC token: signature against GitHub's JWKS, iss, aud, exp/nbf, then typed claims. */
+	static verify = verify;
+	/**
+	* A valid claims payload for tests, overridable field by field.
+	*
+	* @remarks
+	* Wire-shaped (snake_case keys, string ids) and complete except for the
+	* time claims `iat` and `exp`, which depend on the clock: a signer stamps
+	* them, as `TestIssuer.sign` from `@effected/jwt/testing` does. `iss` is
+	* {@link ActionsOidc.issuer}; `aud` is a placeholder to override with the
+	* audience under test.
+	*/
+	static testClaims = testClaims;
 };
 
 export { ActionsOidc, ActionsOidcClaims, ActionsOidcClaimsFromWire };

package/ArtifactMetadata.js

@@ -1,3 +1,4 @@
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -37,14 +38,12 @@ var StorageRecordInput = class extends Schema.Class("StorageRecordInput")({
 var ArtifactMetadata = class ArtifactMetadata extends Context.Service()("@effected/github/ArtifactMetadata") {
 	/** The live service, built over a `GitHubClient`. */
 	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")) });
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
+	static makeTest = (overrides = {}) => ({ createStorageRecord: overrides.createStorageRecord ?? (() => dies("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 dies = unstubbed("ArtifactMetadata.makeTest");
 const make = (client) => ({ createStorageRecord: Effect.fn("ArtifactMetadata.createStorageRecord")(function* (input) {
 	const { owner } = yield* Repo;
 	yield* Effect.annotateCurrentSpan({

package/Attestation.js

@@ -1,3 +1,4 @@
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -54,17 +55,15 @@ const ListResponse = Schema.Struct({ attestations: Schema.optionalKey(Schema.Arr
 var Attestation = class Attestation extends Context.Service()("@effected/github/Attestation") {
 	/** The live service, built over a `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		upload: overrides.upload ?? (() => unstubbed("upload")),
-		listForSubject: overrides.listForSubject ?? (() => unstubbed("listForSubject"))
+		upload: overrides.upload ?? (() => dies("upload")),
+		listForSubject: overrides.listForSubject ?? (() => dies("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 dies = unstubbed("Attestation.makeTest");
 const make = (client) => ({
 	upload: Effect.fn("Attestation.upload")(function* (bundle) {
 		const { owner, repo } = yield* Repo;

package/AuthenticatedApp.js

@@ -1,4 +1,5 @@
 import { GitHubError } from "./GitHubError.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { numericId } from "./internal/ids.js";
 import { Context, Effect, Layer, Schema, Stream } from "effect";
@@ -118,20 +119,18 @@ var DeliveryAttempt = class extends Schema.Class("DeliveryAttempt")({
 var AuthenticatedApp = class AuthenticatedApp extends Context.Service()("@effected/github/AuthenticatedApp") {
 	/** The live service, built over an App-JWT `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		get: overrides.get ?? (() => unstubbed("get")),
-		deliveries: overrides.deliveries ?? (() => unstubbed("deliveries")),
-		delivery: overrides.delivery ?? (() => unstubbed("delivery")),
-		redeliver: overrides.redeliver ?? (() => unstubbed("redeliver")),
-		uninstall: overrides.uninstall ?? (() => unstubbed("uninstall"))
+		get: overrides.get ?? (() => dies("get")),
+		deliveries: overrides.deliveries ?? (() => Stream.fromEffect(dies("deliveries"))),
+		delivery: overrides.delivery ?? (() => dies("delivery")),
+		redeliver: overrides.redeliver ?? (() => dies("redeliver")),
+		uninstall: overrides.uninstall ?? (() => dies("uninstall"))
 	});
 	/** {@link AuthenticatedApp.makeTest} behind a `Layer`. */
 	static layerTest = (overrides = {}) => Layer.succeed(AuthenticatedApp, AuthenticatedApp.makeTest(overrides));
 };
-const unstubbed = (member) => {
-	throw new Error(`AuthenticatedApp.makeTest: ${member}() was called but not stubbed — pass an override.`);
-};
+const dies = unstubbed("AuthenticatedApp.makeTest");
 const decodeDelivery = Schema.decodeUnknownEffect(DeliveryAttempt);
 const decodeApp = Schema.decodeUnknownEffect(AppInfo);
 /** A nullable int64 id, narrowed like every other id. */

package/CheckRun.js

@@ -1,4 +1,5 @@
 import { GitHubError } from "./GitHubError.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { numericId } from "./internal/ids.js";
@@ -239,24 +240,22 @@ var CheckRunRef = class extends Schema.Class("CheckRunRef")({
 var CheckRun = class CheckRun extends Context.Service()("@effected/github/CheckRun") {
 	/** The live service, built over a `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		create: overrides.create ?? (() => unstubbed("create")),
-		get: overrides.get ?? (() => unstubbed("get")),
-		update: overrides.update ?? (() => unstubbed("update")),
-		updateRef: overrides.updateRef ?? (() => unstubbed("updateRef")),
-		list: overrides.list ?? (() => unstubbed("list")),
-		findByExternalId: overrides.findByExternalId ?? (() => unstubbed("findByExternalId")),
-		complete: overrides.complete ?? (() => unstubbed("complete")),
-		completeRef: overrides.completeRef ?? (() => unstubbed("completeRef")),
-		withCheckRun: overrides.withCheckRun ?? (() => unstubbed("withCheckRun"))
+		create: overrides.create ?? (() => dies("create")),
+		get: overrides.get ?? (() => dies("get")),
+		update: overrides.update ?? (() => dies("update")),
+		updateRef: overrides.updateRef ?? (() => dies("updateRef")),
+		list: overrides.list ?? (() => dies("list")),
+		findByExternalId: overrides.findByExternalId ?? (() => dies("findByExternalId")),
+		complete: overrides.complete ?? (() => dies("complete")),
+		completeRef: overrides.completeRef ?? (() => dies("completeRef")),
+		withCheckRun: overrides.withCheckRun ?? (() => dies("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 dies = unstubbed("CheckRun.makeTest");
 const wireOutput = (output) => {
 	const capped = output.truncated();
 	return {

package/CodeScanning.js

@@ -1,3 +1,4 @@
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer } from "effect";
@@ -25,17 +26,15 @@ var CodeScanning = class CodeScanning extends Context.Service()("@effected/githu
 	* with a clean typecheck.
 	*/
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		configure: overrides.configure ?? (() => unstubbed("configure")),
-		languages: overrides.languages ?? (() => unstubbed("languages"))
+		configure: overrides.configure ?? (() => dies("configure")),
+		languages: overrides.languages ?? (() => dies("languages"))
 	});
 	/** {@link CodeScanning.makeTest} behind a `Layer`. */
 	static layerTest = (overrides = {}) => Layer.succeed(CodeScanning, CodeScanning.makeTest(overrides));
 };
-const unstubbed = (member) => {
-	throw new Error(`CodeScanning.makeTest: ${member}() was called but not stubbed — pass an override.`);
-};
+const dies = unstubbed("CodeScanning.makeTest");
 const SETUP_KEYS = [
 	"state",
 	"languages",

package/DeploymentEnvironment.js

@@ -1,3 +1,4 @@
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer } from "effect";
@@ -34,18 +35,16 @@ var DeploymentEnvironment = class DeploymentEnvironment extends Context.Service(
 	* further down throws at import time with a clean typecheck.
 	*/
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		upsert: overrides.upsert ?? (() => unstubbed("upsert")),
-		list: overrides.list ?? (() => unstubbed("list")),
-		delete: overrides.delete ?? (() => unstubbed("delete"))
+		upsert: overrides.upsert ?? (() => dies("upsert")),
+		list: overrides.list ?? (() => dies("list")),
+		delete: overrides.delete ?? (() => dies("delete"))
 	});
 	/** {@link DeploymentEnvironment.makeTest} behind a `Layer`. */
 	static layerTest = (overrides = {}) => Layer.succeed(DeploymentEnvironment, DeploymentEnvironment.makeTest(overrides));
 };
-const unstubbed = (member) => {
-	throw new Error(`DeploymentEnvironment.makeTest: ${member}() was called but not stubbed — pass an override.`);
-};
+const dies = unstubbed("DeploymentEnvironment.makeTest");
 const make = (client) => {
 	return {
 		upsert: Effect.fn("DeploymentEnvironment.upsert")(function* (name, config = {}) {

package/GitBranch.js

@@ -1,5 +1,6 @@
 import { GitHubError } from "./GitHubError.js";
 import { GraphQLDocument } from "./GraphQL.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer, Option, Schema } from "effect";
@@ -50,23 +51,21 @@ var GitBranch = class GitBranch extends Context.Service()("@effected/github/GitB
 	* layer is built.
 	*/
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	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"))
+		create: overrides.create ?? (() => dies("create")),
+		upsert: overrides.upsert ?? (() => dies("upsert")),
+		exists: overrides.exists ?? (() => dies("exists")),
+		sha: overrides.sha ?? (() => dies("sha")),
+		shaOption: overrides.shaOption ?? (() => dies("shaOption")),
+		reset: overrides.reset ?? (() => dies("reset")),
+		delete: overrides.delete ?? (() => dies("delete")),
+		createLinked: overrides.createLinked ?? (() => dies("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.`);
-};
+const dies = unstubbed("GitBranch.makeTest");
 /**
 * `main`, `refs/heads/main` and `heads/main` all name the same branch.
 *

package/GitCommit.js

@@ -1,3 +1,4 @@
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -86,19 +87,17 @@ var CommitRef = class extends Schema.Class("CommitRef")({
 var GitCommit = class GitCommit extends Context.Service()("@effected/github/GitCommit") {
 	/** The live service, built over a `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		get: overrides.get ?? (() => unstubbed("get")),
-		createTree: overrides.createTree ?? (() => unstubbed("createTree")),
-		createCommit: overrides.createCommit ?? (() => unstubbed("createCommit")),
-		commitFiles: overrides.commitFiles ?? (() => unstubbed("commitFiles"))
+		get: overrides.get ?? (() => dies("get")),
+		createTree: overrides.createTree ?? (() => dies("createTree")),
+		createCommit: overrides.createCommit ?? (() => dies("createCommit")),
+		commitFiles: overrides.commitFiles ?? (() => dies("commitFiles"))
 	});
 	/** {@link GitCommit.makeTest} behind a `Layer`. */
 	static layerTest = (overrides = {}) => Layer.succeed(GitCommit, GitCommit.makeTest(overrides));
 };
-const unstubbed = (member) => {
-	throw new Error(`GitCommit.makeTest: ${member}() was called but not stubbed — pass an override.`);
-};
+const dies = unstubbed("GitCommit.makeTest");
 /** The Git Database tree entry for one change. */
 const treeEntry = (change) => change._tag === "FileContent" ? {
 	path: change.path,

package/GitHubApp.js

@@ -1,5 +1,6 @@
 import { GitHubError } from "./GitHubError.js";
 import { GitHubGraphQLError } from "./GraphQL.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient, makeClientShape } from "./GitHubClient.js";
 import { numericId } from "./internal/ids.js";
 import { InstallationTokenStore } from "./InstallationTokenStore.js";
@@ -435,16 +436,16 @@ var GitHubApp = class GitHubApp extends Context.Service()("@effected/github/GitH
 		...options,
 		token: cached.token.token
 	})));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => {
-		const token = overrides.token ?? (() => unstubbed("token"));
+		const token = overrides.token ?? (() => dies("token"));
 		return {
 			token,
-			scopedToken: overrides.scopedToken ?? (() => unstubbed("scopedToken")),
-			revoke: overrides.revoke ?? (() => unstubbed("revoke")),
-			identity: overrides.identity ?? (() => unstubbed("identity")),
-			botUser: overrides.botUser ?? (() => unstubbed("botUser")),
-			installations: overrides.installations ?? (() => unstubbed("installations")),
+			scopedToken: overrides.scopedToken ?? (() => dies("scopedToken")),
+			revoke: overrides.revoke ?? (() => dies("revoke")),
+			identity: overrides.identity ?? (() => dies("identity")),
+			botUser: overrides.botUser ?? (() => dies("botUser")),
+			installations: overrides.installations ?? (() => dies("installations")),
 			cachedToken: overrides.cachedToken ?? makeCachedToken(token)
 		};
 	};
@@ -515,9 +516,7 @@ const makeCachedToken = (token) => {
 		};
 	});
 };
-const unstubbed = (member) => {
-	throw new Error(`GitHubApp.makeTest: ${member}() was called but not stubbed — pass an override.`);
-};
+const dies = unstubbed("GitHubApp.makeTest");
 /** Mint an app JWT: iat 60 s in the past (clock drift), exp 9 minutes after now (GitHub caps at 10). */
 const mintJwt = (credentials) => Effect.gen(function* () {
 	const key = yield* JwtKey.fromPkcs8Pem(credentials.privateKey, { alg: "RS256" });

package/GitHubClient.js

@@ -3,6 +3,7 @@ import { GitHubGraphQLError } from "./GraphQL.js";
 import { RetryPolicy } from "./Resilience.js";
 import { makeTransport } from "./internal/octokit.js";
 import { fromArray, paginate } from "./internal/paginate.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { Clock, Config, Context, Effect, Layer, Option, Schema, Stream } from "effect";
 
 // src/GitHubClient.ts
@@ -10,7 +11,7 @@ import { Clock, Config, Context, Effect, Layer, Option, Schema, Stream } from "e
 const DEFAULT_PER_PAGE = 100;
 /**
 * A raw HTTP failure recorded for {@link GitHubClient.layerFixture}, made by
-* {@link (GitHubFixtures:variable).failure}.
+* {@link (GitHubFixtures:class).failure}.
 *
 * @remarks
 * Branded, so a fixture's data payload that happens to have a `status` and a
@@ -45,12 +46,42 @@ const isRawFailure = (value) => typeof value === "object" && value !== null && v
 *
 * @public
 */
-const GitHubFixtures = { failure: (response) => new RawFailure(response) };
+var GitHubFixtures = class {
+	constructor() {}
+	/**
+	* A raw failure: what GitHub answered, classified at call time by the same
+	* classifier the live client uses.
+	*
+	* @remarks
+	* Record it wherever a fixture accepts a `GitHubError` (`request`, and so
+	* `requestDecoded`, and `paginate`). Each call fails with
+	* `GitHubError.fromResponse(route, response, now)`, `now` read from `Clock`,
+	* so a rate-limit reset header is measured against the `TestClock`. Prefer it
+	* to a hand-built `GitHubError` when the test is about GitHub's actual
+	* response: the classification is then the package's, not the test's.
+	*
+	* @example
+	* ```ts
+	* import { GitHubClient, GitHubFixtures } from "@effected/github";
+	*
+	* const layer = GitHubClient.layerFixture({
+	*   request: {
+	*     "POST /repos/{owner}/{repo}/releases": GitHubFixtures.failure({
+	*       status: 422,
+	*       body: {
+	*         message: "Validation Failed",
+	*         errors: [{ resource: "Release", code: "already_exists", field: "tag_name" }],
+	*       },
+	*     }),
+	*   },
+	* });
+	* ```
+	*/
+	static failure = (response) => new RawFailure(response);
+};
 const resolvePolicy = (retry) => retry === void 0 ? RetryPolicy.default : retry === "off" ? RetryPolicy.none : retry;
 const perPageOf = (options) => options?.perPage ?? DEFAULT_PER_PAGE;
-const unstubbed = (member) => {
-	throw new Error(`GitHubClient.makeTest: ${member}() was called but not stubbed — pass an override, or use GitHubClient.layerFixture for recorded responses.`);
-};
+const dies = unstubbed("GitHubClient.makeTest", "pass an override, or use GitHubClient.layerFixture for recorded responses.");
 /**
 * The typed GitHub API client.
 *
@@ -127,11 +158,11 @@ var GitHubClient = class GitHubClient extends Context.Service()("@effected/githu
 	* {@link GitHubClient.layerFixture}.
 	*/
 	static makeTest = (overrides = {}) => ({
-		request: overrides.request ?? (() => unstubbed("request")),
-		requestDecoded: overrides.requestDecoded ?? (() => unstubbed("requestDecoded")),
-		paginate: overrides.paginate ?? (() => unstubbed("paginate")),
-		paginateStream: overrides.paginateStream ?? (() => unstubbed("paginateStream")),
-		graphql: overrides.graphql ?? (() => unstubbed("graphql")),
+		request: overrides.request ?? (() => dies("request")),
+		requestDecoded: overrides.requestDecoded ?? (() => dies("requestDecoded")),
+		paginate: overrides.paginate ?? (() => dies("paginate")),
+		paginateStream: overrides.paginateStream ?? (() => Stream.fromEffect(dies("paginateStream"))),
+		graphql: overrides.graphql ?? (() => dies("graphql")),
 		rateLimit: overrides.rateLimit ?? Effect.succeed(Option.none())
 	});
 	/** {@link GitHubClient.makeTest} behind a `Layer`. */
@@ -150,7 +181,7 @@ var GitHubClient = class GitHubClient extends Context.Service()("@effected/githu
 	*
 	* **It records every call it serves, including one that fails.** A call
 	* answered by a recorded `GitHubError` or a
-	* {@link (GitHubFixtures:variable).failure} is recorded before it fails, so
+	* {@link (GitHubFixtures:class).failure} is recorded before it fails, so
 	* one fixture both records the calls and classifies a raw failure the way
 	* the live client would; there is no need to classify by hand inside a
 	* {@link GitHubClient.layerTest} handler.

package/GitHubCommit.js

@@ -1,4 +1,5 @@
 import { paginate } from "./internal/paginate.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
@@ -114,19 +115,17 @@ var CommitComparison = class extends Schema.Class("CommitComparison")({
 var GitHubCommit = class GitHubCommit extends Context.Service()("@effected/github/GitHubCommit") {
 	/** The live service, built over a `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		get: overrides.get ?? (() => unstubbed("get")),
-		list: overrides.list ?? (() => unstubbed("list")),
-		compare: overrides.compare ?? (() => unstubbed("compare")),
-		changedFiles: overrides.changedFiles ?? (() => unstubbed("changedFiles"))
+		get: overrides.get ?? (() => dies("get")),
+		list: overrides.list ?? (() => dies("list")),
+		compare: overrides.compare ?? (() => dies("compare")),
+		changedFiles: overrides.changedFiles ?? (() => dies("changedFiles"))
 	});
 	/** {@link GitHubCommit.makeTest} behind a `Layer`. */
 	static layerTest = (overrides = {}) => Layer.succeed(GitHubCommit, GitHubCommit.makeTest(overrides));
 };
-const unstubbed = (member) => {
-	throw new Error(`GitHubCommit.makeTest: ${member}() was called but not stubbed — pass an override.`);
-};
+const dies = unstubbed("GitHubCommit.makeTest");
 const summarize = (raw) => CommitSummary.make({
 	sha: raw.sha,
 	message: raw.commit.message,

package/GitHubContent.js

@@ -1,4 +1,5 @@
 import { GitHubError } from "./GitHubError.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer, Option, Result } from "effect";
@@ -35,17 +36,15 @@ const utf8 = new TextDecoder("utf-8", { ignoreBOM: true });
 var GitHubContent = class GitHubContent extends Context.Service()("@effected/github/GitHubContent") {
 	/** The live service, built over a `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		getFile: overrides.getFile ?? (() => unstubbed("getFile")),
-		getFileOption: overrides.getFileOption ?? (() => unstubbed("getFileOption"))
+		getFile: overrides.getFile ?? (() => dies("getFile")),
+		getFileOption: overrides.getFileOption ?? (() => dies("getFileOption"))
 	});
 	/** {@link GitHubContent.makeTest} behind a `Layer`. */
 	static layerTest = (overrides = {}) => Layer.succeed(GitHubContent, GitHubContent.makeTest(overrides));
 };
-const unstubbed = (member) => {
-	throw new Error(`GitHubContent.makeTest: ${member}() was called but not stubbed — pass an override.`);
-};
+const dies = unstubbed("GitHubContent.makeTest");
 const make = (client) => {
 	const getFile = Effect.fn("GitHubContent.getFile")(function* (path, options) {
 		const { owner, repo } = yield* Repo;

package/GitHubIssue.js

@@ -1,4 +1,5 @@
 import { GraphQLDocument } from "./GraphQL.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { numericId } from "./internal/ids.js";
@@ -127,22 +128,20 @@ const CrossReferencedDocument = GraphQLDocument.make({
 var GitHubIssue = class GitHubIssue extends Context.Service()("@effected/github/GitHubIssue") {
 	/** The live service, built over a `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	static makeTest = (overrides = {}) => ({
-		get: overrides.get ?? (() => unstubbed("get")),
-		list: overrides.list ?? (() => unstubbed("list")),
-		close: overrides.close ?? (() => unstubbed("close")),
-		comment: overrides.comment ?? (() => unstubbed("comment")),
-		commentOnce: overrides.commentOnce ?? (() => unstubbed("commentOnce")),
-		linkedIssues: overrides.linkedIssues ?? (() => unstubbed("linkedIssues")),
-		isCrossReferencedBy: overrides.isCrossReferencedBy ?? (() => unstubbed("isCrossReferencedBy"))
+		get: overrides.get ?? (() => dies("get")),
+		list: overrides.list ?? (() => dies("list")),
+		close: overrides.close ?? (() => dies("close")),
+		comment: overrides.comment ?? (() => dies("comment")),
+		commentOnce: overrides.commentOnce ?? (() => dies("commentOnce")),
+		linkedIssues: overrides.linkedIssues ?? (() => dies("linkedIssues")),
+		isCrossReferencedBy: overrides.isCrossReferencedBy ?? (() => dies("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.`);
-};
+const dies = unstubbed("GitHubIssue.makeTest");
 /**
 * The REST calendar version this module's requests pin.
 *

package/GitHubRelease.js

@@ -1,4 +1,5 @@
 import { GitHubError } from "./GitHubError.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer, Option, Schema } from "effect";
@@ -59,22 +60,20 @@ var ReleaseAsset = class extends Schema.Class("ReleaseAsset")({
 var GitHubRelease = class GitHubRelease extends Context.Service()("@effected/github/GitHubRelease") {
 	/** The live service, built over a `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	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"))
+		create: overrides.create ?? (() => dies("create")),
+		getByTag: overrides.getByTag ?? (() => dies("getByTag")),
+		getByTagOption: overrides.getByTagOption ?? (() => dies("getByTagOption")),
+		list: overrides.list ?? (() => dies("list")),
+		update: overrides.update ?? (() => dies("update")),
+		uploadAsset: overrides.uploadAsset ?? (() => dies("uploadAsset")),
+		listAssets: overrides.listAssets ?? (() => dies("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 dies = unstubbed("GitHubRelease.makeTest");
 const project = (raw) => ReleaseInfo.make({
 	id: raw.id,
 	tag: raw.tag_name,

package/GitHubRepository.js

@@ -1,4 +1,5 @@
 import { GraphQLDocument } from "./GraphQL.js";
+import { unstubbed, unstubbedRead } from "./internal/unstubbed.js";
 import { GitHubClient } from "./GitHubClient.js";
 import { Repo } from "./Repo.js";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -195,21 +196,20 @@ const preparePatch = (patch) => {
 var GitHubRepository = class GitHubRepository extends Context.Service()("@effected/github/GitHubRepository") {
 	/** The live service, built over a `GitHubClient`. */
 	static layer = Layer.effect(this, Effect.map(GitHubClient, (client) => make(client)));
-	/** An in-memory double; unstubbed members die naming themselves. */
+	/** An in-memory double; an unstubbed member dies when run, naming itself. */
 	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")),
-		ownerType: overrides.ownerType ?? Effect.sync(() => unstubbed("ownerType")),
-		applySettings: overrides.applySettings ?? (() => unstubbed("applySettings"))
+		settings: overrides.settings ?? unread("settings"),
+		updateSettings: overrides.updateSettings ?? (() => dies("updateSettings")),
+		defaultBranch: overrides.defaultBranch ?? unread("defaultBranch"),
+		nodeId: overrides.nodeId ?? unread("nodeId"),
+		ownerType: overrides.ownerType ?? unread("ownerType"),
+		applySettings: overrides.applySettings ?? (() => dies("applySettings"))
 	});
 	/** {@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 dies = unstubbed("GitHubRepository.makeTest");
+const unread = unstubbedRead("GitHubRepository.makeTest");
 const make = (client) => {
 	const settings = Effect.fn("GitHubRepository.settings")(function* () {
 		const { owner, repo } = yield* Repo;