@alchemy.run/fly 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Bucket.ts

@@ -251,7 +251,7 @@ export type Bucket = Resource<
 export const Bucket = Resource<Bucket>("Fly.Bucket");
 
 export class BucketNotCreated extends Data.TaggedError("Fly.BucketNotCreated")<{
-  name: string;
+  resourceName: string;
 }> {}
 
 export class BucketOrgMissing extends Data.TaggedError("Fly.BucketOrgMissing")<{
@@ -259,13 +259,13 @@ export class BucketOrgMissing extends Data.TaggedError("Fly.BucketOrgMissing")<{
 }> {}
 
 export class BucketProvisionFailed extends Data.TaggedError("Fly.BucketProvisionFailed")<{
-  name: string;
+  resourceName: string;
   status: string | undefined;
   errorMessage: string | undefined;
 }> {}
 
 class BucketPending extends Data.TaggedError("Fly.BucketPending")<{
-  name: string;
+  resourceName: string;
   status: string;
 }> {}
 
@@ -465,20 +465,22 @@ const waitUntilReady = (name: string, addOnId: string) =>
         addOn,
       ): Effect.Effect<AddOnsResponseEdgesItemNode, BucketPending | BucketProvisionFailed> => {
         if (addOn === undefined) {
-          return Effect.fail(new BucketPending({ name, status: "missing" }));
+          return Effect.fail(new BucketPending({ resourceName: name, status: "missing" }));
         }
         const status = addOn.status ?? undefined;
         if (failedStatus(status)) {
           return Effect.fail(
             new BucketProvisionFailed({
-              name,
+              resourceName: name,
               status,
               errorMessage: addOn.errorMessage ?? undefined,
             }),
           );
         }
         if (pendingStatus(status)) {
-          return Effect.fail(new BucketPending({ name, status: status ?? "creating" }));
+          return Effect.fail(
+            new BucketPending({ resourceName: name, status: status ?? "creating" }),
+          );
         }
         return Effect.succeed(addOn);
       },
@@ -506,7 +508,7 @@ const waitUntilGone = (addOnId: string, name: string) =>
       (yield* findById(addOnId)) ?? (name.length > 0 ? yield* findByName(name) : undefined);
     if (still !== undefined) {
       return yield* new BucketPending({
-        name,
+        resourceName: name,
         status: still.status ?? "deleting",
       });
     }
@@ -521,7 +523,7 @@ const waitUntilGone = (addOnId: string, name: string) =>
 const resolveOrganization = (orgSlug: string) =>
   addons
     .organization({ slug: orgSlug })
-    .pipe(Effect.catchTag("FlyIoParseError", () => Effect.succeed(undefined)));
+    .pipe(Effect.catchTag("FlyIoParseError", () => Effect.undefined));
 
 const ensureTos = (orgSlug: string, organizationId: string) =>
   Effect.gen(function* () {
@@ -650,13 +652,13 @@ export const BucketProvider = () =>
       }
 
       if (current === undefined || current.id.length === 0) {
-        return yield* new BucketNotCreated({ name });
+        return yield* new BucketNotCreated({ resourceName: name });
       }
 
       const status = current.status ?? undefined;
       if (failedStatus(status)) {
         return yield* new BucketProvisionFailed({
-          name,
+          resourceName: name,
           status,
           errorMessage: current.errorMessage ?? undefined,
         });
@@ -749,7 +751,7 @@ const requireBucketSecrets = Effect.fn(function* (appName: string, values: Recor
   ];
   if (required.some((key) => !values[key]?.trim())) {
     return yield* new TigrisCredentialsMissing({
-      name: values.BUCKET_NAME || appName,
+      resourceName: values.BUCKET_NAME || appName,
     });
   }
 });
@@ -820,7 +822,7 @@ const findAttachedBucket = (input: { id?: string; name: string }) =>
           : undefined;
     if (listed === undefined) {
       return yield* new BucketPending({
-        name: input.name || input.id || "",
+        resourceName: input.name || input.id || "",
         status: "missing",
       });
     }
@@ -830,7 +832,7 @@ const findAttachedBucket = (input: { id?: string; name: string }) =>
         name: listed.name ?? input.name,
         provider: TIGRIS,
       })
