@distilled.cloud/expo-eas 1.0.0-rc.13 → 1.0.0-rc.14

package/lib/traits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traits.d.ts","sourceRoot":"","sources":["../src/traits.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AAMrC;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;CACrC;AAED,eAAO,MAAM,eAAe,eAE3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,OAAQ,cAAc,qDACP,CAAC;AAEtC,eAAO,MAAM,kBAAkB,eAE9B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,SAAU,MAAM,qDACC,CAAC;AAE3C,eAAO,MAAM,wBAAwB,eAEpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,wDACiB,CAAC"}
+{"version":3,"file":"traits.d.ts","sourceRoot":"","sources":["../src/traits.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AAMrC;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;CACrC;AAED,eAAO,MAAM,eAAe,eAAqD,CAAC;AAElF;;;GAGG;AACH,eAAO,MAAM,SAAS,OAAQ,cAAc,qDAAwC,CAAC;AAErF,eAAO,MAAM,kBAAkB,eAAwD,CAAC;AAExF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,SAAU,MAAM,qDAA6C,CAAC;AAEvF,eAAO,MAAM,wBAAwB,eAEpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,wDAAuD,CAAC"}

package/lib/traits.js.map

@@ -1 +1 @@
-{"version":3,"file":"traits.js","sourceRoot":"","sources":["../src/traits.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAGhB,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AAkBrC,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CACvC,sCAAsC,CACvC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,EAAkB,EAAE,EAAE,CAC9C,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;AAEtC,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAC1C,yCAAyC,CAC1C,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,IAAY,EAAE,EAAE,CAC3C,cAAc,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;AAE3C,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,GAAG,CAChD,gDAAgD,CACjD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,EAAE,CACrC,cAAc,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC"}
+{"version":3,"file":"traits.js","sourceRoot":"","sources":["../src/traits.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAGhB,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AAkBrC,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,sCAAsC,CAAC,CAAC;AAElF;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,EAAkB,EAAE,EAAE,CAAC,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;AAErF,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAC,yCAAyC,CAAC,CAAC;AAExF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,cAAc,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;AAEvF,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,GAAG,CAChD,gDAAgD,CACjD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,EAAE,CAAC,cAAc,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC"}

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@distilled.cloud/expo-eas",
-  "version": "1.0.0-rc.13",
+  "version": "1.0.0-rc.14",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/alchemy-run/distilled",
     "directory": "packages/expo-eas"
   },
-  "license": "Apache-2.0",
-  "type": "module",
-  "sideEffects": false,
-  "module": "src/index.ts",
   "files": [
     "lib",
     "src"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "module": "src/index.ts",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
@@ -65,20 +65,22 @@
     }
   },
   "dependencies": {
-    "@distilled.cloud/core": "1.0.0-rc.13"
+    "@distilled.cloud/core": "1.0.0-rc.14"
   },
   "devDependencies": {
-    "@types/bun": "1.3.14",
-    "@types/node": "26.2.0",
-    "@effect/platform-bun": "^4.0.0"
+    "@types/node": "26.2.0"
   },
   "peerDependencies": {
     "effect": "^4.0.0"
   },
+  "distilled": {
+    "generatedAt": "2026-10-05",
+    "specUpdatedAt": "2026-10-03"
+  },
   "scripts": {
     "build": "tsc -b",
-    "convert": "bun scripts/convert.ts",
-    "generate": "bun scripts/generate.ts",
+    "convert": "node --conditions=bun scripts/convert.ts",
+    "generate": "node --conditions=bun scripts/generate.ts",
     "typecheck": "tsc -p tsconfig.json",
     "specs:fetch": "git submodule update --force --init --depth=1 specs/spec-mirror-expo-eas",
     "specs:update": "git submodule update --remote --force --depth=1 specs/spec-mirror-expo-eas"

package/src/credentials.ts

@@ -22,10 +22,9 @@ export interface Config {
   readonly apiBaseUrl: string;
 }
 
-export class Credentials extends Context.Service<
-  Credentials,
-  Effect.Effect<Config>
->()("EasCredentials") {}
+export class Credentials extends Context.Service<Credentials, Effect.Effect<Config>>()(
+  "EasCredentials",
+) {}
 
 const envConfig = EffectConfig.all({
   accessToken: EffectConfig.String("EXPO_TOKEN"),

package/src/errors.ts

@@ -26,6 +26,7 @@ export {
   DEFAULT_ERRORS,
   API_ERRORS,
 } from "@distilled.cloud/core/errors";
+import * as Category from "@distilled.cloud/core/category";
 import type {
   BadRequest,
   Conflict,
@@ -35,31 +36,23 @@ import type {
   NotFound,
   UnprocessableEntity,
 } from "@distilled.cloud/core/errors";
-
 import * as Schema from "effect/Schema";
-import * as Category from "@distilled.cloud/core/category";
 
 /**
  * Catch-all for EAS GraphQL errors that don't match any other tagged class.
  * Carries the raw `errors[]` envelope and a best-effort `code` / `message`.
  */
-export class UnknownEasError extends Schema.TaggedError<UnknownEasError>()(
-  "UnknownEasError",
-  {
-    code: Schema.optional(Schema.String),
-    message: Schema.optional(Schema.String),
-    body: Schema.Unknown,
-  },
-).pipe(Category.withServerError) {}
+export class UnknownEasError extends Schema.TaggedError<UnknownEasError>()("UnknownEasError", {
+  code: Schema.optional(Schema.String),
+  message: Schema.optional(Schema.String),
+  body: Schema.Unknown,
+}).pipe(Category.withServerError) {}
 
 /** Schema parse error wrapper (response body did not match the operation schema). */
-export class EasParseError extends Schema.TaggedError<EasParseError>()(
-  "EasParseError",
-  {
-    body: Schema.Unknown,
-    cause: Schema.Unknown,
-  },
-).pipe(Category.withParseError) {}
+export class EasParseError extends Schema.TaggedError<EasParseError>()("EasParseError", {
+  body: Schema.Unknown,
+  cause: Schema.Unknown,
+}).pipe(Category.withParseError) {}
 
 /**
  * The installed eas-cli / API client is too old. Returned with errorCode
@@ -157,9 +150,7 @@ export class EasChannelAlreadyExists extends Schema.TaggedError<EasChannelAlread
   {
     message: Schema.String,
   },
-).pipe(
-  Category.withCategory(Category.ConflictError, Category.AlreadyExistsError),
-) {}
+).pipe(Category.withCategory(Category.ConflictError, Category.AlreadyExistsError)) {}
 
 /**
  * The authenticated actor does not have permission to perform this operation
@@ -205,9 +196,7 @@ export class EasDevDomainNameTaken extends Schema.TaggedError<EasDevDomainNameTa
   {
     message: Schema.String,
   },
-).pipe(
-  Category.withCategory(Category.ConflictError, Category.AlreadyExistsError),
-) {}
+).pipe(Category.withCategory(Category.ConflictError, Category.AlreadyExistsError)) {}
 
 /**
  * Map from EAS GraphQL `extensions.errorCode` → typed error class.
@@ -230,10 +219,8 @@ export const EAS_ERROR_CODE_MAP: Record<string, any> = {
   EAS_BUILD_FREE_TIER_IOS_LIMIT_EXCEEDED: EasBuildFreeTierLimitExceeded,
   EAS_BUILD_FREE_TIER_ANDROID_LIMIT_EXCEEDED: EasBuildFreeTierLimitExceeded,
   EAS_BUILD_TOO_MANY_PENDING_BUILDS: EasBuildTooManyPendingBuilds,
-  EAS_BUILD_RESOURCE_CLASS_NOT_AVAILABLE_IN_FREE_TIER:
-    EasBuildResourceClassNotAvailableInFreeTier,
-  EAS_BUILD_LEGACY_RESOURCE_CLASS_NOT_AVAILABLE:
-    EasBuildLegacyResourceClassNotAvailable,
+  EAS_BUILD_RESOURCE_CLASS_NOT_AVAILABLE_IN_FREE_TIER: EasBuildResourceClassNotAvailableInFreeTier,
+  EAS_BUILD_LEGACY_RESOURCE_CLASS_NOT_AVAILABLE: EasBuildLegacyResourceClassNotAvailable,
   CHANNEL_ALREADY_EXISTS: EasChannelAlreadyExists,
   UNAUTHORIZED_ERROR: EasUnauthorizedOperation,
   EXPERIENCE_NOT_FOUND: EasExperienceNotFound,

package/src/index.ts

@@ -13,10 +13,6 @@
 export * from "./credentials.ts";
 export * from "./errors.ts";
 export * as T from "./traits.ts";
-export {
-  ExpoGraphqlProtocol,
-  type ExpoEasOpError,
-  type ExpoEasOpContext,
-} from "./protocol.ts";
+export { ExpoGraphqlProtocol, type ExpoEasOpError, type ExpoEasOpContext } from "./protocol.ts";
 export * as Retry from "./retry.ts";
 export * as Services from "./services/index.ts";

package/src/protocol.test.ts

@@ -0,0 +1,362 @@
+import * as ResponseValidation from "@distilled.cloud/core/response-validation";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Result from "effect/Result";
+import { describe, expect, test } from "vitest";
+import { Credentials, CredentialsFromEnv } from "./credentials.ts";
+import {
+  BadGateway,
+  BadRequest,
+  EasChannelAlreadyExists,
+  EasExperienceNotFound,
+  EasParseError,
+  EasUnauthorizedOperation,
+  InternalServerError,
+  ServiceUnavailable,
+  TooManyRequests,
+  Unauthorized,
+  UnknownEasError,
+} from "./errors.ts";
+import type { ExpoEasOpContext } from "./protocol.ts";
+import * as Retry from "./retry.ts";
+import { accessTokenDeleteAccessToken, accessTokenSetAccessTokenRevoked } from "./services/eas.ts";
+
+interface Reply {
+  readonly status?: number;
+  readonly body?: string;
+  readonly headers?: Record<string, string>;
+}
+
+const credentialsLayer = (apiBaseUrl: string, token = "expo-token") =>
+  Layer.succeed(Credentials, Effect.succeed({ accessToken: Redacted.make(token), apiBaseUrl }));
+
+const prod = credentialsLayer("https://api.expo.dev");
+
+/** A fake HttpClient that records each request (as a web Request) and answers with `reply`. */
+const fakeHttp = (reply: Reply) => {
+  const requests: Array<Request> = [];
+  const http = Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request) =>
+      Effect.sync(() => {
+        requests.push(Result.getOrThrow(HttpClientRequest.toWebResult(request)));
+        return HttpClientResponse.fromWeb(
+          request,
+          new Response(reply.body ?? "", {
+            status: reply.status ?? 200,
+            headers: reply.headers,
+          }),
+        );
+      }),
+    ),
+  );
+  return { requests, http };
+};
+
+const run = <A, E>(
+  operation: Effect.Effect<A, E, ExpoEasOpContext>,
+  reply: Reply,
+  creds: Layer.Layer<Credentials> = prod,
+) => {
+  const { requests, http } = fakeHttp(reply);
+  const promise = Effect.runPromise(
+    operation.pipe(Retry.none, Effect.provide(Layer.mergeAll(http, creds))),
+  );
+  return { requests, promise };
+};
+
+const deleteToken = () => accessTokenDeleteAccessToken({ id: "tok-1" });
+
+const succeed = (reply: Reply) => run(deleteToken(), reply).promise;
+const failWith = (reply: Reply, operation = deleteToken()) =>
+  run(Effect.flip(operation), reply).promise;
+
+const data = (id: unknown) =>
+  JSON.stringify({ data: { accessToken: { deleteAccessToken: { id } } } });
+
+const graphqlErrors = (
+  errors: ReadonlyArray<{ message: string; extensions?: Record<string, string> }>,
+  extra: Record<string, unknown> = {},
+) => JSON.stringify({ data: null, errors, ...extra });
+
+describe("request envelope", () => {
+  test("POSTs { query, operationName, variables } to <base>/graphql with a Bearer token", async () => {
+    const { requests, promise } = run(deleteToken(), { body: data("tok-1") });
+    await promise;
+    expect(requests).toHaveLength(1);
+    const request = requests[0]!;
+    expect(request.method).toBe("POST");
+    expect(request.url).toBe("https://api.expo.dev/graphql");
+    expect(request.headers.get("authorization")).toBe("Bearer expo-token");
+    expect(request.headers.get("accept")).toBe("application/json");
+    expect(request.headers.get("content-type")).toContain("application/json");
+    const body = await request.json();
+    expect(body).toEqual({
+      query: expect.stringContaining("mutation accessTokenDeleteAccessToken($id: ID!)"),
+      operationName: "accessTokenDeleteAccessToken",
+      variables: { id: "tok-1" },
+    });
+  });
+
+  test("input members are variables verbatim: undefined dropped, null kept", async () => {
+    const omitted = run(accessTokenSetAccessTokenRevoked({ id: "tok-1", revoked: undefined }), {
+      body: JSON.stringify({ data: { accessToken: { setAccessTokenRevoked: null } } }),
+    });
+    await omitted.promise;
+    expect((await omitted.requests[0]!.json()).variables).toEqual({ id: "tok-1" });
+
+    const nulled = run(accessTokenSetAccessTokenRevoked({ id: "tok-1", revoked: null }), {
+      body: JSON.stringify({ data: { accessToken: { setAccessTokenRevoked: null } } }),
+    });
+    await nulled.promise;
+    expect((await nulled.requests[0]!.json()).variables).toEqual({ id: "tok-1", revoked: null });
+  });
+
+  test("the staging base URL is honoured", async () => {
+    const { requests, promise } = run(
+      deleteToken(),
+      { body: data("tok-1") },
+      credentialsLayer("https://staging-api.expo.dev", "staging-token"),
+    );
+    await promise;
+    expect(requests[0]!.url).toBe("https://staging-api.expo.dev/graphql");
+    expect(requests[0]!.headers.get("authorization")).toBe("Bearer staging-token");
+  });
+
+  const fromEnv = (env: Record<string, string>) =>
+    Layer.mergeAll(
+      CredentialsFromEnv,
+      Layer.succeed(ConfigProvider.ConfigProvider, ConfigProvider.fromUnknown(env)),
+    );
+
+  test("CredentialsFromEnv targets production by default and staging via EXPO_API_URL", async () => {
+    const production = run(
+      deleteToken(),
+      { body: data("tok-1") },
+      fromEnv({ EXPO_TOKEN: "env-token" }),
+    );
+    await production.promise;
+    expect(production.requests[0]!.url).toBe("https://api.expo.dev/graphql");
+    expect(production.requests[0]!.headers.get("authorization")).toBe("Bearer env-token");
+
+    const staging = run(
+      deleteToken(),
+      { body: data("tok-1") },
+      fromEnv({ EXPO_TOKEN: "env-token", EXPO_API_URL: "https://staging-api.expo.dev" }),
+    );
+    await staging.promise;
+    expect(staging.requests[0]!.url).toBe("https://staging-api.expo.dev/graphql");
+  });
+});
+
+describe("data envelope", () => {
+  test("returns the value at data.<responsePath>", async () => {
+    expect(await succeed({ body: data("tok-1") })).toEqual({ id: "tok-1" });
+  });
+
+  test("a missing or null path segment yields null", async () => {
+    expect(await succeed({ body: JSON.stringify({ data: { accessToken: null } }) })).toBeNull();
+    expect(await succeed({ body: JSON.stringify({ data: null }) })).toBeNull();
+  });
+
+  test("an empty errors array is not a failure", async () => {
+    const body = JSON.stringify({
+      data: { accessToken: { deleteAccessToken: { id: "tok-1" } } },
+      errors: [],
+    });
+    expect(await succeed({ body })).toEqual({ id: "tok-1" });
+  });
+});
+
+describe("GraphQL errors", () => {
+  test("errors[] inside HTTP 200 map extensions.errorCode to the typed class", async () => {
+    const error = await failWith({
+      body: graphqlErrors([
+        { message: "Channel already exists", extensions: { errorCode: "CHANNEL_ALREADY_EXISTS" } },
+      ]),
+    });
+    expect(error).toBeInstanceOf(EasChannelAlreadyExists);
+    expect(error).toMatchObject({ message: "Channel already exists" });
+  });
+
+  test("extensions.code is the fallback code field", async () => {
+    const error = await failWith({
+      body: graphqlErrors([{ message: "Not allowed", extensions: { code: "UNAUTHORIZED_ERROR" } }]),
+    });
+    expect(error).toBeInstanceOf(EasUnauthorizedOperation);
+  });
+
+  test("only the first error is used", async () => {
+    const error = await failWith({
+      body: graphqlErrors([
+        { message: "missing", extensions: { errorCode: "EXPERIENCE_NOT_FOUND" } },
+        { message: "taken", extensions: { errorCode: "CHANNEL_ALREADY_EXISTS" } },
+      ]),
+    });
+    expect(error).toBeInstanceOf(EasExperienceNotFound);
+    expect(error).toMatchObject({ message: "missing" });
+  });
+
+  test("errors win over partial data", async () => {
+    const error = await failWith({
+      body: JSON.stringify({
+        data: { accessToken: { deleteAccessToken: { id: "tok-1" } } },
+        errors: [{ message: "partial", extensions: { errorCode: "CHANNEL_ALREADY_EXISTS" } }],
+      }),
+    });
+    expect(error).toBeInstanceOf(EasChannelAlreadyExists);
+  });
+
+  test("an unknown code inside HTTP 200 is UnknownEasError carrying code, message and body", async () => {
+    const body = graphqlErrors([
+      { message: "Something new", extensions: { errorCode: "BRAND_NEW_CODE" } },
+    ]);
+    const error = await failWith({ body });
+    expect(error).toBeInstanceOf(UnknownEasError);
+    expect(error).toMatchObject({
+      code: "BRAND_NEW_CODE",
+      message: "Something new",
+      body: JSON.parse(body),
+    });
+  });
+
+  test("an error without extensions inside HTTP 200 is UnknownEasError without a code", async () => {
+    const error = await failWith({
+      body: graphqlErrors([{ message: 'Cannot query field "nope" on type "Query".' }]),
+    });
+    expect(error).toBeInstanceOf(UnknownEasError);
+    expect(error).toMatchObject({ message: 'Cannot query field "nope" on type "Query".' });
+    expect((error as UnknownEasError).code).toBeUndefined();
+  });
+
+  test("an unknown code under an error status uses the HTTP status class", async () => {
+    const error = await failWith({
+      status: 400,
+      body: graphqlErrors([
+        { message: "Variable $id is required", extensions: { code: "GRAPHQL_VALIDATION_FAILED" } },
+      ]),
+    });
+    expect(error).toBeInstanceOf(BadRequest);
+    expect(error).toMatchObject({ message: "Variable $id is required" });
+  });
+
+  test("a typed code still wins under an error status", async () => {
+    const error = await failWith({
+      status: 403,
+      body: graphqlErrors([
+        { message: "Not allowed", extensions: { errorCode: "UNAUTHORIZED_ERROR" } },
+      ]),
+    });
+    expect(error).toBeInstanceOf(EasUnauthorizedOperation);
+  });
+});
+
+describe("HTTP-level failures", () => {
+  test("a REST-ish { message } body uses the status class", async () => {
+    const error = await failWith({
+      status: 401,
+      body: JSON.stringify({ message: "Invalid access token" }),
+    });
+    expect(error).toBeInstanceOf(Unauthorized);
+    expect(error).toMatchObject({ message: "Invalid access token" });
+  });
+
+  test("429 carries the Retry-After hint", async () => {
+    const error = await failWith({
+      status: 429,
+      body: JSON.stringify({ message: "Too many requests" }),
+      headers: { "retry-after": "5" },
+    });
+    expect(error).toBeInstanceOf(TooManyRequests);
+    expect(Duration.toSeconds((error as TooManyRequests).retryAfter!)).toBe(5);
+  });
+
+  test("an empty JSON object under 500 is InternalServerError", async () => {
+    const error = await failWith({ status: 500, body: "{}" });
+    expect(error).toBeInstanceOf(InternalServerError);
+  });
+
+  test("a REST-ish body under an unmapped status is UnknownEasError", async () => {
+    const error = await failWith({
+      status: 418,
+      body: JSON.stringify({ message: "teapot", code: "TEAPOT" }),
+    });
+    expect(error).toBeInstanceOf(UnknownEasError);
+    expect(error).toMatchObject({ code: "TEAPOT", message: "teapot" });
+  });
+});
+
+describe("non-JSON HTTP-level failures", () => {
+  test("an HTML 502 proxy page is BadGateway with the trimmed body as message", async () => {
+    const html = "<html><body><h1>502 Bad Gateway</h1></body></html>";
+    const error = await failWith({
+      status: 502,
+      body: `\n  ${html}\n`,
+      headers: { "content-type": "text/html" },
+    });
+    expect(error).toBeInstanceOf(BadGateway);
+    expect(error).toMatchObject({ message: html });
+  });
+
+  test("a plain-text 500 is InternalServerError", async () => {
+    const error = await failWith({ status: 500, body: "Internal Server Error" });
+    expect(error).toBeInstanceOf(InternalServerError);
+    expect(error).toMatchObject({ message: "Internal Server Error" });
+  });
+
+  test("a plain-text 429 is TooManyRequests carrying the Retry-After hint", async () => {
+    const error = await failWith({
+      status: 429,
+      body: "Too Many Requests",
+      headers: { "content-type": "text/plain", "retry-after": "7" },
+    });
+    expect(error).toBeInstanceOf(TooManyRequests);
+    expect(error).toMatchObject({ message: "Too Many Requests" });
+    expect(Duration.toSeconds((error as TooManyRequests).retryAfter!)).toBe(7);
+  });
+
+  test("a plain-text 401 is Unauthorized", async () => {
+    const error = await failWith({ status: 401, body: "Unauthorized\n" });
+    expect(error).toBeInstanceOf(Unauthorized);
+    expect(error).toMatchObject({ message: "Unauthorized" });
+  });
+
+  test("an empty error body uses the status class with an HTTP <status> message", async () => {
+    const error = await failWith({ status: 503, body: "" });
+    expect(error).toBeInstanceOf(ServiceUnavailable);
+    expect(error).toMatchObject({ message: "HTTP 503" });
+  });
+
+  test("a non-JSON body under an unmapped status is UnknownEasError carrying the body", async () => {
+    const error = await failWith({ status: 418, body: "I'm a teapot" });
+    expect(error).toBeInstanceOf(UnknownEasError);
+    expect(error).toMatchObject({ body: "I'm a teapot" });
+  });
+});
+
+describe("response validation", () => {
+  const strict = deleteToken().pipe(Effect.provide(ResponseValidation.strict));
+
+  test("lenient mode returns a mismatched payload as read", async () => {
+    expect((await succeed({ body: data(42) })) as unknown).toEqual({ id: 42 });
+  });
+
+  test("strict mode fails a mismatched payload with EasParseError", async () => {
+    expect(await failWith({ body: data(42) }, strict)).toBeInstanceOf(EasParseError);
+  });
+
+  test("strict mode passes a matching payload", async () => {
+    expect(await run(strict, { body: data("tok-1") }).promise).toEqual({ id: "tok-1" });
+  });
+
+  test("a non-JSON 2xx body: lenient returns the text, strict fails", async () => {
+    expect((await succeed({ body: "not json" })) as unknown).toBe("not json");
+    expect(await failWith({ body: "not json" }, strict)).toBeInstanceOf(EasParseError);
+  });
+});