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

package/src/Sprite.ts

@@ -5,7 +5,7 @@ import * as Bundle from "alchemy/Bundle/Bundle";
 import { isResolved } from "alchemy/Diff";
 import { Platform, type Main, type PlatformProps } from "alchemy/Platform";
 import * as Provider from "alchemy/Provider";
-import type { Resource, ResourceBinding } from "alchemy/Resource";
+import type { LookupMethod, Resource, ResourceBinding } from "alchemy/Resource";
 import type { ServerHost } from "alchemy/Runtime/Process";
 import { Stack } from "alchemy/Stack";
 import { createInternalTags } from "alchemy/Tags";
@@ -119,9 +119,19 @@ export type Sprite = Resource<
     };
   },
   SpriteBinding,
-  Providers
+  Providers,
+  SpriteLookup
 >;
 
+/**
+ * Props for {@link Sprite.lookup}: find a Sprite this stack doesn't
+ * manage by its name.
+ */
+export interface SpriteLookup {
+  /** Sprite name (unique per org). */
+  name: string;
+}
+
 export const isSprite = (value: unknown): value is Sprite =>
   typeof value === "object" && value !== null && (value as { Type?: string }).Type === "Fly.Sprite";
 
@@ -307,29 +317,38 @@ export type SpriteRuntimeContext = FlyHostRuntimeContext;
  * ) {}
  * ```
  *
+ * ### Looking up an existing Sprite
+ * `Sprite.lookup` references a Sprite Alchemy doesn't manage (created with
+ * `sprite create` or by another stack). It is read during plan/deploy,
+ * never created, updated or deleted. `code.hash` is empty: the Sprite's
+ * program isn't Alchemy's.
+ *
+ * **Example:** Reference an existing Sprite
+ * ```typescript
+ * const box = Fly.Sprite.lookup({ name: "my-box" });
+ * ```
+ *
  * @resource
  * @product Sprite
  */
-export const Sprite: Platform<Sprite, SpriteServices, SpriteShape, SpriteRuntimeContext> = Platform(
-  "Fly.Sprite",
-  {
-    createRuntimeContext: createFlyHostRuntimeContext("Fly.Sprite"),
-  },
-);
+export const Sprite: Platform<Sprite, SpriteServices, SpriteShape, SpriteRuntimeContext> &
+  LookupMethod<Sprite> = Platform("Fly.Sprite", {
+  createRuntimeContext: createFlyHostRuntimeContext("Fly.Sprite"),
+});
 
 export class SpriteNotCreated extends Data.TaggedError("Fly.SpriteNotCreated")<{
-  name: string;
+  resourceName: string;
 }> {}
 
 export class SpriteExecFailed extends Data.TaggedError("Fly.SpriteExecFailed")<{
-  name: string;
+  resourceName: string;
   cmd: string;
   exitCode: number | undefined;
   stderr: string | undefined;
 }> {}
 
 class SpritePending extends Data.TaggedError("Fly.SpritePending")<{
-  name: string;
+  resourceName: string;
 }> {}
 
 const toStatus = (status: string | undefined): SpriteStatus =>
@@ -368,12 +387,14 @@ const ownershipLabels = (id: string) =>
   });
 
 const getByName = (name: string) =>
-  sprites.getSprite({ name }).pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
+  sprites.getSprite({ name }).pipe(Effect.catchTag("NotFound", () => Effect.undefined));
 
 const waitForSprite = (name: string) =>
   getByName(name).pipe(
     Effect.flatMap((found) =>
-      found !== undefined ? Effect.succeed(found) : Effect.fail(new SpritePending({ name })),
+      found !== undefined
+        ? Effect.succeed(found)
+        : Effect.fail(new SpritePending({ resourceName: name })),
     ),
     Effect.retry({
       while: (e) => e._tag === "Fly.SpritePending",
@@ -458,7 +479,7 @@ const runExec = (input: { name: string; cmd: string[]; env?: string[] }) =>
     );
     if ((result.exit_code ?? 0) !== 0) {
       return yield* new SpriteExecFailed({
-        name: input.name,
+        resourceName: input.name,
         cmd: input.cmd.join(" "),
         exitCode: result.exit_code,
         stderr: result.stderr,
@@ -573,15 +594,22 @@ export const SpriteProvider = () =>
           return undefined;
         }),
 
+        lookup: Effect.fn(function* ({ name }) {
+          const found = yield* getByName(name).pipe(
+            Effect.catchTag("SpritesNotEnabled", () => Effect.undefined),
+          );
+          return found === undefined ? undefined : toAttrs(found, name, "");
+        }),
+
         read: Effect.fn(function* ({ id, olds, output }) {
           const name = yield* resolveSpriteName(id, olds?.name, output?.name);
           const found = yield* (
-            output?.name !== undefined ? getByName(output.name) : Effect.succeed(undefined)
+            output?.name !== undefined ? getByName(output.name) : Effect.undefined
           ).pipe(
             Effect.flatMap((existing) =>
               existing !== undefined ? Effect.succeed(existing) : getByName(name),
             ),
-            Effect.catchTag("SpritesNotEnabled", () => Effect.succeed(undefined)),
+            Effect.catchTag("SpritesNotEnabled", () => Effect.undefined),
           );
           if (found === undefined) return undefined;
           const attrs = toAttrs(found, name, output?.code.hash ?? "");
@@ -628,7 +656,7 @@ export const SpriteProvider = () =>
           }
 
           if (current === undefined) {
-            return yield* new SpriteNotCreated({ name });
+            return yield* new SpriteNotCreated({ resourceName: name });
           }
           // Narrowed once so the `NotFound` fallbacks below keep the
           // non-optional type instead of widening back to `| undefined`.

package/src/Volume.ts

@@ -16,7 +16,7 @@ export const DEFAULT_VOLUME_REGION = "iad";
 export const MIN_SIZE_GB = 1;
 
 export class VolumeNotCreated extends Data.TaggedError("Fly.VolumeNotCreated")<{
-  name: string;
+  resourceName: string;
   appName: string;
 }> {}
 
@@ -39,7 +39,7 @@ const transientState = (state: string | undefined) =>
 export const getVolumeById = (appName: string, volumeId: string) =>
   machines.getVolumeById({ app_name: appName, volume_id: volumeId }).pipe(
     Effect.map((volume) => (destroying(volume.state) ? undefined : volume)),
-    Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+    Effect.catchTag("NotFound", () => Effect.undefined),
   );
 
 export const listVolumesByApp = (appName: string) =>
@@ -66,7 +66,7 @@ export const listVolumeGroup = (appName: string, name: string, region: string) =
 export const waitUntilVolumeReady = (appName: string, volumeId: string) =>
   getVolumeById(appName, volumeId).pipe(
     Effect.flatMap((volume) => {
-      if (volume === undefined) return Effect.succeed(undefined);
+      if (volume === undefined) return Effect.undefined;
       if (transientState(volume.state)) {
         return Effect.fail(
           new VolumePending({
@@ -116,6 +116,11 @@ export const createVolume = Effect.fn(function* (input: {
   disk: DiskSpec;
 }) {
   const sizeGb = Math.max(input.disk.sizeGb, MIN_SIZE_GB);
+  // The volumes this group held before the create: a storage host that fails
+  // with an unknown outcome may still have made one.
+  const before = new Set(
+    (yield* listVolumeGroup(input.appName, input.name, input.region)).map((volume) => volume.id),
+  );
   const created = yield* machines
     .createVolume({
       app_name: input.appName,
@@ -130,7 +135,26 @@ export const createVolume = Effect.fn(function* (input: {
       source_volume_id: input.disk.sourceVolumeId,
       require_unique_zone: input.disk.requireUniqueZone,
     })
-    .pipe(Effect.catchTag("Conflict", () => Effect.succeed(undefined)));
+    .pipe(
+      Effect.catchTags({
+        Conflict: () => Effect.undefined,
+        StorageHostCapacity: (error) =>
+          Effect.gen(function* () {
+            // Its outcome is unknown: a single new volume in the group is the
+            // one this call made. Otherwise create again after a pause.
+            yield* Effect.sleep(Duration.seconds(5));
+            const fresh = (yield* listVolumeGroup(input.appName, input.name, input.region)).filter(
+              (volume) => volume.id !== undefined && !before.has(volume.id),
+            );
+            return fresh.length === 1 ? fresh[0] : yield* error;
+          }),
+      }),
+      Effect.retry({
+        while: (error) => error._tag === "StorageHostCapacity",
+        schedule: Schedule.spaced(Duration.seconds(5)),
+        times: 6,
+      }),
+    );
   if (created?.id !== undefined && created.id.length > 0) {
     return (yield* waitUntilVolumeReady(input.appName, created.id)) ?? created;
   }
@@ -138,7 +162,7 @@ export const createVolume = Effect.fn(function* (input: {
   const hit = group.at(-1);
   if (hit === undefined || hit.id === undefined) {
     return yield* new VolumeNotCreated({
-      name: input.name,
+      resourceName: input.name,
       appName: input.appName,
     });
   }
@@ -211,7 +235,7 @@ export const ensureVolumeGroup = Effect.fn(function* (input: {
   }
   if (group.length < input.count) {
     return yield* new VolumeNotCreated({
-      name: input.name,
+      resourceName: input.name,
       appName: input.appName,
     });
   }

package/src/VolumeSnapshot.ts

@@ -56,9 +56,23 @@ export type VolumeSnapshot = Resource<
     createdAt: string | undefined;
   },
   never,
-  Providers
+  Providers,
+  VolumeSnapshotLookup
 >;
 
+/**
+ * Props for {@link VolumeSnapshot.lookup}: find a snapshot this stack
+ * doesn't manage by its App, Volume and id.
+ */
+export interface VolumeSnapshotLookup {
+  /** Fly App name the Volume belongs to. */
+  appName: string;
+  /** Fly Volume id (`vol_…`). */
+  volumeId: string;
+  /** Fly snapshot id (`vs_…`). */
+  snapshotId: string;
+}
+
 /**
  * A Fly.VolumeSnapshot is an on-demand snapshot of a mounted disk.
  *
@@ -127,6 +141,25 @@ export type VolumeSnapshot = Resource<
  * ) {}
  * ```
  *