-      .pipe(Effect.catchTag("FlyIoParseError", () => Effect.succeed(undefined)));
+      .pipe(Effect.catchTag("FlyIoParseError", () => Effect.undefined));
     return detail ?? listed;
   });
 

package/src/BucketBinding.ts

@@ -106,7 +106,7 @@ export const makeTigrisS3Binding = <I extends { Bucket?: string }, A, E>(options
           resolvedEndpoint === undefined
         ) {
           return yield* new TigrisCredentialsMissing({
-            name: resolvedName ?? bucket.LogicalId,
+            resourceName: resolvedName ?? bucket.LogicalId,
           });
         }
         const scope = {

package/src/Certificate.ts

@@ -314,7 +314,7 @@ const toAttrsFromSummary = (
 const getByHostname = (appName: string, hostname: string) =>
   machines
     .getAppCertificate({ app_name: appName, hostname })
-    .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
+    .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
 
 const listAppCertificates = (appName: string) =>
   Effect.gen(function* () {
@@ -372,7 +372,7 @@ const createAcme = (appName: string, hostname: string) =>
       app_name: appName,
       hostname,
     })
-    .pipe(Effect.catchTag("Conflict", () => Effect.succeed(undefined)));
+    .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
 
 const createCustom = (appName: string, hostname: string, fullchain: string, privateKey: string) =>
   machines
@@ -382,7 +382,7 @@ const createCustom = (appName: string, hostname: string, fullchain: string, priv
       fullchain,
       private_key: privateKey,
     })
-    .pipe(Effect.catchTag("Conflict", () => Effect.succeed(undefined)));
+    .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
 
 const replaceCustom = (appName: string, hostname: string, fullchain: string, privateKey: string) =>
   Effect.gen(function* () {
@@ -524,7 +524,7 @@ export const CertificateProvider = () =>
             app_name: appName,
             hostname,
           })
-          .pipe(Effect.catchTag(["NotFound", "BadRequest"], () => Effect.succeed(undefined)));
+          .pipe(Effect.catchTag(["NotFound", "BadRequest"], () => Effect.undefined));
         if (checked !== undefined) {
           current = checked;
         }

package/src/ConnectPostgres.ts

@@ -46,7 +46,7 @@ export const connectEnvKeys = (postgres: Pick<Postgres, "LogicalId">) => {
 };
 
 export class PostgresUrlMissing extends Data.TaggedError("Fly.PostgresUrlMissing")<{
-  name: string;
+  resourceName: string;
 }> {}
 
 export interface ConnectPostgresClient {

package/src/ConnectPostgresHttp.ts

@@ -26,7 +26,7 @@ const asRedactedUrl = (
   const url = typeof plain === "string" ? plain : "";
   return url.length > 0
     ? Effect.succeed(Redacted.make(url))
-    : Effect.fail(new PostgresUrlMissing({ name }));
+    : Effect.fail(new PostgresUrlMissing({ resourceName: name }));
 };
 
 /**

package/src/Credentials.ts

@@ -1,20 +1,12 @@
 import { ConfigError } from "@distilled.cloud/core/errors";
 import { Credentials, CredentialsFromEnv } from "@distilled.cloud/fly-io";
-import {
-  deferUntilFirstUse,
-  orDieCredentialsUnavailable,
-  resolveProviderConfig,
-} from "alchemy/Auth/Resolve";
+import { lazyCredentials, orDieCredentialsUnavailable } from "alchemy/Auth/Resolve";
 import * as Output from "alchemy/Output";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
-import {
-  FLY_AUTH_PROVIDER_NAME,
-  type FlyAuthConfig,
-  type FlyResolvedCredentials,
-} from "./AuthProvider.ts";
+import { FLY_AUTH_PROVIDER_NAME, type FlyResolvedCredentials } from "./AuthProvider.ts";
 
 export {
   Credentials,
@@ -37,6 +29,9 @@ export const bindFlyApiToken = (): Effect.Effect<void, never, Credentials> =>
       : yield* Credentials.pipe(
           Effect.flatMap((resolve) => resolve),
           Effect.map((cfg) => Redacted.value(cfg.apiKey)),
+          // Binding initialization cannot fail; the engine reports this
+          // defect as `CredentialsRequired`.
+          orDieCredentialsUnavailable("Fly"),
         );
     yield* Output.named(Output.asOutput(token), "FLY_API_TOKEN").asEffect().pipe(Effect.asVoid);
   });
@@ -73,30 +68,8 @@ export const CredentialsFromAmbientOrEnv: Layer.Layer<Credentials> = Layer.effec
 export const fromAuthProvider = () =>
   Layer.effect(
     Credentials,
-    Effect.gen(function* () {
-      // Defer profile lookup and credential resolution until first use, so
-      // building the provider layers never requires a configured profile.
-      const resolve = yield* resolveProviderConfig<FlyAuthConfig, FlyResolvedCredentials>(
-        FLY_AUTH_PROVIDER_NAME,
-      ).pipe(
-        Effect.flatMap(({ profileName, resolve }) =>
-          resolve.pipe(
-            Effect.map((creds) => ({
-              apiKey: creds.apiKey,
-              apiBaseUrl: creds.apiBaseUrl,
-            })),
-            Effect.mapError((e) =>
-              ConfigError.make({
-                message: `Failed to resolve Fly credentials from ${profileName === undefined ? "the CI environment" : `profile '${profileName}'`}: ${(e as { message?: string }).message ?? String(e)}`,
-              }),
-            ),
-          ),
-        ),
-        deferUntilFirstUse,
-      );
-      return yield* resolve.pipe(
-        orDieCredentialsUnavailable(FLY_AUTH_PROVIDER_NAME),
-        Effect.cached,
-      );
-    }),
+    lazyCredentials<FlyResolvedCredentials, ConfigError>()(FLY_AUTH_PROVIDER_NAME, (creds) => ({
+      apiKey: creds.apiKey,
+      apiBaseUrl: creds.apiBaseUrl,
+    })),
   );

package/src/DeploymentImages.ts

@@ -35,7 +35,7 @@ export const encodeImageSet = (pins: readonly ContainerImagePin[]): string | und
 
 export const decodeImageSet = (raw: string | undefined): ContainerImagePin[] | undefined => {
   if (raw === undefined) return undefined;
-  const decoded = Schema.decodeUnknownOption(Schema.fromJsonString(ImageSet))(raw);
+  const decoded = Schema.decodeOption(Schema.fromJsonString(ImageSet))(raw);
   if (!Option.isSome(decoded)) return undefined;
   const pins = decoded.value;
   return valid(pins) ? canonical(pins) : undefined;

package/src/Errors.ts

@@ -10,5 +10,5 @@ import * as Data from "effect/Data";
  * operation fails with this instead of signing an anonymous request.
  */
 export class TigrisCredentialsMissing extends Data.TaggedError("Fly.TigrisCredentialsMissing")<{
-  name: string;
+  resourceName: string;
 }> {}

package/src/IpAssignment.ts

@@ -382,14 +382,14 @@ export const syncOwnedAppAddresses = Effect.fn(function* (
   if (!observed.some(isDesiredFlycast)) {
     yield* machines
       .createAppIPAssignment({ app_name: appName, type: "private_v6", network })
-      .pipe(Effect.catchTag("Conflict", () => Effect.succeed(undefined)));
+      .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
   }
   if (isPublic) {
     for (const type of ["shared_v4", "v6"] as const) {
       if (observed.some((item) => inferType(item) === type)) continue;
       yield* machines
         .createAppIPAssignment({ app_name: appName, type })
-        .pipe(Effect.catchTag("Conflict", () => Effect.succeed(undefined)));
+        .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
     }
   }
   // Release public addresses of a private Service and Flycast addresses
@@ -415,7 +415,7 @@ export const ensureFlycastAddress = Effect.fn(function* (appName: string, networ
     return;
   yield* machines
     .createAppIPAssignment({ app_name: appName, type: "private_v6", network })
-    .pipe(Effect.catchTag("Conflict", () => Effect.succeed(undefined)));
+    .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
 });
 
 export const IpAssignmentProvider = () =>
@@ -495,7 +495,7 @@ export const IpAssignmentProvider = () =>
             org_slug: props.orgSlug,
             service_name: props.serviceName,
           })
-          .pipe(Effect.catchTag("Conflict", () => Effect.succeed(undefined)));
+          .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
         if (created !== undefined && created.ip !== undefined) {
           current = created;
         } else {

package/src/Machine.ts

@@ -844,7 +844,7 @@ export type Machine = Resource<
 export const Machine = Resource<Machine>("Fly.Machine");
 
 export class MachineNotCreated extends Data.TaggedError("Fly.MachineNotCreated")<{
-  name: string;
+  resourceName: string;
   appName: string;
 }> {}
 
@@ -928,7 +928,7 @@ const desiredEnv = (
 const desiredMetadata = (
   props: MachineProps,
   alchemy: Record<string, string>,
-): Record<string, string> => ({ ...(props.metadata ?? {}), ...alchemy });
+): Record<string, string> => ({ ...props.metadata, ...alchemy });
 
 const buildConfig = (input: {
   image: string | undefined;
@@ -1245,7 +1245,9 @@ export const MachineProvider = () =>
           }),
       }).pipe(
         Effect.catchTag("Fly.ReplicaNotCreated", (error) =>
-          Effect.fail(new MachineNotCreated({ name: error.name, appName: error.appName })),
+          Effect.fail(
+            new MachineNotCreated({ resourceName: error.resourceName, appName: error.appName }),
+          ),
         ),
       );
       return toAttrs(set);

package/src/Postgres.ts

@@ -286,7 +286,7 @@ export type Postgres = Resource<
 export const Postgres = Resource<Postgres>("Fly.Postgres");
 
 export class PostgresNotCreated extends Data.TaggedError("Fly.PostgresNotCreated")<{
-  name: string;
+  resourceName: string;
   orgSlug: string;
 }> {}
 
@@ -369,7 +369,7 @@ const resolveName = (id: string, name: string | undefined, existing?: string) =>
 export const getLiveCluster = (clusterId: string) =>
   mpg.getClusterById({ id: clusterId }).pipe(
     Effect.map((res) => (isLiveCluster(res.data) ? res.data : undefined)),
-    Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+    Effect.catchTag("NotFound", () => Effect.undefined),
   );
 
 export const getClusterResponse = (clusterId: string) =>
@@ -377,7 +377,7 @@ export const getClusterResponse = (clusterId: string) =>
     Effect.map((res): GetClusterResponse | undefined =>
       isLiveCluster(res.data) ? res : undefined,
     ),
-    Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+    Effect.catchTag("NotFound", () => Effect.undefined),
   );
 
 const listOrgClusters = (orgSlug: string) =>
