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

package/src/IpAssignment.ts

@@ -85,9 +85,21 @@ export type IpAssignment = Resource<
     createdAt: string | undefined;
   },
   never,
-  Providers
+  Providers,
+  IpAssignmentLookup
 >;
 
+/**
+ * Props for {@link IpAssignment.lookup}: find an address this stack
+ * doesn't manage by its App and IP.
+ */
+export interface IpAssignmentLookup {
+  /** Fly App name the address is assigned to. */
+  appName: string;
+  /** The allocated address. */
+  ip: string;
+}
+
 const resolveIpAssignmentProps = (
   props: IpAssignmentProps | Effect.Effect<IpAssignmentProps, never, Providers>,
 ): Effect.Effect<IpAssignmentProps, never, Providers> =>
@@ -247,6 +259,19 @@ const IpAssignmentResource = Resource<IpAssignment>("Fly.IpAssignment");
  * );
  * ```
  *
+ * ### Looking up an existing address
+ * `IpAssignment.lookup` references an address Alchemy doesn't manage
+ * (allocated with `fly ips allocate-v4` or by another stack). It is read
+ * during plan/deploy, never allocated or released.
+ *
+ * **Example:** Reference an existing address
+ * ```typescript
+ * const ip = Fly.IpAssignment.lookup({
+ *   appName: "my-site",
+ *   ip: "2a09:8280:1::1",
+ * });
+ * ```
+ *
  * @resource
  * @product App
  */
@@ -382,14 +407,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 +440,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 = () =>
@@ -439,6 +464,11 @@ export const IpAssignmentProvider = () =>
       return undefined;
     }),
 
+    lookup: Effect.fn(function* ({ appName, ip }) {
+      const found = yield* findByIp(appName, ip);
+      return found?.ip === undefined ? undefined : toAttrs(appName, found);
+    }),
+
     read: Effect.fn(function* ({ olds, output }) {
       const appName = output?.appName ?? appNameOf(olds?.app);
       if (appName === undefined) return undefined;
@@ -495,7 +525,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

@@ -33,6 +33,7 @@ import type { Providers } from "./Providers.ts";
 import {
   deleteReplicaSet,
   listReplicaSets,
+  lookupReplicaSet,
   observeReplicaSet,
   reconcileReplicas,
   resolveCount,
@@ -379,9 +380,25 @@ export type Machine = Resource<
     replicas: Replica[];
   },
   ServiceBinding,
-  Providers
+  Providers,
+  MachineLookup
 >;
 
+/**
+ * Props for {@link Machine.lookup}: find Machines this stack doesn't
+ * manage by their App and name.
+ */
+export interface MachineLookup {
+  /** Fly App name the Machines run in. */
+  appName: string;
+  /**
+   * Machine name (unique per App). Replicas named `{name}-{N}` are
+   * found with it, as are the replicas of an Alchemy Machine whose base
+   * name it is.
+   */
+  name: string;
+}
+
 /**
  * A Fly.Machine is a Firecracker VM running one image or a named container group.
  *
@@ -838,13 +855,24 @@ export type Machine = Resource<
  * discovers unfinished owned generations.
  * See the [deployment guide](/fly/compute/deployments) for recovery and limits.
  *
+ * ### Looking up existing Machines
+ * `Machine.lookup` references Machines Alchemy doesn't manage (started with
+ * `fly machine run` or by another stack). It is read during plan/deploy,
+ * never created, updated or deleted.
+ *
+ * **Example:** Reference an existing Machine
+ * ```typescript
+ * const worker = Fly.Machine.lookup({ appName: "my-app", name: "worker" });
+ * const address = worker.privateIp;
+ * ```
+ *
  * @resource
  * @product Machine
  */
 export const Machine = Resource<Machine>("Fly.Machine");
 
 export class MachineNotCreated extends Data.TaggedError("Fly.MachineNotCreated")<{
-  name: string;
+  resourceName: string;
   appName: string;
 }> {}
 
@@ -928,7 +956,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;
@@ -1154,6 +1182,11 @@ export const MachineProvider = () =>
       return output.rolloutPending ? { action: "update" as const } : undefined;
     }),
 
+    lookup: Effect.fn(function* ({ appName, name }) {
+      const found = yield* lookupReplicaSet({ appName, name });
+      return found === undefined ? undefined : toAttrs(found);
+    }),
+
     read: Effect.fn(function* ({ id, fqn, instanceId, olds, output }) {
       const appName = appNameOf(olds?.app) ?? output?.appName;
       const name = yield* resolveMachineName(id, olds?.name, output?.baseName ?? output?.name);
@@ -1245,7 +1278,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/MountVolume.ts

@@ -116,6 +116,11 @@ export interface ServiceBinding {
    * published.
    */
   target?: BoundTarget;
+  /**
+   * A Service that calls this one, recorded on the target by
+   * `Fly.bindService`. Only the Apps recorded here may call its methods.
+   */
+  caller?: { appName: string };
 }
 
 /** A Service bound by `Fly.bindService` or `Fly.bindEndpoint`. */
@@ -128,8 +133,6 @@ export interface BoundTarget {
   network: string | undefined;
   /** The bound Service's private address; `undefined` when it publishes nothing. */
   privateUrl: string | undefined;
-  /** The bound Service's caller token. */
-  rpcToken?: import("effect/Redacted").Redacted<string>;
   /** Port `Fly.bindEndpoint` targets; the binding port for `bindService`. */
   port?: number;
   /** Ports the bound Service publishes, for `Fly.bindEndpoint`. */

package/src/Postgres.ts

@@ -93,6 +93,13 @@ export interface PostgresProps {
    * is reachable on the org private network; deploy-time apply needs a
    * route to that network (a WireGuard peer, `fly mpg proxy`, or a
    * machine already on 6PN).
+   *
+   * History is forward-only and linear. A new file must sort after every
+   * applied one, or the deploy fails with `NonLinearMigrationHistoryError`;
+   * an edited or deleted applied file fails with
+   * `RewrittenMigrationHistoryError`. Renaming an applied file without
+   * changing its contents keeps it applied. See
+   * [Migrations](https://alchemy.run/sql/effect-sql/migrations#change-migration-history-safely).
    */
   migrations?: MigrationsInput;
   /**
@@ -143,9 +150,24 @@ export type Postgres = Resource<
     importHashes: Record<string, string>;
   },
   never,
-  Providers
+  Providers,
+  PostgresLookup
 >;
 
+/**
+ * Props for {@link Postgres.lookup}: find a Managed Postgres cluster
+ * this stack doesn't manage by its name.
+ */
+export interface PostgresLookup {
+  /** Cluster name (unique in the org). */
+  name: string;
+  /**
+   * Organization slug.
+   * @default the current token's org
+   */
+  orgSlug?: string;
+}
+
 /**
  * A Fly.Postgres is a Managed Postgres (MPG) cluster. It is billed.
  * Do not wrap unmanaged `fly postgres`.
@@ -280,13 +302,25 @@ export type Postgres = Resource<
  * });
  * ```
  *
