@computis/effect-github 0.0.0-stage → 0.1.0

package/src/action-summary.ts

@@ -0,0 +1,143 @@
+import { summary } from "@actions/core";
+import { whenDefined } from "./object.ts";
+import { thrownMessage } from "./thrown-message.ts";
+import { Context, Effect, Layer } from "effect";
+import { ActionSummaryError, ActionSummaryErrorReason } from "./errors/action-summary-error.ts";
+
+export interface SummaryTableCell {
+  readonly data: string;
+  readonly header?: boolean;
+  readonly colspan?: number;
+  readonly rowspan?: number;
+}
+
+export interface SummaryImageOptions {
+  readonly width?: string;
+  readonly height?: string;
+}
+
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+
+export interface ActionSummaryApi {
+  readonly addRaw: (text: string, addEOL?: boolean) => ActionSummaryApi;
+  readonly addEOL: () => ActionSummaryApi;
+  readonly addHeading: (text: string, level?: HeadingLevel) => ActionSummaryApi;
+  readonly addCodeBlock: (code: string, lang?: string) => ActionSummaryApi;
+  readonly addList: (items: readonly string[], ordered?: boolean) => ActionSummaryApi;
+  readonly addTable: (rows: readonly (readonly SummaryTableCell[])[]) => ActionSummaryApi;
+  readonly addDetails: (label: string, content: string) => ActionSummaryApi;
+  readonly addImage: (src: string, alt: string, options?: SummaryImageOptions) => ActionSummaryApi;
+  readonly addLink: (text: string, href: string) => ActionSummaryApi;
+  readonly addSeparator: () => ActionSummaryApi;
+  readonly addBreak: () => ActionSummaryApi;
+  readonly addQuote: (text: string, cite?: string) => ActionSummaryApi;
+  readonly stringify: () => string;
+  readonly isEmptyBuffer: () => boolean;
+  readonly emptyBuffer: () => ActionSummaryApi;
+  readonly write: (options?: {
+    readonly overwrite?: boolean;
+  }) => Effect.Effect<ActionSummaryApi, ActionSummaryError>;
+  readonly clear: () => Effect.Effect<ActionSummaryApi, ActionSummaryError>;
+}
+
+const writeFailed = (cause: unknown) =>
+  new ActionSummaryError({
+    cause,
+    description: thrownMessage(cause, "GITHUB_STEP_SUMMARY could not be written"),
+    reason: ActionSummaryErrorReason.WriteFailed,
+  });
+
+export class ActionSummary extends Context.Service<ActionSummary, ActionSummaryApi>()(
+  "@computis/effect-github/ActionSummary",
+) {
+  static readonly layer = Layer.sync(ActionSummary, () => {
+    const self: ActionSummaryApi = {
+      addBreak: () => {
+        summary.addBreak();
+        return self;
+      },
+      addCodeBlock: (code, lang) => {
+        summary.addCodeBlock(code, lang);
+        return self;
+      },
+      addDetails: (label, content) => {
+        summary.addDetails(label, content);
+        return self;
+      },
+      addEOL: () => {
+        summary.addEOL();
+        return self;
+      },
+      addHeading: (text, level) => {
+        summary.addHeading(text, level);
+        return self;
+      },
+      addImage: (src, alt, options) => {
+        summary.addImage(src, alt, options);
+        return self;
+      },
+      addLink: (text, href) => {
+        summary.addLink(text, href);
+        return self;
+      },
+      addList: (items, ordered) => {
+        summary.addList([...items], ordered);
+        return self;
+      },
+      addQuote: (text, cite) => {
+        summary.addQuote(text, cite);
+        return self;
+      },
+      addRaw: (text, addEOL) => {
+        summary.addRaw(text, addEOL);
+        return self;
+      },
+      addSeparator: () => {
+        summary.addSeparator();
+        return self;
+      },
+      addTable: (rows) => {
+        summary.addTable(
+          rows.map((row) =>
+            row.map((cell) => ({
+              data: cell.data,
+              ...whenDefined(cell.header, (header) => ({ header })),
+              ...whenDefined(cell.colspan, (colspan) => ({ colspan: String(colspan) })),
+              ...whenDefined(cell.rowspan, (rowspan) => ({ rowspan: String(rowspan) })),
+            })),
+          ),
+        );
+        return self;
+      },
+      clear: Effect.fn("ActionSummary.clear")(function* clear() {
+        yield* Effect.tryPromise({ catch: writeFailed, try: async () => await summary.clear() });
+        return self;
+      }),
+      emptyBuffer: () => {
+        summary.emptyBuffer();
+        return self;
+      },
+      isEmptyBuffer: () => summary.isEmptyBuffer(),
+      stringify: () => summary.stringify(),
+      write: Effect.fn("ActionSummary.write")(function* write(options?: {
+        readonly overwrite?: boolean;
+      }) {
+        yield* Effect.tryPromise({
+          catch: writeFailed,
+          try: async () => await summary.write(options),
+        });
+        return self;
+      }),
+    };
+    return self;
+  });
+}
+
+const jobSummary = Effect.service(ActionSummary);
+
+export const write = (options?: { readonly overwrite?: boolean }) =>
+  jobSummary.pipe(Effect.flatMap((service) => service.write(options)));
+
+export const clear = jobSummary.pipe(Effect.flatMap((service) => service.clear()));
+
+export const { layer } = ActionSummary;