@@ -535,7 +535,7 @@ export const attachPostgresSecrets = Effect.fn(function* (
       times: 10,
       schedule: backoff,
     }),
-    Effect.catchTag("Fly.PostgresCredentialsPending", () => Effect.succeed(undefined)),
+    Effect.catchTag("Fly.PostgresCredentialsPending", () => Effect.undefined),
   );
   if (creds === undefined) {
     return yield* new PostgresCredentialsMissing({ clusterId });
@@ -660,7 +660,7 @@ export const PostgresProvider = () =>
 
       if (current === undefined) {
         if (region === undefined || region.length === 0) {
-          return yield* new PostgresNotCreated({ name, orgSlug });
+          return yield* new PostgresNotCreated({ resourceName: name, orgSlug });
         }
         const created = yield* mpg
           .createCluster({
@@ -674,13 +674,13 @@ export const PostgresProvider = () =>
           })
           .pipe(
             Effect.map((res) => res.data),
-            Effect.catchTag("Conflict", () => Effect.succeed(undefined)),
+            Effect.catchTag("Conflict", () => Effect.undefined),
           );
         current = isLiveCluster(created) ? created : yield* findByName(orgSlug, name);
       }
 
       if (current === undefined || current.id === undefined) {
-        return yield* new PostgresNotCreated({ name, orgSlug });
+        return yield* new PostgresNotCreated({ resourceName: name, orgSlug });
       }
       // `current` is reassigned below; the id is stable across the waits.
       const clusterId = current.id;

package/src/PostgresMigrations.ts

@@ -1,52 +1,18 @@
 import {
-  makePgMigrationExecutor,
+  MigrationError,
   runMigrations,
+  withPgExecutor,
   type NormalizedMigrationsInput,
+  type SqlExecutor,
   type StampedMigrationsState,
 } from "@alchemy.run/sql/Migrations";
-import { importPg } from "@alchemy.run/sql/PostgresDriver";
-import { readSqlFile } from "@alchemy.run/sql/SqlFile";
-import * as Data from "effect/Data";
+import { stripSslQueryParams } from "@alchemy.run/sql/PostgresDriver";
+import { applySqlImports } from "@alchemy.run/sql/SqlFile";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
-import * as Schedule from "effect/Schedule";
-import type { Client } from "pg";
 
-export class PostgresMigrationError extends Data.TaggedError("Fly.PostgresMigrationError")<{
-  message: string;
-  cause?: unknown;
-}> {}
+export { stripSslQueryParams };
 
-/**
- * Strip query-string SSL flags so `pg-connection-string` does not treat
- * `sslmode=require` as `verify-full`. TLS and certificate verification
- * are set on the client (`ssl.rejectUnauthorized: true`).
- */
-export const stripSslQueryParams = (uri: string): string => {
-  try {
-    const url = new URL(uri);
-    url.searchParams.delete("sslmode");
-    url.searchParams.delete("channel_binding");
-    return url.toString();
-  } catch {
-    return uri;
-  }
-};
-
-const toMigrationError = (cause: unknown) =>
-  new PostgresMigrationError({
-    message: cause instanceof Error ? cause.message : String(cause),
-    cause,
-  });
-
-/**
- * A freshly-provisioned Fly Managed Postgres cluster reports `ready` on the
- * API before its hostname is resolvable and its endpoint accepts
- * connections — reconcile's first migration connect can fail with
- * `ENOTFOUND` (DNS still propagating) or a refused/reset socket. These are
- * eventual consistency, not failures: retry the connect on a bounded
- * schedule (~45s) before surfacing the error.
- */
 const TRANSIENT_CONNECT_CODES = new Set([
   "ENOTFOUND",
   "EAI_AGAIN",
@@ -55,40 +21,32 @@ const TRANSIENT_CONNECT_CODES = new Set([
   "ETIMEDOUT",
 ]);
 
-const isTransientConnectError = (error: PostgresMigrationError): boolean => {
-  const code = (error.cause as { code?: unknown } | null | undefined)?.code;
+const isTransientConnectError = (cause: unknown): boolean => {
+  const code = (cause as { code?: unknown } | null | undefined)?.code;
   return typeof code === "string" && TRANSIENT_CONNECT_CODES.has(code);
 };
 
-/** Open a pg client for the scope of `use`, closing it afterwards. */
-export const withPgClient = <A, E, R>(
+/**
+ * A verified-TLS `pg` session on a Fly Managed Postgres URI for the scope
+ * of `use`. A fresh cluster's hostname takes a moment to resolve, so
+ * connection failures are retried; one that persists is almost always a
+ * missing route — MPG hostnames only exist on the org's private network.
+ */
+const withFlyPgExecutor = <A, E, R>(
   connectionUri: Redacted.Redacted<string>,
-  use: (client: Client) => Effect.Effect<A, E, R>,
-): Effect.Effect<A, PostgresMigrationError | E, R> =>
-  Effect.acquireUseRelease(
-    Effect.tryPromise({
-      try: async () => {
-        const { Client } = await importPg();
-        const client = new Client({
-          connectionString: connectionUri.pipe(Redacted.value, stripSslQueryParams),
-          ssl: { rejectUnauthorized: true },
-        });
-        await client.connect();
-        return client;
-      },
-      catch: toMigrationError,
-    }).pipe(
-      Effect.retry({
-        while: isTransientConnectError,
-        schedule: Schedule.spaced("3 seconds"),
-        times: 15,
-      }),
-      // Still unreachable after the bounded retry: almost always a missing
-      // route rather than propagation — MPG hostnames only exist on the org
-      // private network. Say so instead of a bare `getaddrinfo ENOTFOUND`.
-      Effect.mapError((error) =>
-        isTransientConnectError(error)
-          ? new PostgresMigrationError({
+  use: (executor: SqlExecutor) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, MigrationError | E, R> =>
+  withPgExecutor(
+    {
+      connectionString: connectionUri.pipe(Redacted.value, stripSslQueryParams),
+      ssl: { rejectUnauthorized: true },
+    },
+    use,
+    {
+      retryConnect: { while: isTransientConnectError, times: 15, interval: "3 seconds" },
+      onConnectFailure: (error) =>
+        isTransientConnectError(error.cause)
+          ? new MigrationError({
               message:
                 `${error.message} — Fly Managed Postgres is only reachable ` +
                 "on the org's private network. Run the deploy behind a " +
@@ -97,10 +55,7 @@ export const withPgClient = <A, E, R>(
               cause: error.cause,
             })
           : error,
-      ),
-    ),
-    use,
-    (client) => Effect.promise(() => client.end().catch(() => {})),
+    },
   );
 
 /**
@@ -114,40 +69,25 @@ export const runPgMigrations = (options: {
   stamped: StampedMigrationsState;
 }) =>
   runMigrations({
-    ...options,
-    withExecutor: (apply) =>
-      withPgClient(options.connectionUri, (client) => apply(makePgMigrationExecutor(client))),
+    input: options.input,
+    stamped: options.stamped,
+    withExecutor: (apply) => withFlyPgExecutor(options.connectionUri, apply),
   });
 
 /** Run a single SQL script against the database (used for `importFiles`). */
 export const runSql = (connectionUri: Redacted.Redacted<string>, sql: string) =>
-  withPgClient(connectionUri, (client) =>
-    Effect.tryPromise({
-      try: () => client.query(sql),
-      catch: toMigrationError,
-    }),
-  ).pipe(Effect.asVoid);
+  withFlyPgExecutor(connectionUri, (executor) => executor.query(sql)).pipe(Effect.asVoid);
 
+/** Apply `importFiles`, each once and again only when it changes. */
 export const runImports = (
   connectionUri: Redacted.Redacted<string>,
   importFiles: ReadonlyArray<string>,
   rootDir: string,
   previous: Record<string, string>,
 ) =>
-  Effect.gen(function* () {
-    const hashes: Record<string, string> = { ...previous };
-    for (const filePath of importFiles) {
-      const file = yield* readSqlFile(rootDir, filePath);
-      if (previous[filePath] === file.hash) {
-        hashes[filePath] = file.hash;
-        continue;
-      }
-      yield* runSql(connectionUri, file.sql);
-      hashes[filePath] = file.hash;
-    }
-    const tracked = new Set(importFiles);
-    for (const key of Object.keys(hashes)) {
-      if (!tracked.has(key)) delete hashes[key];
-    }
-    return hashes;
+  applySqlImports({
+    importFiles,
+    rootDir,
+    previous,
+    apply: (file) => runSql(connectionUri, file.sql),
   });

package/src/Redis.ts

@@ -24,10 +24,13 @@ export const REDIS_ADDON_TYPE = "upstash_redis";
 export const REDIS_PROVIDER = "upstash_redis";
 export const REDIS_URL_ENV = "REDIS_URL";
 
+// Re-export from the defining module, not the `@alchemy.run/redis` barrel:
+// rolldown's lazyBarrel rejects an unused re-export from an `export *` barrel
+// (https://github.com/rolldown/rolldown/issues/11344).
 export {
   CommandError as RedisCommandError,
   UrlMissing as RedisUrlMissing,
-} from "@alchemy.run/redis";
+} from "@alchemy.run/redis/Errors";
 
 export interface RedisProps {
   /**
@@ -222,7 +225,7 @@ export type Redis = Resource<
 export const Redis = Resource<Redis>("Fly.Redis");
 
 export class RedisNotCreated extends Data.TaggedError("Fly.RedisNotCreated")<{
-  name: string;
+  resourceName: string;
   errorMessage?: string;
 }> {}
 
@@ -454,7 +457,7 @@ const resolvePlan = (plan: string | undefined, existingId: string | undefined) =
 const resolveOrganization = (orgSlug: string) =>
   addons
     .organization({ slug: orgSlug })
-    .pipe(Effect.catchTag("FlyIoParseError", () => Effect.succeed(undefined)));
+    .pipe(Effect.catchTag("FlyIoParseError", () => Effect.undefined));
 
 const ensureTos = (orgSlug: string, organizationId: string) =>
   Effect.gen(function* () {
@@ -485,7 +488,7 @@ const waitUntilReady = (id: string, name: string) =>
         if (failedStatus(row.status)) {
           return Effect.fail(
             new RedisNotCreated({
-              name: row.name ?? name,
+              resourceName: row.name ?? name,
               errorMessage: row.errorMessage ?? row.status ?? undefined,
             }),
           );
@@ -522,7 +525,7 @@ const waitUntilGone = (id: string, name: string) =>
 const desiredOptions = (
   props: RedisProps,
   plan: RedisPlan,
-  observed: unknown | undefined,
+  observed: unknown,
 ): Record<string, unknown> => {
   const options = recordOf(observed);
   if (props.eviction !== undefined) options.eviction = props.eviction;
@@ -595,7 +598,7 @@ export const attachRedisSecrets = Effect.fn(function* (
     if ((url === undefined || url.length === 0) && row.id !== undefined) {
       const detail = yield* addons
         .addOn({ id: row.id })
-        .pipe(Effect.catchTag("FlyIoParseError", () => Effect.succeed(undefined)));
+        .pipe(Effect.catchTag("FlyIoParseError", () => Effect.undefined));
       url = unwrapSensitive(detail?.publicUrl);
     }
     if (url === undefined || url.length === 0) {
@@ -735,7 +738,7 @@ export const RedisProvider = () =>
       }
 
       if (current === undefined) {
-        return yield* new RedisNotCreated({ name });
+        return yield* new RedisNotCreated({ resourceName: name });
       }
 
       if (pendingStatus(current.status)) {
@@ -744,7 +747,7 @@ export const RedisProvider = () =>
       }
 
       if (current === undefined) {
-        return yield* new RedisNotCreated({ name });
+        return yield* new RedisNotCreated({ resourceName: name });
       }
 
       const observedOptions = recordOf(current.options);

package/src/RedisBinding.ts

@@ -52,7 +52,7 @@ export const makeRedisBinding = <Client>(options: { makeClient: (url: Url) => Cl
 
       const urlFromResource = yield* redis.url;
       const missing = new RedisUrlMissing({
-        name: asPlain(redis.name) ?? redis.LogicalId,
+        resourceName: asPlain(redis.name) ?? redis.LogicalId,
       });
       const url: Url = Effect.gen(function* () {
         const fromOutput = asPlain(yield* urlFromResource);

package/src/RedisHttp.ts

@@ -4,8 +4,11 @@
  * The RESP client lives in `@alchemy.run/redis`. These aliases keep the
  * `{Op}Http.ts` layers stable.
  */
+// Re-export from the defining module, not the `@alchemy.run/redis` barrel:
+// rolldown's lazyBarrel rejects an unused re-export from an `export *` barrel
+// (https://github.com/rolldown/rolldown/issues/11344).
 export {
   makeRead as makeReadRedisClient,
   makeReadWrite as makeReadWriteRedisClient,
   makeWrite as makeWriteRedisClient,
-} from "@alchemy.run/redis";
+} from "@alchemy.run/redis/Client";