+ * ### Looking up an existing cluster
+ * `Postgres.lookup` references a cluster Alchemy doesn't manage (created
+ * with `fly mpg create` or by another stack). It is read during
+ * plan/deploy, never created, updated or deleted, and its connection URIs
+ * come from Fly like a declared cluster's.
+ *
+ * **Example:** Connect to an existing cluster
+ * ```typescript
+ * const db = Fly.Postgres.lookup({ name: "my-db" });
+ * const sql = yield* Fly.ConnectPostgres(db);
+ * ```
+ *
  * @resource
  * @product Postgres
  */
 export const Postgres = Resource<Postgres>("Fly.Postgres");
 
 export class PostgresNotCreated extends Data.TaggedError("Fly.PostgresNotCreated")<{
-  name: string;
+  resourceName: string;
   orgSlug: string;
 }> {}
 
@@ -369,7 +403,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 +411,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 +569,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 });
@@ -602,6 +636,14 @@ export const PostgresProvider = () =>
       return undefined;
     }),
 
+    lookup: Effect.fn(function* ({ name, orgSlug }) {
+      const org = orgSlug ?? (yield* resolveOrgSlug());
+      const found = yield* findByName(org, name);
+      if (found === undefined) return undefined;
+      const hydrated = found.id !== undefined ? yield* getClusterResponse(found.id) : undefined;
+      return toAttrs(hydrated?.data ?? found, { name, orgSlug: org }, hydrated?.credentials);
+    }),
+
     read: Effect.fn(function* ({ id, olds, output }) {
       const found =
         output?.clusterId !== undefined && output.clusterId.length > 0
@@ -660,7 +702,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 +716,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,17 @@ 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";
+// Clients' runtime effects require redis's `RuntimeContext` twin, so it shows
+// up in users' inferred types. Exporting it here lets TypeScript name it
+// through this package without users depending on @alchemy.run/redis.
+export type { RuntimeContext as RedisRuntimeContext } from "@alchemy.run/redis/RuntimeContext";
 
 export interface RedisProps {
   /**
@@ -105,9 +112,19 @@ export type Redis = Resource<
     url: Redacted.Redacted<string> | undefined;
   },
   never,
-  Providers
+  Providers,
+  RedisLookup
 >;
 
+/**
+ * Props for {@link Redis.lookup}: find an Upstash Redis this stack
+ * doesn't manage by its name.
+ */
+export interface RedisLookup {
+  /** Upstash Redis name. */
+  name: string;
+}
+
 /**
  * Managed Upstash Redis in a Fly org. Bind {@link ReadRedis},
  * {@link WriteRedis}, or {@link ReadWriteRedis} on a {@link Service}.
@@ -216,13 +233,24 @@ export type Redis = Resource<
  * need a specific size.
  * :::
  *
+ * ### Looking up an existing Redis
+ * `Redis.lookup` references a Redis Alchemy doesn't manage (created with
+ * `fly redis create` or by another stack). It is read during plan/deploy,
+ * never created, updated or deleted. Bind it like a declared Redis.
+ *
+ * **Example:** Read an existing Redis
+ * ```typescript
+ * const cache = Fly.Redis.lookup({ name: "my-cache" });
+ * const redis = yield* Fly.ReadRedis(cache);
+ * ```
+ *
  * @resource
  * @product Redis
  */
 export const Redis = Resource<Redis>("Fly.Redis");
 
 export class RedisNotCreated extends Data.TaggedError("Fly.RedisNotCreated")<{
-  name: string;
+  resourceName: string;
   errorMessage?: string;
 }> {}
 
@@ -454,7 +482,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 +513,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 +550,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 +623,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) {
@@ -651,6 +679,23 @@ export const RedisProvider = () =>
       return undefined;
     }),
 
+    lookup: Effect.fn(function* ({ name }) {
+      const found = yield* findRedisAddOn({ name });
+      if (found === undefined) return undefined;
+      let url = unwrapSensitive(found.publicUrl);
+      if ((url === undefined || url.length === 0) && found.id !== undefined) {
+        const detail = yield* addons
+          .addOn({ id: found.id })
+          .pipe(Effect.catchTag("FlyIoParseError", () => Effect.undefined));
+        url = unwrapSensitive(detail?.publicUrl);
+      }
+      return toAttrs(found, {
+        name,
+        primaryRegion: DEFAULT_REDIS_REGION,
+        url: url === undefined || url.length === 0 ? undefined : Redacted.make(url),
+      });
+    }),
+
     read: Effect.fn(function* ({ id, olds, output }) {
       const name = yield* resolveName(id, olds?.name, output?.name);
       const found =
@@ -735,7 +780,7 @@ export const RedisProvider = () =>
       }
 
       if (current === undefined) {
-        return yield* new RedisNotCreated({ name });
+        return yield* new RedisNotCreated({ resourceName: name });
       }
 
       if (pendingStatus(current.status)) {
@@ -744,7 +789,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";