package/src/action.ts

@@ -0,0 +1,81 @@
+import { setFailed } from "@actions/core";
+import { thrownMessage } from "./thrown-message.ts";
+import { Cause, Effect, Layer, Logger, ManagedRuntime, Option } from "effect";
+import type { Redacted } from "effect";
+import { ActionClient } from "./action-client.ts";
+import { ActionContext } from "./action-context.ts";
+import { ActionRunner } from "./action-runner.ts";
+import { ActionSummary } from "./action-summary.ts";
+import { isActionFailure } from "./errors/action-failure.ts";
+import { PlatformMissing } from "./errors/platform-missing.ts";
+
+export type ActionRequirements = ActionRunner | ActionContext | ActionClient | ActionSummary;
+
+export const layer = (token: Redacted.Redacted): Layer.Layer<ActionRequirements> =>
+  Layer.mergeAll(
+    ActionRunner.layer,
+    ActionContext.layer,
+    ActionClient.layer(token),
+    ActionSummary.layer,
+  );
+
+export const layerConfig = Layer.mergeAll(
+  ActionRunner.layer,
+  ActionContext.layer,
+  ActionClient.layerConfig,
+  ActionSummary.layer,
+);
+
+export const runMain = <A, E>(
+  effect: Effect.Effect<A, E, ActionRequirements>,
+  options: {
+    readonly disableErrorReporting?: boolean;
+    readonly disablePrettyLogger?: boolean;
+    readonly token?: Redacted.Redacted;
+  } = {},
+) => {
+  const program = effect.pipe(
+    Effect.provide(options.token === undefined ? layerConfig : layer(options.token)),
+    Effect.tapCause(
+      Effect.fn("Action.reportFailure")(function* reportFailure<F>(cause: Cause.Cause<F>) {
+        if (Cause.hasInterruptsOnly(cause)) {
+          return;
+        }
+        if (options.disableErrorReporting !== true) {
+          yield* Effect.logError(cause);
+        }
+        setFailed(
+          Option.match(Cause.findErrorOption(cause), {
+            onNone: () => Cause.pretty(cause),
+            onSome: (error) =>
+              isActionFailure(error)
+                ? error.displayMessage
+                : thrownMessage(error, Cause.pretty(cause)),
+          }),
+        );
+      }),
+    ),
+    Effect.provide(
+      options.disablePrettyLogger === true ? Layer.empty : Logger.layer([Logger.consolePretty()]),
+    ),
+  );
+  Effect.runFork(
+    Effect.tryPromise({
+      catch: () => new PlatformMissing({ platform: "@effect/platform-node" }),
+      try: async () => await import("@effect/platform-node/NodeRuntime"),
+    }).pipe(
+      Effect.flatMap((NodeRuntime) =>
+        Effect.sync(() => {
+          NodeRuntime.runMain(program, { disableErrorReporting: true });
+        }),
+      ),
+      Effect.catchTag("PlatformMissing", (missing) =>
+        Effect.sync(() => {
+          setFailed(missing.message);
+        }),
+      ),
+    ),
+  );
+};
+
+export const makeRuntime = (token: Redacted.Redacted) => ManagedRuntime.make(layer(token));

