@effected/github-actions 0.13.0 → 0.13.2

package/ActionCache.js

@@ -1,10 +1,14 @@
 import { ActionEnvironment } from "./ActionEnvironment.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { BlobTransferError } from "./BlobTransfer.js";
-import { resultsBackend } from "./internal/actionsResults.js";
-import { CONFLICT, isOk, stringField, twirpCall } from "./internal/twirp.js";
-import { Context, Effect, FileSystem, Layer, Option, Path, Schema, Stream } from "effect";
+import { misconfiguredDetail, resultsBackend } from "./internal/actionsResults.js";
+import { twirpCall, twirpFailureFields } from "./internal/twirp.js";
+import { CACHE_SERVICE, finalizeUpload, lookupDownload, reserveUpload } from "./internal/cacheService.js";
+import { sha256Hex } from "./internal/digest.js";
+import { isWindowsRunner } from "./internal/runner.js";
+import { spawnOnce } from "./internal/spawn.js";
+import { Context, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
 import { HttpClient } from "effect/unstable/http";
-import { createHash } from "node:crypto";
 import { BlobClient, BlockBlobClient } from "@azure/storage-blob";
 import { GlobPattern, GlobSet } from "@effected/glob";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
@@ -53,8 +57,6 @@ var ActionCacheError = class extends Schema.TaggedError()("ActionCacheError", {
 		}
 	}
 };
-/** The Twirp service the Actions cache protocol lives under. */
-const SERVICE = "github.actions.results.api.v1.CacheService";
 /**
 * The entry version, byte-compatible with `actions/cache`.
 *
@@ -74,11 +76,11 @@ const SERVICE = "github.actions.results.api.v1.CacheService";
 * version the restore side cannot reproduce, and every save would be an entry
 * no restore ever finds.
 */