+ * ### Looking up an existing snapshot
+ * `VolumeSnapshot.lookup` references a snapshot Alchemy doesn't manage
+ * (taken by Fly's daily schedule or by another stack). It is read during
+ * plan/deploy and never created or deleted.
+ *
+ * **Example:** Restore a disk from an existing snapshot
+ * ```typescript
+ * const snapshot = Fly.VolumeSnapshot.lookup({
+ *   appName: "my-app",
+ *   volumeId: "vol_123",
+ *   snapshotId: "vs_456",
+ * });
+ * const disk = yield* Fly.MountVolume({
+ *   path: "/data",
+ *   sizeGb: 1,
+ *   snapshotId: snapshot.snapshotId,
+ * });
+ * ```
+ *
  * @resource
  * @product Volume
  */
@@ -214,7 +247,7 @@ const waitForNewSnapshot = (appName: string, volumeId: string, knownIds: Readonl
       times: 8,
       schedule: backoff,
     }),
-    Effect.catchTag("Fly.VolumeSnapshotPending", () => Effect.succeed(undefined)),
+    Effect.catchTag("Fly.VolumeSnapshotPending", () => Effect.undefined),
   );
 
 export const VolumeSnapshotProvider = () =>
@@ -235,6 +268,11 @@ export const VolumeSnapshotProvider = () =>
       return undefined;
     }),
 