package/src/errors/action-api-error.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+
+export class ActionApiError extends Schema.TaggedError<ActionApiError>()("ActionApiError", {
+  cause: Schema.optionalKey(Schema.Defect()),
+  description: Schema.optionalKey(Schema.String),
+  method: Schema.String,
+  status: Schema.optionalKey(Schema.Number),
+}) {
+  override get message() {
+    const status = this.status === undefined ? "" : ` (${this.status})`;
+    const description = this.description === undefined ? "" : ` - ${this.description}`;
+    return `GitHub API error${status}: ${this.method}${description}`;
+  }
+
+  get isRateLimited() {
+    return this.status === 403 || this.status === 429;
+  }
+}

package/src/errors/action-context-error.ts

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+
+export const ActionContextErrorReason = {
+  InvalidPayload: "InvalidPayload",
+  InvalidRepo: "InvalidRepo",
+  MissingEnv: "MissingEnv",
+} as const;
+
+export class ActionContextError extends Schema.TaggedError<ActionContextError>()(
+  "ActionContextError",
+  {
+    cause: Schema.optionalKey(Schema.Defect()),
+    description: Schema.optionalKey(Schema.String),
+    reason: Schema.Literals(Object.values(ActionContextErrorReason)),
+  },
+) {
+  override get message() {
+    return this.description ?? `Context error: ${this.reason}`;
+  }
+}

package/src/errors/action-failed.ts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+
+export class ActionFailed extends Schema.TaggedError<ActionFailed>()("ActionFailed", {
+  cause: Schema.optionalKey(Schema.Defect()),
+  message: Schema.String,
+}) {
+  get displayMessage() {
+    return this.message;
+  }
+}

package/src/errors/action-failure.ts

@@ -0,0 +1,36 @@
+import { ActionApiError } from "./action-api-error.ts";
+import { ActionContextError } from "./action-context-error.ts";
+import { ActionFailed } from "./action-failed.ts";
+import { ActionInputError } from "./action-input-error.ts";
+import { ActionOIDCError } from "./action-oidc-error.ts";
+import { ActionSummaryError } from "./action-summary-error.ts";
+import { InputValidationFailure } from "./input-validation-failure.ts";
+
+export type ActionFailure = InputValidationFailure | ActionFailed;
+
+type NarrowedMember<Member, Target> = Member extends Target
+  ? Member
+  : [Extract<Target, Member>] extends [never]
+    ? Member & Target
+    : Extract<Target, Member>;
+
+export type Narrowed<E, Target> = E extends unknown ? NarrowedMember<E, Target> : never;
+
+export const isActionFailure = <E>(error: E): error is Narrowed<E, ActionFailure> =>
+  error instanceof InputValidationFailure || error instanceof ActionFailed;
+
+export type ActionError =
+  | ActionInputError
+  | ActionContextError
+  | ActionApiError
+  | ActionOIDCError
+  | ActionSummaryError
+  | ActionFailure;
+
+export const isActionError = <E>(error: E): error is Narrowed<E, ActionError> =>
+  isActionFailure(error) ||
+  error instanceof ActionInputError ||
+  error instanceof ActionContextError ||
+  error instanceof ActionApiError ||
+  error instanceof ActionOIDCError ||
+  error instanceof ActionSummaryError;

package/src/errors/action-input-error.ts

@@ -0,0 +1,24 @@
+import { Schema } from "effect";
+
+export const ActionInputErrorReason = {
+  InvalidType: "InvalidType",
+  Missing: "Missing",
+  ParseError: "ParseError",
+} as const;
+
+const messages = {
+  [ActionInputErrorReason.InvalidType]: (name: string) => `Input "${name}" has invalid type`,
+  [ActionInputErrorReason.Missing]: (name: string) => `Input required and not supplied: ${name}`,
+  [ActionInputErrorReason.ParseError]: (name: string) => `Failed to parse input "${name}"`,
+};
+
+export class ActionInputError extends Schema.TaggedError<ActionInputError>()("ActionInputError", {
+  cause: Schema.optionalKey(Schema.Defect()),
+  name: Schema.String,
+  reason: Schema.Literals(Object.values(ActionInputErrorReason)),
+  value: Schema.optionalKey(Schema.Unknown),
+}) {
+  override get message() {
+    return messages[this.reason](this.name);
+  }
+}

package/src/errors/action-oidc-error.ts