-const versionOf = (paths) => createHash("sha256").update([
+const versionOf = (paths) => sha256Hex([
 	...paths,
 	"gzip",
 	"1.0"
-].join("|")).digest("hex");
+].join("|"));
 /**
 * The Azure half, duplicated on purpose.
 *
@@ -109,17 +111,6 @@ const azure = {
 		})
 	}).pipe(Effect.asVoid)
 };
-const fromTwirp = (failure, key) => failure.kind === "status" ? new ActionCacheError({
-	reason: "refused",
-	key,
-	detail: failure.method,
-	...failure.status === void 0 ? {} : { status: failure.status }
-}) : new ActionCacheError({
-	reason: "unreachable",
-	key,
-	detail: `${failure.method} did not answer with a Twirp body`,
-	...failure.cause === void 0 ? {} : { cause: failure.cause }
-});
 /** The primary key and the ladder to fall back through. */
 const ladder = (key, restoreKeys) => typeof key === "string" ? {
 	primary: key,
@@ -134,24 +125,38 @@ const make = (transfer) => Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 	const env = yield* ActionEnvironment;
-	const windows = yield* Effect.map(env.getOptional("RUNNER_OS"), (found) => Option.match(found, {
-		onNone: () => false,
-		onSome: (os) => os.toLowerCase() === "windows"
-	}));
+	const windows = yield* isWindowsRunner(env);
+	/** A filesystem or subprocess failure on the way to or from the archive. */
+	const archiveFailed = (key) => (cause) => new ActionCacheError({
+		reason: "archiveFailed",
+		key,
+		cause
+	});
 	const backend = resultsBackend(env).pipe(Effect.mapError((name) => new ActionCacheError({
 		reason: "misconfigured",
-		detail: `${name} is not set — the Actions cache is only reachable from a \`uses:\` step, never from \`run:\``
+		detail: misconfiguredDetail(name, "Actions cache")
 	})));
-	const call = (method, body, key) => Effect.gen(function* () {
-		const { baseUrl, token } = yield* backend;
-		return yield* twirpCall({
-			http,
-			baseUrl,
-			service: SERVICE,
-			token,
-			method,
-			body
-		}).pipe(Effect.mapError((failure) => fromTwirp(failure, key)));
+	/** The cache service, for one key: every failure names it. */
+	const cacheService = (key) => ({
+		call: (method, body) => Effect.gen(function* () {
+			const { baseUrl, token } = yield* backend;
+			return yield* twirpCall({
+				http,
+				baseUrl,
+				service: CACHE_SERVICE,
+				token,
+				method,
+				body
+			}).pipe(Effect.mapError((failure) => new ActionCacheError({
+				...twirpFailureFields(failure),
+				key
+			})));
+		}),
+		refused: (detail) => new ActionCacheError({
+			reason: "refused",
+			key,
+			detail
+		})
 	});
 	/**
 	* Run `tar` ONCE, keeping its stderr.
@@ -162,39 +167,24 @@ const make = (transfer) => Effect.gen(function* () {
 	* exits 1 to say so, which is a warning rather than an error. Exit 2 and
 	* above stays a failure on every platform.
 	*
-	* Output and exit code come from the SAME `spawn` handle: the spawner's
-	* `string` and `exitCode` convenience members each spawn independently
-	* (core derives both from `spawn`), so calling them back-to-back
-	* double-executed every archive operation — and on a failure reported the
-	* FIRST run's output as the second run's complaint. `tar` being idempotent
-	* kept this latent here; the same shape failed loudly in
-	* `ToolInstaller.extractZip` on Windows.
+	* Output and exit code come from the SAME `spawn` handle
+	* (`internal/spawn.ts` — the spawner's convenience members each spawn
+	* independently, and the double run failed loudly in
+	* `ToolInstaller.extractZip` on Windows).
 	*/
-	const tar = (args, key, tolerateWarnings) => Effect.scoped(Effect.gen(function* () {
-		const command = ChildProcess.make("tar", [...args]);
-		const archiveError = (cause) => new ActionCacheError({
-			reason: "archiveFailed",
-			key,
-			cause
-		});
-		const handle = yield* spawner.spawn(command).pipe(Effect.mapError(archiveError));
-		const output = yield* Stream.mkString(Stream.decodeText(handle.all)).pipe(Effect.mapError(archiveError));
-		const code = yield* handle.exitCode.pipe(Effect.mapError(archiveError));
+	const tar = (args, key, tolerateWarnings) => Effect.gen(function* () {
+		const { output, code } = yield* spawnOnce(spawner, ChildProcess.make("tar", [...args])).pipe(Effect.mapError(archiveFailed(key)));
 		if (code !== 0 && !(tolerateWarnings && code === 1)) return yield* Effect.fail(new ActionCacheError({
 			reason: "archiveFailed",
 			key,
 			stderr: output.trim()
 		}));
-	}));
+	});
 	/**
 	* A scratch archive path — plus the scratch directory itself, where the
 	* save side writes its tar manifest — removed on every exit path.
 	*/
-	const withArchive = (key, use) => Effect.acquireUseRelease(fs.makeTempDirectory({ prefix: "effected-cache-" }).pipe(Effect.mapError((cause) => new ActionCacheError({
-		reason: "archiveFailed",
-		key,
-		cause
-	}))), (directory) => use(path.join(directory, "cache.tar.gz"), directory), (directory) => Effect.ignore(fs.remove(directory, {
+	const withArchive = (key, use) => Effect.acquireUseRelease(fs.makeTempDirectory({ prefix: "effected-cache-" }).pipe(Effect.mapError(archiveFailed(key))), (directory) => use(path.join(directory, "cache.tar.gz"), directory), (directory) => Effect.ignore(fs.remove(directory, {
 		recursive: true,
 		force: true
 	})));
@@ -291,78 +281,44 @@ const make = (transfer) => Effect.gen(function* () {
 		save: Effect.fn("ActionCache.save")(function* (paths, key) {
 			const { primary } = ladder(key, void 0);
 			yield* Effect.annotateCurrentSpan({ key: primary });
-			const version = versionOf(paths);
 			if (paths.length === 0) return yield* Effect.fail(new ActionCacheError({
 				reason: "archiveFailed",
 				key: primary,
 				detail: "no paths were given to cache"
 			}));
+			const version = versionOf(paths);
 			const resolved = yield* resolvePaths(paths, primary);
 			yield* withArchive(primary, (archive, scratch) => Effect.gen(function* () {
 				const manifest = path.join(scratch, "manifest.txt");
-				yield* fs.writeFileString(manifest, `${resolved.join("\n")}\n`).pipe(Effect.mapError((cause) => new ActionCacheError({
-					reason: "archiveFailed",
-					key: primary,
-					cause
-				})));
+				yield* fs.writeFileString(manifest, `${resolved.join("\n")}\n`).pipe(Effect.mapError(archiveFailed(primary)));
 				yield* tar([
 					"czPf",
 					archive,
 					"-T",
 					manifest
 				], primary, false);
-				const size = yield* fs.stat(archive).pipe(Effect.mapError((cause) => new ActionCacheError({
-					reason: "archiveFailed",
-					key: primary,
-					cause
-				})));
-				const created = yield* call("CreateCacheEntry", {
-					key: primary,
-					version
-				}, primary);
-				if (created === CONFLICT) return;
-				const url = stringField(created, "signedUploadUrl");
-				if (!isOk(created) || url === void 0) return yield* Effect.fail(new ActionCacheError({
-					reason: "refused",
-					key: primary,
-					detail: "CreateCacheEntry returned no upload url"
-				}));
-				yield* transfer.uploadFile(url, archive).pipe(moved(primary));
-				const finalized = yield* call("FinalizeCacheEntryUpload", {
-					key: primary,
-					version,
-					size_bytes: String(size.size)
-				}, primary);
-				if (finalized === CONFLICT || !isOk(finalized)) return yield* Effect.fail(new ActionCacheError({
-					reason: "refused",
-					key: primary,
-					detail: "FinalizeCacheEntryUpload did not confirm the upload"
-				}));
+				const size = yield* fs.stat(archive).pipe(Effect.mapError(archiveFailed(primary)));
+				const service = cacheService(primary);
+				const url = yield* reserveUpload(service, primary, version);
+				if (Option.isNone(url)) return;
+				yield* transfer.uploadFile(url.value, archive).pipe(moved(primary));
+				yield* finalizeUpload(service, primary, version, size.size);
 			}));
 		}),
 		restore: Effect.fn("ActionCache.restore")(function* (paths, key, restoreKeys) {
 			const { primary, fallbacks } = ladder(key, restoreKeys);
 			yield* Effect.annotateCurrentSpan({ key: primary });
-			const version = versionOf(paths);
-			const found = yield* call("GetCacheEntryDownloadURL", {
-				key: primary,
-				restore_keys: [...fallbacks],
-				version
-			}, primary);
-			if (found === CONFLICT || !isOk(found)) return Option.none();
-			const url = stringField(found, "signedDownloadUrl");
-			if (url === void 0) return Option.none();
+			const hit = yield* lookupDownload(cacheService(primary), primary, fallbacks, versionOf(paths));
+			if (Option.isNone(hit)) return Option.none();
 			yield* withArchive(primary, (archive) => Effect.gen(function* () {
-				yield* transfer.downloadToFile(url, archive).pipe(moved(primary));
+				yield* transfer.downloadToFile(hit.value.url, archive).pipe(moved(primary));
 				yield* tar([windows ? "xzPkf" : "xzPf", archive], primary, windows);
 			}));
-			return Option.some(stringField(found, "matchedKey") ?? primary);
+			return Option.some(hit.value.matchedKey ?? primary);
 		})
 	};
 });
-const unimplemented = (member) => {
-	throw new Error(`ActionCache.makeTest: ${member}() was called but not stubbed — pass a \`${member}\` override.`);
-};
+const dies = unstubbed("ActionCache.makeTest");
 /**
 * The runner's own cache: archive a set of paths under a key, and get them back
 * in a later job.
@@ -416,8 +372,8 @@ var ActionCache = class ActionCache extends Context.Service()("@effected/github-
 	static layerWith = (transfer) => Layer.effect(ActionCache, make(transfer));
 	/** A test double. Unstubbed members die rather than reporting a miss. */
 	static makeTest = (overrides = {}) => ({
-		save: () => Effect.sync(() => unimplemented("save")),
-		restore: () => Effect.sync(() => unimplemented("restore")),
+		save: () => dies("save"),
+		restore: () => dies("restore"),
 		...overrides
 	});
 	/** {@link ActionCache.makeTest} behind `Layer.succeed`. */

package/ActionEnvironment.js

@@ -129,62 +129,31 @@ const make = (base) => Effect.gen(function* () {
 		get,
 		getOptional: lookup,
 		isDebug: Effect.map(lookup("RUNNER_DEBUG"), (value) => Option.isSome(value) && value.value === "1"),
-		github: Effect.gen(function* () {
-			const [repository, repositoryOwner, ref, refName, sha, workflow, job] = yield* Effect.all([
-				get("GITHUB_REPOSITORY"),
-				get("GITHUB_REPOSITORY_OWNER"),
-				get("GITHUB_REF"),
-				get("GITHUB_REF_NAME"),
-				get("GITHUB_SHA"),
-				get("GITHUB_WORKFLOW"),
-				get("GITHUB_JOB")
-			]);
-			const runId = yield* Effect.flatMap(get("GITHUB_RUN_ID"), (raw) => numeric("GITHUB_RUN_ID", raw));
-			const runAttempt = yield* Effect.flatMap(get("GITHUB_RUN_ATTEMPT"), (raw) => numeric("GITHUB_RUN_ATTEMPT", raw));
-			const headRef = yield* lookup("GITHUB_HEAD_REF");
-			const [eventName, actor, serverUrl, apiUrl, graphqlUrl, workspace] = yield* Effect.all([
-				get("GITHUB_EVENT_NAME"),
-				get("GITHUB_ACTOR"),
-				get("GITHUB_SERVER_URL"),
-				get("GITHUB_API_URL"),
-				get("GITHUB_GRAPHQL_URL"),
-				get("GITHUB_WORKSPACE")
-			]);
-			return GitHubContext.make({
-				repository,
-				repositoryOwner,
-				ref,
-				refName,
-				headRef,
-				sha,
-				workflow,
-				job,
-				runId,
-				runAttempt,
-				eventName,
-				actor,
-				serverUrl,
-				apiUrl,
-				graphqlUrl,
-				workspace
-			});
-		}),
-		runner: Effect.gen(function* () {
-			const [os, arch, name, temp, toolCache] = yield* Effect.all([
-				get("RUNNER_OS"),
-				get("RUNNER_ARCH"),
-				get("RUNNER_NAME"),
-				get("RUNNER_TEMP"),
-				get("RUNNER_TOOL_CACHE")
-			]);
-			return RunnerContext.make({
-				os,
-				arch,
-				name,
-				temp,
-				toolCache
-			});
-		}),
+		github: Effect.map(Effect.all({
+			repository: get("GITHUB_REPOSITORY"),
+			repositoryOwner: get("GITHUB_REPOSITORY_OWNER"),
+			ref: get("GITHUB_REF"),
+			refName: get("GITHUB_REF_NAME"),
+			headRef: lookup("GITHUB_HEAD_REF"),
+			sha: get("GITHUB_SHA"),
+			workflow: get("GITHUB_WORKFLOW"),
+			job: get("GITHUB_JOB"),
+			runId: Effect.flatMap(get("GITHUB_RUN_ID"), (raw) => numeric("GITHUB_RUN_ID", raw)),
+			runAttempt: Effect.flatMap(get("GITHUB_RUN_ATTEMPT"), (raw) => numeric("GITHUB_RUN_ATTEMPT", raw)),
+			eventName: get("GITHUB_EVENT_NAME"),
+			actor: get("GITHUB_ACTOR"),
+			serverUrl: get("GITHUB_SERVER_URL"),
+			apiUrl: get("GITHUB_API_URL"),
+			graphqlUrl: get("GITHUB_GRAPHQL_URL"),
+			workspace: get("GITHUB_WORKSPACE")
+		}), (fields) => GitHubContext.make(fields)),
+		runner: Effect.map(Effect.all({
+			os: get("RUNNER_OS"),
+			arch: get("RUNNER_ARCH"),
+			name: get("RUNNER_NAME"),
+			temp: get("RUNNER_TEMP"),
+			toolCache: get("RUNNER_TOOL_CACHE")
+		}), (fields) => RunnerContext.make(fields)),
 		payload: Effect.gen(function* () {
 			const path = yield* get("GITHUB_EVENT_PATH");
 			const raw = yield* fs.readFileString(path).pipe(Effect.mapError((cause) => new ActionEnvironmentError({

package/ActionInput.js

@@ -374,16 +374,17 @@ var ActionInput = class ActionInput {
 		/** Unset, and the `""` the runner writes for an unsupplied input, are both absent. */
 		const present = (value) => value !== void 0 && value !== "";
 		/**
-		* Resolve one runner-variable name: the verbatim entry wins; an
-		* `INPUT_`-prefixed miss then consults the input-name entries through the
-		* one spelling of the derivation (`inputVariable`).
+		* The input-name entries, keyed by the runner variable they would be
+		* (`inputVariable`, the one spelling of the derivation) — built once,
+		* so an `INPUT_`-prefixed miss is a map read rather than a scan of the
+		* whole environment per `Config` read.
 		*/
+		const byInputName = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(env)) if (!key.startsWith("INPUT_") && present(value) && !byInputName.has(inputVariable(key))) byInputName.set(inputVariable(key), value);
+		/** Resolve one runner-variable name: the verbatim entry wins, then the input-name entry. */
 		const lookup = (name) => {
 			const direct = env[name];
-			if (present(direct)) return direct;
-			if (name.startsWith("INPUT_")) {
-				for (const [key, value] of Object.entries(env)) if (!key.startsWith("INPUT_") && inputVariable(key) === name && present(value)) return value;
-			}
+			return present(direct) ? direct : byInputName.get(name);
 		};
 		return ConfigProvider.make((path) => {
 			const single = path.length === 1 && typeof path[0] === "string" ? path[0] : void 0;

package/ActionLogger.js

@@ -54,15 +54,13 @@ const readAnnotations = (record) => {
 		...endColumn === void 0 ? {} : { endColumn }
 	};
 };
-/** The inverse: annotation fields as a record `Effect.annotateLogs` accepts. */
-const annotationRecord = (properties) => ({
-	...properties.title === void 0 ? {} : { title: properties.title },
-	...properties.file === void 0 ? {} : { file: properties.file },
-	...properties.startLine === void 0 ? {} : { startLine: properties.startLine },
-	...properties.endLine === void 0 ? {} : { endLine: properties.endLine },
-	...properties.startColumn === void 0 ? {} : { startColumn: properties.startColumn },
-	...properties.endColumn === void 0 ? {} : { endColumn: properties.endColumn }
-});
+/**
+* The inverse: annotation fields as a record `Effect.annotateLogs` accepts.
+* A plain copy: `exactOptionalPropertyTypes` keeps an absent field absent
+* rather than present-and-`undefined`, and {@link readAnnotations} drops
+* anything that is not a string or number on the way back out.
+*/
+const annotationRecord = (properties) => ({ ...properties });
 /**
 * Map one log entry onto the line the runner should see.
 *
@@ -79,6 +77,10 @@ const renderEntry = (level, message, annotations) => {
 	}
 	return LogLevel.isGreaterThanOrEqualTo(level, "Info") ? text : WorkflowCommand.debug(text);
 };
+/** The line the runner should see for one log event, with the fiber's annotations. */
+const renderLogger = Logger.make((options) => renderEntry(options.logLevel, options.message, options.fiber.getRef(References.CurrentLogAnnotations)));
+/** {@link renderLogger} written through core `Console`. */
+const commandLogger = Logger.withConsoleLog(renderLogger);
 /**
 * The buffer the current fiber is writing into, or `null` when not buffering.
 *
@@ -118,8 +120,7 @@ const make = Effect.gen(function* () {
 		};
 		const buffering = Logger.make((options) => {
 			if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, "Warn")) {
-				const annotations = options.fiber.getRef(References.CurrentLogAnnotations);
-				options.fiber.getRef(Console.Console).log(renderEntry(options.logLevel, options.message, annotations));
+				commandLogger.log(options);
 				return;
 			}
 			state.entries.push(formatMessage(options.message));
@@ -170,10 +171,7 @@ var ActionLogger = class ActionLogger extends Context.Service()("@effected/githu
 	* It writes through core `Console`, which is what makes its output
 	* observable in a test without a runner.
 	*/
-	static logger = Logger.make((options) => {
-		const annotations = options.fiber.getRef(References.CurrentLogAnnotations);
-		options.fiber.getRef(Console.Console).log(renderEntry(options.logLevel, options.message, annotations));
-	});
+	static logger = commandLogger;
 	/** {@link ActionLogger.logger} installed as the only logger. */
 	static layerLogger = Logger.layer([ActionLogger.logger]);
 	/**

package/ActionOutputs.js

@@ -1,5 +1,7 @@
 import { ActionEnvironment } from "./ActionEnvironment.js";
 import { WorkflowCommand } from "./WorkflowCommand.js";
+import { heredocBlock, isUsableName } from "./internal/runnerFile.js";
+import { unstubbed } from "./internal/unstubbed.js";
 import { Console, Context, Effect, FileSystem, Layer, Schema } from "effect";
 
 //#region src/ActionOutputs.ts
@@ -83,35 +85,36 @@ var DetachedOutputError = class extends Schema.TaggedError()("DetachedOutputErro
 		return `Runner file "${this.file}" cannot be reached from a detached worker — it configures the parent job's later steps, and a worker has none and may outlive the job. Publish this from the parent process instead.`;
 	}
 };
-/** The base delimiter for a heredoc block. */
-const BASE_DELIMITER = "EFFECTED_EOF";
 /**
-* A delimiter guaranteed absent from `value`.
-*
-* @remarks
-* GitHub's own toolkit uses a random UUID here and accepts the (tiny) chance
-* of collision. Deriving the delimiter instead makes collision **impossible**
-* rather than improbable, needs no randomness — so no `Crypto` in `R` and no
-* unreproducible output — and is trivially testable. A value that contains a
-* delimiter would terminate its block early and corrupt every entry after it,
-* which is a value-controlled injection into the runner's own file.
+* The runner file each member appends to — spelled once, so the real layer,
+* the detached layer and the recording double cannot disagree about which
+* file a member's failure names.
 */
-const delimiterFor = (value) => {
-	let delimiter = BASE_DELIMITER;
-	while (value.includes(delimiter)) delimiter = `${delimiter}_`;
-	return delimiter;
+const RUNNER_FILE = {
+	set: "GITHUB_OUTPUT",
+	setJson: "GITHUB_OUTPUT",
+	exportVariable: "GITHUB_ENV",
+	summary: "GITHUB_STEP_SUMMARY",
+	addPath: "GITHUB_PATH"
 };
-/** A name that would break the block structure it lives in. */
-const isUsableName = (name) => name !== "" && !/[\r\n]/.test(name);
+/**
+* Run `effect` only if `name` can head a heredoc block; otherwise fail typed,
+* naming the file. The one name check every construction of the service
+* applies before a named write.
+*/
+const withUsableName = (file, name, effect) => isUsableName(name) ? effect : Effect.fail(new InvalidOutputNameError({
+	file,
+	name
+}));
 /**
 * The JSON text `setJson` publishes for `value`: encoded through `schema`,
 * then stringified. The one step of `setJson` that can fail, shared by the
 * real layer and both test doubles so that none of them can skip it.
 */
-const encodeJson = (name, value, schema) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new OutputEncodeError({
+const encodeJson = (name, value, schema) => Schema.encodeUnknownEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError((cause) => new OutputEncodeError({
 	name,
 	cause
-})), Effect.map((encoded) => JSON.stringify(encoded)));
+})));
 /**
 * One call an {@link ActionOutputs.recording} double observed.
 *
@@ -151,28 +154,19 @@ const make = Effect.gen(function* () {
 			cause
 		})));
 	});
-	const appendBlock = (file, name, value) => {
-		if (!isUsableName(name)) return Effect.fail(new InvalidOutputNameError({
-			file,
-			name
-		}));
-		const delimiter = delimiterFor(value);
-		return append(file, `${name}<<${delimiter}\n${value}\n${delimiter}\n`);
-	};
-	const set = (name, value) => appendBlock("GITHUB_OUTPUT", name, value);
+	const appendBlock = (file, name, value) => withUsableName(file, name, append(file, heredocBlock(name, value)));
+	const set = (name, value) => appendBlock(RUNNER_FILE.set, name, value);
 	return {
 		set,
 		setJson: (name, value, schema) => encodeJson(name, value, schema).pipe(Effect.flatMap((json) => set(name, json))),
-		summary: (content) => append("GITHUB_STEP_SUMMARY", content),
-		exportVariable: (name, value) => appendBlock("GITHUB_ENV", name, value),
-		addPath: (path) => append("GITHUB_PATH", `${path}\n`),
+		summary: (content) => append(RUNNER_FILE.summary, content),
+		exportVariable: (name, value) => appendBlock(RUNNER_FILE.exportVariable, name, value),
+		addPath: (path) => append(RUNNER_FILE.addPath, `${path}\n`),
 		setFailed: (message) => Console.log(WorkflowCommand.error(message)),
 		setSecret: (value) => Console.log(WorkflowCommand.addMask(value))
 	};
 });
-const unimplemented = (member) => {
-	throw new Error(`ActionOutputs.makeTest: ${member}() was called but not stubbed — pass a \`${member}\` override.`);
-};
+const dies = unstubbed("ActionOutputs.makeTest");
 /**
 * Everything an action publishes: step outputs, exported variables, `PATH`
 * additions, the job summary, log masking and failure annotations.
@@ -230,19 +224,19 @@ var ActionOutputs = class ActionOutputs extends Context.Service()("@effected/git
 	*/
 	static layerDetached = Layer.succeed(this, {
 		set: (name) => Effect.fail(new DetachedOutputError({
-			file: "GITHUB_OUTPUT",
+			file: RUNNER_FILE.set,
 			name
 		})),
 		setJson: (name) => Effect.fail(new DetachedOutputError({
-			file: "GITHUB_OUTPUT",
+			file: RUNNER_FILE.setJson,
 			name
 		})),
-		summary: () => Effect.fail(new DetachedOutputError({ file: "GITHUB_STEP_SUMMARY" })),
+		summary: () => Effect.fail(new DetachedOutputError({ file: RUNNER_FILE.summary })),
 		exportVariable: (name) => Effect.fail(new DetachedOutputError({
-			file: "GITHUB_ENV",
+			file: RUNNER_FILE.exportVariable,
 			name
 		})),
-		addPath: () => Effect.fail(new DetachedOutputError({ file: "GITHUB_PATH" })),
+		addPath: () => Effect.fail(new DetachedOutputError({ file: RUNNER_FILE.addPath })),
 		setFailed: (message) => Console.error(message),
 		setSecret: () => Effect.void
 	});
@@ -262,14 +256,14 @@ var ActionOutputs = class ActionOutputs extends Context.Service()("@effected/git
 	* {@link ActionOutputs.recording} instead.
 	*/
 	static makeTest = (overrides = {}) => {
-		const setJson = overrides.setJson ?? (() => Effect.sync(() => unimplemented("setJson")));
+		const setJson = overrides.setJson ?? (() => dies("setJson"));
 		return {
-			set: () => Effect.sync(() => unimplemented("set")),
-			summary: () => Effect.sync(() => unimplemented("summary")),
-			exportVariable: () => Effect.sync(() => unimplemented("exportVariable")),
-			addPath: () => Effect.sync(() => unimplemented("addPath")),
-			setFailed: () => Effect.sync(() => unimplemented("setFailed")),
-			setSecret: () => Effect.sync(() => unimplemented("setSecret")),
+			set: () => dies("set"),
+			summary: () => dies("summary"),
+			exportVariable: () => dies("exportVariable"),
+			addPath: () => dies("addPath"),
+			setFailed: () => dies("setFailed"),
+			setSecret: () => dies("setSecret"),
 			...overrides,
 			setJson: (name, value, schema) => encodeJson(name, value, schema).pipe(Effect.flatMap(() => setJson(name, value, schema)))
 		};
@@ -309,19 +303,12 @@ var ActionOutputs = class ActionOutputs extends Context.Service()("@effected/git
 				...name === void 0 ? {} : { name }
 			}));
 		});
-		const recordNamed = (member, file, name, value) => isUsableName(name) ? record(member, value, name) : Effect.fail(new InvalidOutputNameError({
-			file,
-			name
-		}));
 		return {
 			layer: Layer.succeed(ActionOutputs, {
-				set: (name, value) => recordNamed("set", "GITHUB_OUTPUT", name, value),
-				setJson: (name, value, schema) => isUsableName(name) ? encodeJson(name, value, schema).pipe(Effect.flatMap((json) => record("setJson", json, name))) : Effect.fail(new InvalidOutputNameError({
-					file: "GITHUB_OUTPUT",
-					name
-				})),
+				set: (name, value) => withUsableName(RUNNER_FILE.set, name, record("set", value, name)),
+				setJson: (name, value, schema) => withUsableName(RUNNER_FILE.setJson, name, encodeJson(name, value, schema).pipe(Effect.flatMap((json) => record("setJson", json, name)))),
 				summary: (content) => record("summary", content),
-				exportVariable: (name, value) => recordNamed("exportVariable", "GITHUB_ENV", name, value),
+				exportVariable: (name, value) => withUsableName(RUNNER_FILE.exportVariable, name, record("exportVariable", value, name)),
 				addPath: (path) => record("addPath", path),
 				setFailed: (message) => record("setFailed", message),
 				setSecret: (value) => record("setSecret", value)