+    lookup: Effect.fn(function* ({ appName, volumeId, snapshotId }) {
+      const found = yield* findById(appName, volumeId, snapshotId);
+      return found === undefined ? undefined : toAttrs(appName, volumeId, found);
+    }),
+
     read: Effect.fn(function* ({ olds, output }) {
       const appName = output?.appName ?? appNameOf(olds?.app);
       const volumeId = output?.volumeId ?? volumeIdOf(olds?.volumeId);

package/src/Website/AssetDeployment.ts

@@ -95,7 +95,7 @@ const scopeOf = (bucket: Bucket) =>
       endpoint === undefined
     ) {
       return yield* new TigrisCredentialsMissing({
-        name: bucketName ?? bucket.LogicalId,
+        resourceName: bucketName ?? bucket.LogicalId,
       });
     }
     return { bucketName, accessKeyId, secretAccessKey, endpoint, region };
@@ -131,14 +131,14 @@ const walkFiles = Effect.fn(function* (root: string) {
   const path = yield* Path.Path;
   if (!(yield* fs.exists(root))) return [] as string[];
   const names = yield* fs.readDirectory(root, { recursive: true });
-  const files = yield* Effect.all(
-    names.map((name) =>
+  const files = yield* Effect.forEach(
+    names,
+    (name) =>
       Effect.gen(function* () {
         const full = path.join(root, name);
         const stat = yield* fs.stat(full);
         return stat.type === "File" ? name.replaceAll("\\", "/") : undefined;
       }),
-    ),
     { concurrency: "unbounded" },
   );
   return files
@@ -213,8 +213,9 @@ export const AssetDeploymentProvider = () =>
           : path.resolve(initialCwd, news.sourcePath);
         const files = yield* walkFiles(root);
         const observed = yield* listObserved(scope, prefix);
-        const prepared = yield* Effect.all(
-          files.map((relative) =>
+        const prepared = yield* Effect.forEach(
+          files,
+          (relative) =>
             Effect.gen(function* () {
               const body = yield* fs.readFile(path.join(root, relative));
               const key = prefix.length > 0 ? `${prefix}/${relative}` : relative;
@@ -222,7 +223,6 @@ export const AssetDeploymentProvider = () =>
               const cacheControl = cacheControlOf(relative);
               return { relative, key, body, contentType, cacheControl };
             }),
-          ),
           { concurrency: "unbounded" },
         );
         const version = yield* Effect.sync(() => {
@@ -258,10 +258,9 @@ export const AssetDeploymentProvider = () =>
         );
 
         if (news.purge ?? true) {
-          yield* Effect.all(
-            [...observed.keys()]
-              .filter((key) => !desired.has(key))
-              .map((key) => deleteObject(scope, key)),
+          yield* Effect.forEach(
+            [...observed.keys()].filter((key) => !desired.has(key)),
+            (key) => deleteObject(scope, key),
             { concurrency: s3Concurrency },
           );
         }
@@ -283,10 +282,9 @@ export const AssetDeploymentProvider = () =>
           if (!(olds.purge ?? true)) return;
           const scope = yield* scopeOf(olds.bucket);
           const observed = yield* listObserved(scope, output.prefix);
-          yield* Effect.all(
-            [...observed.keys()].map((key) => deleteObject(scope, key)),
-            { concurrency: s3Concurrency },
-          );
+          yield* Effect.forEach([...observed.keys()], (key) => deleteObject(scope, key), {
+            concurrency: s3Concurrency,
+          });
         },
         Effect.catchTag("NoSuchBucket", () => Effect.void),
       ),

package/src/Website/Astro.ts

@@ -1,3 +1,5 @@
+import { resolveAstroOutput } from "alchemy/Website/AstroOutput";
+import * as Effect from "effect/Effect";
 import { frameworkSite, staticConfigFromAssets, type FrameworkSiteProps } from "./FrameworkSite.ts";
 
 /** The framework-integration package that drives the Astro build. */
@@ -21,8 +23,9 @@ export interface AstroProps extends FrameworkSiteProps {
      * Astro output target. `"server"` renders pages on demand; individual
      * pages opt into prerendering with `export const prerender = true`.
      * `"static"` prerenders every page at build time and deploys
-     * assets-only (no SSR server).
-     * @default "server"
+     * assets-only (no SSR server). Overrides the `output` in your
+     * `astro.config.*`; leave it unset to use the file's value.
+     * @default the config file's `output`, else `"server"`
      */
     output?: "server" | "static";
     /** Source directory, relative to `rootDir`. @default "./src" */
@@ -41,9 +44,9 @@ export interface AstroProps extends FrameworkSiteProps {
  * running the Node adapter's serve entry (static files first, then the
  * framework handler) on port 3000.
  *
- * Pages render on demand by default (`output: "server"`). With
- * `astro: { output: "static" }` every page is prerendered and the deploy
- * is assets-only.
+ * Pages render on demand by default (`output: "server"`). When your
+ * `astro.config.*` or `astro: { output: "static" }` declares a static
+ * site, every page is prerendered and the deploy is assets-only.
  *
  *
  * ### Creating Astro Sites
@@ -75,13 +78,15 @@ export interface AstroProps extends FrameworkSiteProps {
  * @resource
  * @product Website
  */
-export const Astro = (id: string, props: AstroProps = {}) => {
-  const output = props.astro?.output ?? "server";
-  return frameworkSite(id, props, {
-    name: "Astro",
-    framework: ASTRO_FRAMEWORK_SPECIFIER,
-    target: ASTRO_NODE_TARGET_SPECIFIER,
-    options: { astro: { ...props.astro, output } },
-    static: output === "static" ? staticConfigFromAssets(props.assets) : undefined,
-  });
-};
+export const Astro = (id: string, props: AstroProps = {}) =>
+  resolveAstroOutput({ rootDir: props.rootDir, output: props.astro?.output }).pipe(
+    Effect.flatMap((output) =>
+      frameworkSite(id, props, {
+        name: "Astro",
+        framework: ASTRO_FRAMEWORK_SPECIFIER,
+        target: ASTRO_NODE_TARGET_SPECIFIER,
+        options: { astro: { ...props.astro, output } },
+        static: output === "static" ? staticConfigFromAssets(props.assets) : undefined,
+      }),
+    ),
+  );

package/src/Website/FrameworkSite.ts

@@ -1,5 +1,7 @@
 import { AlchemyContext } from "alchemy/AlchemyContext";
 import type { MemoOptions } from "alchemy/Command/Memo";
+import * as DNS from "alchemy/DNS/Adapter";
+import type { Input } from "alchemy/Input";
 import * as Namespace from "alchemy/Namespace";
 import * as Output from "alchemy/Output";
 import { ProviderModePolicy } from "alchemy/ProviderMode";
@@ -18,7 +20,7 @@ import * as Path from "effect/Path";
 import * as Redacted from "effect/Redacted";
 import { App } from "../App.ts";
 import { Bucket } from "../Bucket.ts";
-import { Certificate } from "../Certificate.ts";
+import { Certificate, type CertificateDnsRequirements } from "../Certificate.ts";
 import { IpAssignment } from "../IpAssignment.ts";
 import type { Providers } from "../Providers.ts";
 import { Service, type ServiceProps } from "../Service.ts";
@@ -33,6 +35,80 @@ export type Ref<T> = T | Effect.Effect<T, never, Providers>;
 export type { ServerDevProps, WebsiteAssetsProps, WebsiteNotFoundHandling };
 export { staticConfigFromAssets };
 
+/**
+ * Custom hostname of a Fly website: the hostname itself, or
+ * `{ name, dns }` to also publish its DNS records.
+ */
+export type WebsiteDomain =
+  | string
+  | {
+      /** Hostname, e.g. `www.example.com`. */
+      name: string;
+      /**
+       * DNS host that publishes the hostname's records (see
+       * [DNS Adapters](/infrastructure-as-code/dns-adapters)), e.g.
+       * `Cloudflare.DNS.Adapter()`: the ACME challenge `CNAME` Fly lists in
+       * the Certificate's `dnsRequirements`, and `A` / `AAAA` records at
+       * the site's addresses. Omitted: publish the records yourself.
+       */
+      dns?: DNS.DnsConfig;
+    };
+
+/** The hostname of a {@link WebsiteDomain}. */
+export const websiteDomainName = (domain: WebsiteDomain | undefined): string | undefined =>
+  domain === undefined || typeof domain === "string" ? domain : domain.name;
+
+const acmeChallengeRecords = (
+  hostname: string,
+  requirements: CertificateDnsRequirements | undefined,
+): DNS.DnsRecord[] => {
+  const challenge = requirements?.acmeChallenge;
+  if (challenge?.target === undefined || challenge.target.length === 0) {
+    return [];
+  }
+  const expected = `_acme-challenge.${hostname}`;
+  const name =
+    challenge.name !== undefined &&
+    DNS.normalizeDnsName(challenge.name).endsWith(DNS.normalizeDnsName(hostname))
+      ? challenge.name
+      : expected;
+  return [{ name, type: "CNAME", value: challenge.target }];
+};
+
+/**
+ * Publish a Fly website's records through `domain.dns`: the Certificate's
+ * ACME challenge `CNAME` (`CertificateValidation`) and `A` / `AAAA`
+ * records at the site's shared IPv4 plus any IPv6 Fly lists for the
+ * hostname (`Domain`). No-op for a plain hostname or an object without
+ * `dns`.
+ */
+export const publishWebsiteDomainDns = Effect.fn("Fly.Website.publishDomainDns")(function* (args: {
+  readonly domain: WebsiteDomain;
+  readonly certificate: Certificate;
+  readonly ip: IpAssignment;
+}) {
+  if (typeof args.domain === "string" || args.domain.dns === undefined) {
+    return;
+  }
+  const dns = yield* DNS.resolve(args.domain.dns);
+  const name = args.domain.name;
+  yield* dns.records("CertificateValidation", {
+    records: Output.map(args.certificate.dnsRequirements, (requirements) =>
+      acmeChallengeRecords(name, requirements),
+    ) as unknown as Input<DNS.DnsRecord[]>,
+  });
+  yield* dns.alias("Domain", {
+    name,
+    target: {
+      ipv4: Output.map(args.ip.ip, (ip) => [ip]) as unknown as Input<string[]>,
+      ipv6: Output.map(
+        args.certificate.dnsRequirements,
+        (requirements) => requirements?.aaaa ?? [],
+      ) as unknown as Input<string[]>,
+    },
+  });
+});
+
 /**
  * Props shared by every Fly framework website composite.
  */
@@ -78,9 +154,15 @@ export interface FrameworkSiteProps {
   dev?: ServerDevProps;
   /**
    * Optional custom hostname. Requests ACME (`Fly.Certificate`) on the
-   * App. `url` becomes `https://<domain>` (existing DNS only for v1).
+   * App and `url` becomes `https://<domain>`.
+   *
+   * A string (or `{ name }`) leaves DNS to you. Set `dns` (e.g.
+   * `{ name: "www.example.com", dns: Cloudflare.DNS.Adapter() }`) to
+   * publish the ACME challenge `CNAME` and the `A` / `AAAA` records
+   * through that DNS host. See
+   * [DNS Adapters](/infrastructure-as-code/dns-adapters).
    */
-  domain?: string;
+  domain?: WebsiteDomain;
   /**
    * User-defined tags. Accepted for API parity; Fly Services do not
    * surface resource tags.
@@ -327,16 +409,20 @@ const runFrameworkSite = Effect.fn("Fly.Website.FrameworkSite")(function* (
         : undefined,
   });
 
+  const domainName = websiteDomainName(props.domain);
   const certificate =
-    props.domain !== undefined
+    domainName !== undefined
       ? yield* Certificate("Certificate", {
           app,
-          hostname: props.domain,
+          hostname: domainName,
           kind: "acme",
         })
       : undefined;
+  if (props.domain !== undefined && certificate !== undefined) {
+    yield* publishWebsiteDomainDns({ domain: props.domain, certificate, ip });
+  }
 
-  const url = props.domain !== undefined ? `https://${props.domain}` : app.url;
+  const url = domainName !== undefined ? `https://${domainName}` : app.url;
 
   return { url, app, service, ip, certificate };
 });

package/src/Website/StaticSite.ts

@@ -15,9 +15,12 @@ import { IpAssignment } from "../IpAssignment.ts";
 import { Service, type ServiceProps } from "../Service.ts";
 import {
   type FrameworkSite,
+  publishWebsiteDomainDns,
   type Ref,
   type WebsiteAssetsProps,
+  type WebsiteDomain,
   staticConfigFromAssets,
+  websiteDomainName,
 } from "./FrameworkSite.ts";
 
 const DEFAULT_PORT = 3000;
@@ -69,9 +72,16 @@ export interface StaticSiteProps {
    */
   app?: Ref<App>;
   /**
-   * Optional custom hostname. Requests ACME (`Fly.Certificate`) on the App.
+   * Optional custom hostname. Requests ACME (`Fly.Certificate`) on the App
+   * and `url` becomes `https://<domain>`.
+   *
+   * A string (or `{ name }`) leaves DNS to you. Set `dns` (e.g.
+   * `{ name: "www.example.com", dns: Cloudflare.DNS.Adapter() }`) to
+   * publish the ACME challenge `CNAME` and the `A` / `AAAA` records
+   * through that DNS host. See
+   * [DNS Adapters](/infrastructure-as-code/dns-adapters).
    */
-  domain?: string;
+  domain?: WebsiteDomain;
   /**
    * User-defined tags. Accepted for API parity; Fly Services do not
    * surface resource tags.
@@ -262,14 +272,24 @@ export const StaticSite = (id: string, props: StaticSiteProps) =>
       ],
     });
 
+    const domainName = websiteDomainName(props.domain);
     const certificate =
-      props.domain !== undefined
-        ? yield* Certificate("Certificate", { app, hostname: props.domain, kind: "acme" }).pipe(
-            Namespace.push(id),
-          )
+      domainName !== undefined
+        ? yield* Certificate("Certificate", {
+            app,
+            hostname: domainName,
+            kind: "acme",
+          }).pipe(Namespace.push(id))
         : undefined;
+    if (props.domain !== undefined && certificate !== undefined) {
+      yield* publishWebsiteDomainDns({
+        domain: props.domain,
+        certificate,
+        ip,
+      }).pipe(Namespace.push(id));
+    }
 
-    const url = props.domain !== undefined ? `https://${props.domain}` : app.url;
+    const url = domainName !== undefined ? `https://${domainName}` : app.url;
 
     return { url, app, service, ip, certificate };
   }).pipe(Effect.orDie);

package/src/Website/Vite.ts

@@ -77,6 +77,15 @@ export interface ViteProps extends FrameworkSiteProps {
  * });
  * ```
  *
+ * **Example:** Publish DNS in Cloudflare
+ * ```typescript
+ * // The ACME challenge CNAME and A/AAAA records are published in the
+ * // Cloudflare zone. Requires Cloudflare.providers() in the stack.
+ * const site = yield* Fly.Website.Vite("Web", {
+ *   domain: { name: "app.example.com", dns: Cloudflare.DNS.Adapter() },
+ * });
+ * ```
+ *
  * ### Build Configuration
  * **Example:** Custom Output Directory and Base Path
  * ```typescript

package/src/WriteCertificatesHttp.ts

@@ -43,7 +43,7 @@ export const certificatesWriteClient = (
       return yield* authorize(
         machines
           .createAppAcmeCertificate({ app_name: yield* appName, hostname })
-          .pipe(Effect.catchTag("Conflict", () => Effect.succeed(undefined))),
+          .pipe(Effect.catchTag("Conflict", () => Effect.undefined)),
       );
     }),
     upload: Effect.fn("Fly.Certificates.upload")(function* (request) {
@@ -78,7 +78,7 @@ export const certificatesWriteClient = (
       return yield* authorize(
         machines
           .getAppCertificate({ app_name: yield* appName, hostname })
-          .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined))),
+          .pipe(Effect.catchTag("NotFound", () => Effect.undefined)),
       );
     }),
     remove: Effect.fn("Fly.Certificates.remove")(function* (hostname) {