@@ -0,0 +1,19 @@
+import { Schema } from "effect";
+
+export const ActionOIDCErrorReason = {
+  NotAvailable: "NotAvailable",
+  RequestFailed: "RequestFailed",
+} as const;
+
+export class ActionOIDCError extends Schema.TaggedError<ActionOIDCError>()("ActionOIDCError", {
+  cause: Schema.optionalKey(Schema.Defect()),
+  description: Schema.optionalKey(Schema.String),
+  reason: Schema.Literals(Object.values(ActionOIDCErrorReason)),
+}) {
+  override get message() {
+    if (this.reason === ActionOIDCErrorReason.NotAvailable) {
+      return "OIDC token is not available in this environment";
+    }
+    return `OIDC token request failed${this.description === undefined ? "" : `: ${this.description}`}`;
+  }
+}

package/src/errors/action-summary-error.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+
+export const ActionSummaryErrorReason = {
+  NotAvailable: "NotAvailable",
+  WriteFailed: "WriteFailed",
+} as const;
+
+export class ActionSummaryError extends Schema.TaggedError<ActionSummaryError>()(
+  "ActionSummaryError",
+  {
+    cause: Schema.optionalKey(Schema.Defect()),
+    description: Schema.optionalKey(Schema.String),
+    reason: Schema.Literals(Object.values(ActionSummaryErrorReason)),
+  },
+) {
+  override get message() {
+    if (this.reason === ActionSummaryErrorReason.NotAvailable) {
+      return "Job summary is not available in this environment";
+    }
+    return `Failed to write job summary${this.description === undefined ? "" : `: ${this.description}`}`;
+  }
+}

package/src/errors/input-validation-failure.ts

@@ -0,0 +1,23 @@
+import { Schema } from "effect";
+
+export const InputValidationFailureReason = {
+  InvalidJson: "InvalidJson",
+  InvalidType: "InvalidType",
+  MissingRequired: "MissingRequired",
+  SchemaValidation: "SchemaValidation",
+} as const;
+
+export class InputValidationFailure extends Schema.TaggedError<InputValidationFailure>()(
+  "InputValidationFailure",
+  {
+    cause: Schema.optionalKey(Schema.Defect()),
+    input: Schema.String,
+    message: Schema.String,
+    reason: Schema.Literals(Object.values(InputValidationFailureReason)),
+    value: Schema.String,
+  },
+) {
+  get displayMessage() {
+    return `Input '${this.input}' is invalid: ${this.message}`;
+  }
+}

package/src/errors/platform-missing.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+
+export class PlatformMissing extends Schema.TaggedError<PlatformMissing>()("PlatformMissing", {
+  platform: Schema.String,
+}) {
+  override get message() {
+    return `runMain runs on an Effect platform package: install ${this.platform} next to @computis/effect-github.`;
+  }
+}

package/src/input.ts

@@ -0,0 +1,60 @@
+import { Effect, Schema, SchemaGetter, SchemaTransformation } from "effect";
+import { ActionRunner } from "./action-runner.ts";
+import {
+  InputValidationFailure,
+  InputValidationFailureReason,
+} from "./errors/input-validation-failure.ts";
+
+const yamlTrue: ReadonlySet<string> = new Set(["true", "yes", "on", "1"]);
+
+export const YamlBoolean: Schema.Codec<boolean, string> = Schema.String.pipe(
+  Schema.decodeTo(Schema.String, SchemaTransformation.toLowerCase()),
+  Schema.decodeTo(
+    Schema.Literals(["true", "yes", "on", "1", "false", "no", "off", "0", ""]),
+    SchemaTransformation.passthroughSupertype(),
+  ),
+  Schema.decodeTo(Schema.Boolean, {
+    decode: SchemaGetter.transform((literal) => yamlTrue.has(literal)),
+    encode: SchemaGetter.transform((value) => (value ? "true" : "false")),
+  }),
+);
+
+export const raw = Effect.fn("Input.raw")(function* raw(name: string) {
+  const runner = yield* ActionRunner;
+  return yield* runner.getInput(name).pipe(Effect.orDie);
+});
+
+export const parse = Effect.fn("Input.parse")(function* parse<S extends Schema.Top>(
+  name: string,
+  schema: S,
+) {
+  const value = yield* raw(name);
+  return yield* Schema.decodeUnknownEffect(schema)(value).pipe(
+    Effect.mapError(
+      (cause) =>
+        new InputValidationFailure({
+          cause,
+          input: name,
+          message: cause.message,
+          reason: InputValidationFailureReason.SchemaValidation,
+          value,
+        }),
+    ),
+  );
+});
+
+export const string = (name: string) => parse(name, Schema.String);
+
+export const nonEmptyString = (name: string) => parse(name, Schema.NonEmptyString);
+
+export const integer = (name: string) => parse(name, Schema.NumberFromString.check(Schema.isInt()));
+
+export const number = (name: string) => parse(name, Schema.NumberFromString);
+
+export const boolean = (name: string) => parse(name, YamlBoolean);
+
+export const secret = (name: string) =>
+  parse(name, Schema.RedactedFromValue(Schema.NonEmptyString));
+
+export const json = <S extends Schema.Top>(name: string, schema: S) =>
+  parse(name, Schema.fromJsonString(schema));

