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

package/src/VolumeSnapshot.ts

@@ -0,0 +1,321 @@
+import type { VolumeSnapshot as FlyVolumeSnapshot } from "@distilled.cloud/fly-io/machines";
+import * as machines from "@distilled.cloud/fly-io/machines";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import type { App } from "./App.ts";
+import type { Providers } from "./Providers.ts";
+import { listOwnedVolumes } from "./Volume.ts";
+
+/**
+ * A resource-valued prop: the resource itself, or an Effect that produces
+ * it (so `yield* App(...)` and `App(...)` both type-check).
+ */
+type Ref<T> = T | Effect.Effect<T, never, Providers>;
+
+export interface VolumeSnapshotProps {
+  /**
+   * Parent Fly App. Changing it replaces the snapshot (a new snapshot is
+   * created on the new App's Volume). There is no delete API for the old
+   * snapshot — it follows Volume `snapshot_retention`.
+   */
+  app: Ref<App>;
+  /**
+   * Fly Volume id to snapshot (`vol_…`). Changing it replaces the
+   * snapshot. Identity is the snapshot `id` returned by a subsequent
+   * `listVolumeSnapshots`.
+   */
+  volumeId: string;
+}
+
+export type VolumeSnapshot = Resource<
+  "Fly.VolumeSnapshot",
+  VolumeSnapshotProps,
+  {
+    /** Parent Fly App name. */
+    appName: string;
+    /** Fly Volume id this snapshot belongs to. */
+    volumeId: string;
+    /** Fly snapshot id (`vs_…`). Identity of the resource. */
+    snapshotId: string;
+    /** Observed snapshot status, if the API returned one. */
+    status: string | undefined;
+    /** Content digest of the snapshot. */
+    digest: string | undefined;
+    /** Snapshot size in bytes, if the API returned one. */
+    size: number | undefined;
+    /** Source volume size in GB at snapshot time. */
+    volumeSize: number | undefined;
+    /** Retention in days. */
+    retentionDays: number | undefined;
+    /** RFC3339 creation timestamp. */
+    createdAt: string | undefined;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * A Fly.VolumeSnapshot is an on-demand snapshot of a mounted disk.
+ *
+ * Create is fire-and-forget. Identity is the snapshot id from a
+ * subsequent list. Destroy is a no-op. Snapshots follow Volume
+ * retention. `nuke` skips this type.
+ *
+ * @see https://fly.io/docs/machines/api/volumes-resource/
+ *
+ * ### Create a snapshot
+ * Point it at a Volume id from the parent {@link Machine} or
+ * {@link Service} (`mounts[0].volumeId`).
+ *
+ * **Example:** Snapshot a mounted disk
+ * ```typescript
+ * const box = yield* Fly.Machine("Box", {
+ *   app: Site,
+ *   region: "iad",
+ *   image: "nginx:alpine",
+ *   mounts: [{ path: "/data", sizeGb: 1 }],
+ * });
+ *
+ * export const Nightly = Fly.VolumeSnapshot("Nightly", {
+ *   app: Site,
+ *   volumeId: box.mounts[0].volumeId,
+ * });
+ * ```
+ *
+ * :::caution[Changing `app` or `volumeId` replaces the snapshot]
+ * A new snapshot is created. There is no delete API for the old one.
+ * It follows Volume `snapshot_retention`.
+ * :::
+ *
+ * ### Restore
+ * Restore into a new disk with `snapshotId` on the mount. Create-only.
+ * The new Machine gets a copy. The original Volume is unchanged.
+ *
+ * **Example:** Restore onto a Machine
+ * ```typescript
+ * const restored = yield* Fly.Machine("Restored", {
+ *   app: Site,
+ *   region: "iad",
+ *   image: "nginx:alpine",
+ *   mounts: [{ path: "/data", sizeGb: 1, snapshotId: Nightly.snapshotId }],
+ * });
+ * ```
+ *
+ * ### Restore into a Service
+ * Pass `snapshotId` on {@link MountVolume}. Same create-only rule.
+ *
+ * **Example:** Restore onto a Service
+ * ```typescript
+ * export default class Api extends Fly.Service<Api>()(
+ *   "Api",
+ *   { app: Site, main: import.meta.url, region: "iad", port: 3000 },
+ *   Effect.gen(function* () {
+ *     const disk = yield* Fly.MountVolume({
+ *       path: "/data",
+ *       sizeGb: 1,
+ *       snapshotId: Nightly.snapshotId,
+ *     });
+ *     return {
+ *       fetch: Effect.succeed(HttpServerResponse.text(disk.path)),
+ *     };
+ *   }).pipe(Effect.provide(Fly.MountVolumeLive)),
+ * ) {}
+ * ```
+ *
+ * @resource
+ * @product Volume
+ */
+export const VolumeSnapshot = Resource<VolumeSnapshot>("Fly.VolumeSnapshot");
+
+export class VolumeSnapshotNotCreated extends Data.TaggedError("Fly.VolumeSnapshotNotCreated")<{
+  appName: string;
+  volumeId: string;
+}> {}
+
+export class VolumeSnapshotRefsMissing extends Data.TaggedError("Fly.VolumeSnapshotRefsMissing")<{
+  message: string;
+}> {}
+
+class VolumeSnapshotPending extends Data.TaggedError("Fly.VolumeSnapshotPending")<{
+  volumeId: string;
+}> {}
+
+const backoff = Schedule.min([
+  Schedule.exponential(Duration.millis(500), 1.5),
+  Schedule.spaced(Duration.seconds(5)),
+]);
+
+const appNameOf = (value: unknown): string | undefined => {
+  if (value == null || typeof value !== "object") return undefined;
+  const name = (value as { appName?: unknown }).appName;
+  return typeof name === "string" && name.length > 0 ? name : undefined;
+};
+
+const volumeIdOf = (value: unknown): string | undefined => {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (value == null || typeof value !== "object") return undefined;
+  const id = (value as { volumeId?: unknown }).volumeId;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+};
+
+const toAttrs = (
+  appName: string,
+  volumeId: string,
+  snapshot: FlyVolumeSnapshot,
+): VolumeSnapshot["Attributes"] => ({
+  appName,
+  volumeId,
+  snapshotId: snapshot.id ?? "",
+  status: snapshot.status,
+  digest: snapshot.digest,
+  size: snapshot.size,
+  volumeSize: snapshot.volume_size,
+  retentionDays: snapshot.retention_days,
+  createdAt: snapshot.created_at,
+});
+
+const listSnapshots = (appName: string, volumeId: string) =>
+  machines
+    .listVolumeSnapshots({
+      app_name: appName,
+      volume_id: volumeId,
+    })
+    .pipe(
+      Effect.catchTag(["NotFound", "Forbidden"], () => Effect.succeed([] as FlyVolumeSnapshot[])),
+    );
+
+const findById = (appName: string, volumeId: string, snapshotId: string) =>
+  listSnapshots(appName, volumeId).pipe(
+    Effect.map((snapshots) => snapshots.find((snapshot) => snapshot.id === snapshotId)),
+  );
+
+const newestFirst = (left: FlyVolumeSnapshot, right: FlyVolumeSnapshot) =>
+  Date.parse(right.created_at ?? "") - Date.parse(left.created_at ?? "");
+
+const pickNewest = (snapshots: FlyVolumeSnapshot[]): FlyVolumeSnapshot | undefined =>
+  snapshots.filter((snapshot) => (snapshot.id ?? "").length > 0).sort(newestFirst)[0];
+
+const waitForNewSnapshot = (appName: string, volumeId: string, knownIds: ReadonlySet<string>) =>
+  listSnapshots(appName, volumeId).pipe(
+    Effect.flatMap((snapshots) => {
+      const next = pickNewest(
+        snapshots.filter((snapshot) => snapshot.id !== undefined && !knownIds.has(snapshot.id)),
+      );
+      if (next !== undefined) return Effect.succeed(next);
+      return Effect.fail(new VolumeSnapshotPending({ volumeId }));
+    }),
+    Effect.retry({
+      while: (e) => e._tag === "Fly.VolumeSnapshotPending",
+      times: 8,
+      schedule: backoff,
+    }),
+    Effect.catchTag("Fly.VolumeSnapshotPending", () => Effect.undefined),
+  );
+
+export const VolumeSnapshotProvider = () =>
+  Provider.succeed(VolumeSnapshot, {
+    stables: ["snapshotId", "volumeId", "appName"],
+    nuke: { skip: true },
+
+    diff: Effect.fn(function* ({ news, output }) {
+      if (news === undefined || !isResolved(news)) return undefined;
+      if (output === undefined) return undefined;
+      const desiredApp = appNameOf(news.app);
+      const appChanged = desiredApp !== undefined && desiredApp !== output.appName;
+      const desiredVolume = volumeIdOf(news.volumeId);
+      const volumeChanged = desiredVolume !== undefined && desiredVolume !== output.volumeId;
+      if (appChanged || volumeChanged) {
+        return { action: "replace" as const };
+      }
+      return undefined;
+    }),
+
+    read: Effect.fn(function* ({ olds, output }) {
+      const appName = output?.appName ?? appNameOf(olds?.app);
+      const volumeId = output?.volumeId ?? volumeIdOf(olds?.volumeId);
+      if (appName === undefined || volumeId === undefined) return undefined;
+      const snapshotId = output?.snapshotId;
+      if (snapshotId === undefined || snapshotId.length === 0) {
+        return undefined;
+      }
+      const found = yield* findById(appName, volumeId, snapshotId);
+      if (found === undefined) return undefined;
+      return toAttrs(appName, volumeId, found);
+    }),
+
+    list: Effect.fn(function* () {
+      const volumes = yield* listOwnedVolumes();
+      const groups = yield* Effect.forEach(
+        volumes,
+        ({ appName, volumeId }) =>
+          listSnapshots(appName, volumeId).pipe(
+            Effect.map((snapshots) =>
+              snapshots
+                .filter((snapshot) => snapshot.id !== undefined && snapshot.id.length > 0)
+                .map((snapshot) => toAttrs(appName, volumeId, snapshot)),
+            ),
+          ),
+        { concurrency: 8 },
+      );
+      return groups.flat();
+    }),
+
+    reconcile: Effect.fn(function* ({ news, output }) {
+      const props = news ?? ({} as VolumeSnapshotProps);
+      const appName = appNameOf(props.app) ?? output?.appName;
+      const volumeId = volumeIdOf(props.volumeId) ?? output?.volumeId;
+      if (appName === undefined || volumeId === undefined) {
+        return yield* new VolumeSnapshotRefsMissing({
+          message: "Fly.VolumeSnapshot requires a resolved App with appName and a volumeId.",
+        });
+      }
+
+      // Observe by cached snapshot id on the target volume.
+      const observed = yield* listSnapshots(appName, volumeId);
+      let current =
+        output?.snapshotId !== undefined && output.snapshotId.length > 0
+          ? observed.find((snapshot) => snapshot.id === output.snapshotId)
+          : undefined;
+
+      if (current === undefined) {
+        const knownIds = new Set(
+          observed.flatMap((snapshot) =>
+            snapshot.id !== undefined && snapshot.id.length > 0 ? [snapshot.id] : [],
+          ),
+        );
+        yield* machines
+          .createVolumeSnapshot({
+            app_name: appName,
+            volume_id: volumeId,
+          })
+          .pipe(
+            Effect.asVoid,
+            Effect.catchTag("Conflict", () => Effect.void),
+            Effect.retry({
+              while: (e) =>
+                e._tag === "NotFound" ||
+                (e._tag === "BadRequest" && e.message.includes("uninitialized volume")),
+              times: 8,
+              schedule: backoff,
+            }),
+          );
+        current = yield* waitForNewSnapshot(appName, volumeId, knownIds);
+      }
+
+      if (current === undefined || current.id === undefined) {
+        return yield* new VolumeSnapshotNotCreated({ appName, volumeId });
+      }
+
+      return toAttrs(appName, volumeId, current);
+    }),
+
+    delete: Effect.fn(function* () {
+      // Fly has no snapshot delete API. Snapshots expire with Volume
+      // snapshot_retention or when the Volume is deleted.
+    }),
+  });

package/src/Website/AssetDeployment.ts

@@ -0,0 +1,292 @@
+import { createHash } from "node:crypto";
+import { Credentials, fromCredentials } from "@distilled.cloud/aws/Credentials";
+import * as AwsEndpoint from "@distilled.cloud/aws/Endpoint";
+import type { RegionName } from "@distilled.cloud/aws/Region";
+import * as s3 from "@distilled.cloud/aws/s3";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import { initialCwd } from "alchemy/Util/Node";
+import { cacheControlOf, contentTypeOf } from "alchemy/Website/assets";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import type * as HttpClient from "effect/http/HttpClient";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Redacted from "effect/Redacted";
+import * as Stream from "effect/Stream";
+import type { Bucket } from "../Bucket.ts";
+import { TigrisCredentialsMissing } from "../Errors.ts";
+import type { Providers } from "../Providers.ts";
+
+const s3Concurrency = 16;
+
+/**
+ * Unwrap Tigris {@link Bucket} attrs for the S3 client. Credentials and
+ * the endpoint are `Redacted<string>`; names are plain strings. This is
+ * Fly Bucket plumbing, not website MIME — it stays here because this
+ * resource is the only Website helper that speaks Tigris.
+ */
+const asPlain = (value: unknown): string | undefined => {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (Redacted.isRedacted(value)) {
+    const inner = Redacted.value(value);
+    return typeof inner === "string" && inner.length > 0 ? inner : undefined;
+  }
+  return undefined;
+};
+
+export interface AssetDeploymentProps {
+  /**
+   * Destination Tigris bucket (a {@link Bucket} resource).
+   */
+  bucket: Bucket;
+  /**
+   * Local directory to upload (framework `clientDirectory`).
+   */
+  sourcePath: string;
+  /**
+   * Optional key prefix within the bucket.
+   */
+  prefix?: string;
+  /**
+   * Delete observed keys under the prefix that are not in this deploy.
+   * @default true
+   */
+  purge?: boolean;
+}
+
+export interface AssetDeployment extends Resource<
+  "Fly.Website.AssetDeployment",
+  AssetDeploymentProps,
+  {
+    bucketName: string;
+    prefix: string;
+    version: string;
+    fileCount: number;
+    files: string[];
+  },
+  never,
+  Providers
+> {}
+
+/**
+ * Upload a local directory into a public Tigris bucket for Fly Website
+ * statics. HTML is never cached; everything else is immutable.
+ *
+ * @resource
+ */
+export const AssetDeployment = Resource<AssetDeployment>("Fly.Website.AssetDeployment");
+
+const normalizePrefix = (prefix: string | undefined) =>
+  prefix ? prefix.replace(/^\/+|\/+$/g, "") : "";
+
+const scopeOf = (bucket: Bucket) =>
+  Effect.gen(function* () {
+    const bucketName = asPlain(bucket.bucketName) ?? asPlain(bucket.name);
+    const accessKeyId = asPlain(bucket.accessKeyId);
+    const secretAccessKey = asPlain(bucket.secretAccessKey);
+    const endpoint = asPlain(bucket.endpoint);
+    const region = (asPlain(bucket.region) ?? "auto") as RegionName;
+    if (
+      bucketName === undefined ||
+      accessKeyId === undefined ||
+      secretAccessKey === undefined ||
+      endpoint === undefined
+    ) {
+      return yield* new TigrisCredentialsMissing({
+        resourceName: bucketName ?? bucket.LogicalId,
+      });
+    }
+    return { bucketName, accessKeyId, secretAccessKey, endpoint, region };
+  });
+
+const withTigris = <A, E>(
+  scope: {
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint: string;
+    region: RegionName;
+  },
+  operation: Effect.Effect<A, E, Credentials | HttpClient.HttpClient>,
+) =>
+  operation.pipe(
+    Effect.provide(
+      Layer.mergeAll(
+        fromCredentials(
+          {
+            accessKeyId: Redacted.make(scope.accessKeyId),
+            secretAccessKey: Redacted.make(scope.secretAccessKey),
+          },
+          scope.region,
+        ),
+        AwsEndpoint.of(scope.endpoint),
+        FetchHttpClient.layer,
+      ),
+    ),
+  );
+
+const walkFiles = Effect.fn(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  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.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
+    .filter((name): name is string => name !== undefined)
+    .sort((a, b) => a.localeCompare(b));
+});
+
+const listObserved = (
+  scope: {
+    bucketName: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint: string;
+    region: RegionName;
+  },
+  prefix: string,
+) =>
+  withTigris(
+    scope,
+    s3.listObjectsV2
+      .pages({
+        Bucket: scope.bucketName,
+        Prefix: prefix.length > 0 ? `${prefix}/` : undefined,
+      })
+      .pipe(
+        Stream.flatMap((page) => Stream.fromIterable(page.Contents ?? [])),
+        Stream.runFold(
+          () => new Map<string, string | undefined>(),
+          (observed, object) => {
+            if (object.Key !== undefined) {
+              observed.set(object.Key, object.ETag);
+            }
+            return observed;
+          },
+        ),
+      ),
+  );
+
+const deleteObject = (
+  scope: {
+    bucketName: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint: string;
+    region: RegionName;
+  },
+  key: string,
+) =>
+  withTigris(
+    scope,
+    s3.deleteObject({
+      Bucket: scope.bucketName,
+      Key: key,
+    }),
+  ).pipe(Effect.catchTag("NoSuchKey", () => Effect.void));
+
+export const AssetDeploymentProvider = () =>
+  Provider.effect(
+    AssetDeployment,
+    Effect.succeed({
+      list: () => Effect.succeed([]),
+      read: Effect.fn(function* ({ output }) {
+        return output;
+      }),
+      reconcile: Effect.fn(function* ({ news, session }) {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const scope = yield* scopeOf(news.bucket);
+        const prefix = normalizePrefix(news.prefix);
+        const root = path.isAbsolute(news.sourcePath)
+          ? news.sourcePath
+          : path.resolve(initialCwd, news.sourcePath);
+        const files = yield* walkFiles(root);
+        const observed = yield* listObserved(scope, prefix);
+        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;
+              const contentType = contentTypeOf(relative);
+              const cacheControl = cacheControlOf(relative);
+              return { relative, key, body, contentType, cacheControl };
+            }),
+          { concurrency: "unbounded" },
+        );
+        const version = yield* Effect.sync(() => {
+          const hash = createHash("sha256");
+          for (const file of prepared) {
+            hash.update(file.relative);
+            hash.update(file.body);
+            hash.update(file.contentType);
+            hash.update(file.cacheControl);
+          }
+          return hash.digest("hex");
+        });
+        const desired = new Set(prepared.map((file) => file.key));
+        yield* Effect.all(
+          prepared.flatMap((file) => {
+            const expected = createHash("md5").update(file.body).digest("hex");
+            const etag = observed.get(file.key)?.replace(/^"|"$/g, "");
+            if (etag === expected) return [];
+            return [
+              withTigris(
+                scope,
+                s3.putObject({
+                  Bucket: scope.bucketName,
+                  Key: file.key,
+                  Body: file.body,
+                  ContentType: file.contentType,
+                  CacheControl: file.cacheControl,
+                }),
+              ),
+            ];
+          }),
+          { concurrency: s3Concurrency },
+        );
+
+        if (news.purge ?? true) {
+          yield* Effect.forEach(
+            [...observed.keys()].filter((key) => !desired.has(key)),
+            (key) => deleteObject(scope, key),
+            { concurrency: s3Concurrency },
+          );
+        }
+
+        const output = {
+          bucketName: scope.bucketName,
+          prefix,
+          version,
+          fileCount: files.length,
+          files: prepared.map((file) => file.relative),
+        };
+        yield* session.note(
+          `Uploaded ${output.fileCount} file(s) to tigris://${output.bucketName}/${output.prefix}`,
+        );
+        return output;
+      }),
+      delete: Effect.fn(
+        function* ({ olds, output }) {
+          if (!(olds.purge ?? true)) return;
+          const scope = yield* scopeOf(olds.bucket);
+          const observed = yield* listObserved(scope, output.prefix);
+          yield* Effect.forEach([...observed.keys()], (key) => deleteObject(scope, key), {
+            concurrency: s3Concurrency,
+          });
+        },
+        Effect.catchTag("NoSuchBucket", () => Effect.void),
+      ),
+    }),
+  );