package/src/object.ts

@@ -0,0 +1,4 @@
+export const whenDefined = <T, U extends object>(
+  value: T,
+  factory: (value: NonNullable<T>) => U,
+) => (value === undefined || value === null ? undefined : factory(value));

package/src/testing/action-client-test.ts

@@ -0,0 +1,15 @@
+import { Redacted } from "effect";
+import type { Layer } from "effect";
+import { ActionClient } from "../action-client.ts";
+
+export const make = (options: { readonly fetch?: typeof globalThis.fetch } = {}) =>
+  ActionClient.layer(Redacted.make("test-token"), {
+    request: {
+      fetch:
+        options.fetch ??
+        (async () =>
+          await Promise.resolve(Response.json({ message: "Not Found" }, { status: 404 }))),
+    },
+  });
+
+export const layer: Layer.Layer<ActionClient> = make();

package/src/testing/action-context-test.ts

@@ -0,0 +1,36 @@
+import { Effect, Layer } from "effect";
+import { ActionContext } from "../action-context.ts";
+import type { ActionContextApi, IssueContext, RepoContext } from "../action-context.ts";
+import { ActionContextError } from "../errors/action-context-error.ts";
+
+export const make = (
+  options: Partial<
+    Omit<ActionContextApi, "repo" | "issue"> & {
+      readonly repo: RepoContext | ActionContextError;
+      readonly issue: IssueContext | ActionContextError;
+    }
+  > = {},
+) => {
+  const repo = options.repo ?? { owner: "octocat", repo: "hello-world" };
+  const issue = options.issue ?? { number: 1, owner: "octocat", repo: "hello-world" };
+  return Layer.succeed(ActionContext, {
+    action: options.action ?? "run",
+    actor: options.actor ?? "octocat",
+    apiUrl: options.apiUrl ?? "https://api.github.com",
+    eventName: options.eventName ?? "push",
+    graphqlUrl: options.graphqlUrl ?? "https://api.github.com/graphql",
+    issue: issue instanceof ActionContextError ? Effect.fail(issue) : Effect.succeed(issue),
+    job: options.job ?? "build",
+    payload: options.payload ?? {},
+    ref: options.ref ?? "refs/heads/main",
+    repo: repo instanceof ActionContextError ? Effect.fail(repo) : Effect.succeed(repo),
+    runAttempt: options.runAttempt ?? 1,
+    runId: options.runId ?? 12_345,
+    runNumber: options.runNumber ?? 1,
+    serverUrl: options.serverUrl ?? "https://github.com",
+    sha: options.sha ?? "abc123def456",
+    workflow: options.workflow ?? "CI",
+  });
+};
+
+export const layer = make();

package/src/testing/action-runner-test.ts

@@ -0,0 +1,138 @@
+import { Effect, Layer, Predicate, Redacted } from "effect";
+import type { Schema } from "effect";
+import { ActionRunner } from "../action-runner.ts";
+import type { InputOptions } from "../action-runner.ts";
+import { ActionInputError, ActionInputErrorReason } from "../errors/action-input-error.ts";
+
+export interface LogEntry {
+  readonly level: "debug" | "info" | "warning" | "error" | "notice";
+  readonly message: string;
+}
+
+const trueInputs = new Set(["true", "True", "TRUE"]);
+const falseInputs = new Set(["false", "False", "FALSE"]);
+
+const messageText = (message: string | Error) =>
+  Predicate.isString(message) ? message : message.message;
+
+export const make = (
+  options: {
+    readonly inputs?: Readonly<Record<string, string>>;
+    readonly state?: Readonly<Record<string, string>>;
+    readonly idToken?: string;
+  } = {},
+) => {
+  const inputs = new Map(Object.entries(options.inputs ?? {}));
+  const recording = {
+    failures: Array.of<string>(),
+    groups: Array.of<string>(),
+    logs: Array.of<LogEntry>(),
+    outputs: new Map<string, Schema.Json>(),
+    paths: Array.of<string>(),
+    secrets: Array.of<string>(),
+    state: new Map(Object.entries(options.state ?? {})),
+    variables: new Map<string, string>(),
+  };
+  const readInput = Effect.fn("ActionRunnerTest.readInput")(function* readInput(
+    name: string,
+    inputOptions: InputOptions = {},
+  ) {
+    const value = inputs.get(name) ?? "";
+    if (inputOptions.required === true && value === "") {
+      return yield* new ActionInputError({ name, reason: ActionInputErrorReason.Missing });
+    }
+    return inputOptions.trimWhitespace === false ? value : value.trim();
+  });
+  const log = (level: LogEntry["level"]) => (message: string | Error) =>
+    Effect.sync(() => {
+      recording.logs.push({ level, message: messageText(message) });
+    });
+  const layer = Layer.succeed(ActionRunner, {
+    addPath: (path) =>
+      Effect.sync(() => {
+        recording.paths.push(path);
+      }),
+    debug: log("debug"),
+    endGroup: () =>
+      Effect.sync(() => {
+        recording.groups.pop();
+      }),
+    error: log("error"),
+    exportVariable: (name, value) =>
+      Effect.sync(() => {
+        recording.variables.set(name, value);
+      }),
+    getBooleanInput: Effect.fn("TestActionRunner.getBooleanInput")(function* getBooleanInput(
+      name: string,
+      inputOptions?: InputOptions,
+    ) {
+      const value = yield* readInput(name, inputOptions).pipe(
+        Effect.mapError(
+          (cause) =>
+            new ActionInputError({ cause, name, reason: ActionInputErrorReason.InvalidType }),
+        ),
+      );
+      if (trueInputs.has(value)) {
+        return true;
+      }
+      if (falseInputs.has(value)) {
+        return false;
+      }
+      return yield* new ActionInputError({
+        name,
+        reason: ActionInputErrorReason.InvalidType,
+        value,
+      });
+    }),
+    getIDToken: () => Effect.succeed(Redacted.make(options.idToken ?? "test-oidc-token")),
+    getInput: readInput,
+    getMultilineInput: Effect.fn("ActionRunnerTest.getMultilineInput")(function* getMultilineInput(
+      name: string,
+      inputOptions?: InputOptions,
+    ) {
+      const value = yield* readInput(name, { ...inputOptions, trimWhitespace: false });
+      return value
+        .split("\n")
+        .filter((line) => line !== "")
+        .map((line) => (inputOptions?.trimWhitespace === false ? line : line.trim()));
+    }),
+    getState: (name) => Effect.sync(() => recording.state.get(name) ?? ""),
+    group: <A, E, R>(name: string, fn: () => Effect.Effect<A, E, R>) =>
+      Effect.acquireUseRelease(
+        Effect.sync(() => {
+          recording.groups.push(name);
+        }),
+        fn,
+        () =>
+          Effect.sync(() => {
+            recording.groups.pop();
+          }),
+      ).pipe(Effect.withSpan("ActionRunnerTest.group", { attributes: { group: name } })),
+    info: log("info"),
+    notice: log("notice"),
+    saveState: (name, value) =>
+      Effect.sync(() => {
+        recording.state.set(name, Predicate.isString(value) ? value : JSON.stringify(value));
+      }),
+    setFailed: (message) =>
+      Effect.sync(() => {
+        recording.failures.push(messageText(message));
+      }),
+    setOutput: (name, value) =>
+      Effect.sync(() => {
+        recording.outputs.set(name, value);
+      }),
+    setSecret: (secret) =>
+      Effect.sync(() => {
+        recording.secrets.push(secret);
+      }),
+    startGroup: (name) =>
+      Effect.sync(() => {
+        recording.groups.push(name);
+      }),
+    warning: log("warning"),
+  });
+  return { layer, recording };
+};
+
+export const { layer } = make();