package/src/Website/Astro.ts

@@ -0,0 +1,92 @@
+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. */
+export const ASTRO_FRAMEWORK_SPECIFIER = "@alchemy.run/frontend-frameworks/astro";
+
+/** The Node container deploy target for the Astro build. */
+export const ASTRO_NODE_TARGET_SPECIFIER = "@alchemy.run/frontend-frameworks/astro/node";
+
+export interface AstroProps extends FrameworkSiteProps {
+  /**
+   * Serializable Astro config merged OVER the project's own
+   * `astro.config.*` (which loads natively). `adapter` is owned by the Node
+   * deploy target and may not be set here.
+   */
+  astro?: {
+    /** The full URL the site deploys to (`Astro.site`). */
+    site?: string;
+    /** Base path the site deploys under. */
+    base?: string;
+    /**
+     * 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). 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" */
+    srcDir?: string;
+    /** Public (static passthrough) directory. @default "./public" */
+    publicDir?: string;
+    /** Build output directory. @default "./dist" */
+    outDir?: string;
+    /** Trailing-slash handling for routes. */
+    trailingSlash?: "always" | "never" | "ignore";
+  };
+}
+
+/**
+ * Deploy an [Astro](https://astro.build) application to Fly: a Service
+ * 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"`). 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
+ * **Example:** Basic Astro App
+ * ```typescript
+ * const site = yield* Fly.Website.Astro("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* Fly.Website.Astro("Web", {
+ *   rootDir: "./app",
+ *   domain: "app.example.com",
+ * });
+ * ```
+ *
+ * ### Static Sites
+ * **Example:** Fully Static Astro Site
+ * ```typescript
+ * const site = yield* Fly.Website.Astro("Docs", {
+ *   rootDir: "./docs",
+ *   astro: { output: "static" },
+ *   assets: { notFoundHandling: "404-page" },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+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,
+      }),
+    ),
+  );