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

package/src/Website/SolidStart.ts

@@ -0,0 +1,90 @@
+import { frameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** The framework-integration package that drives the SolidStart build. */
+export const SOLIDSTART_FRAMEWORK_SPECIFIER = "@alchemy.run/frontend-frameworks/solidstart";
+
+/** The Node container deploy target for the SolidStart build. */
+export const SOLIDSTART_NODE_TARGET_SPECIFIER = "@alchemy.run/frontend-frameworks/solidstart/node";
+
+export interface SolidStartProps extends FrameworkSiteProps {
+  /**
+   * Nitro options forwarded into the nitro plugin the integration appends
+   * (prerendering, route rules, storage, ...). `preset` is owned by the
+   * Node deploy target and may not be set here. JSON-serializable values
+   * only — no functions or plugin instances.
+   *
+   * This is a prop (rather than project config) because the integration
+   * owns the nitro plugin instance: a `nitroV2Plugin()` in your project's
+   * `vite.config.*` is rejected, so this prop is the one home for nitro
+   * options — and it accepts values derived from other resources' Outputs,
+   * which a config file cannot.
+   */
+  nitro?: Record<string, unknown>;
+}
+
+/**
+ * Deploy a [SolidStart](https://start.solidjs.com) application to Fly: the
+ * SSR server on a Machine, static assets (prerendered pages included)
+ * baked into the image, served assets-first then the framework handler.
+ *
+ * The build runs through `@alchemy.run/frontend-frameworks/solidstart` with
+ * the `@alchemy.run/frontend-frameworks/solidstart/node` deploy target —
+ * both must be installed in your project, alongside `@solidjs/start` and
+ * `@solidjs/vite-plugin-nitro-2`.
+ *
+ * Your `vite.config.ts` needs no adapter wiring: the integration drives the
+ * project's own `vite build` and appends its own nitro plugin instance
+ * carrying nitro's `node` preset.
+ *
+ *
+ * ### Creating SolidStart Sites
+ * **Example:** Basic SolidStart App
+ * ```typescript
+ * const site = yield* Fly.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* Fly.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ *   domain: "app.example.com",
+ * });
+ * ```
+ *
+ * ### Server Configuration
+ * **Example:** Process Environment
+ * ```typescript
+ * const site = yield* Fly.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ *   env: {
+ *     GREETING: "Hello from SolidStart on Fly!",
+ *   },
+ * });
+ * ```
+ *
+ * ### Prerendering
+ * The integration owns the nitro plugin instance (a `nitroV2Plugin()` in
+ * your `vite.config.*` is rejected), so nitro options — prerendering
+ * included — go on the `nitro` prop. Prerendered pages are baked into the
+ * image and served as static files.
+ *
+ * **Example:** Prerender Routes
+ * ```typescript
+ * const site = yield* Fly.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ *   nitro: { prerender: { routes: ["/", "/about"] } },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const SolidStart = (id: string, props: SolidStartProps = {}) =>
+  frameworkSite(id, props, {
+    name: "SolidStart",
+    framework: SOLIDSTART_FRAMEWORK_SPECIFIER,
+    target: SOLIDSTART_NODE_TARGET_SPECIFIER,
+    options: { nitro: props.nitro },
+  });

package/src/Website/StaticSite.ts

@@ -0,0 +1,275 @@
+import { AlchemyContext } from "alchemy/AlchemyContext";
+import * as Command from "alchemy/Command";
+import type { MemoOptions } from "alchemy/Command/Memo";
+import * as Namespace from "alchemy/Namespace";
+import * as Output from "alchemy/Output";
+import { ProviderModePolicy } from "alchemy/ProviderMode";
+import { initialCwd } from "alchemy/Util/Node";
+import { loadFrontendCore } from "alchemy/Website/FrontendCore";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import type * as Redacted from "effect/Redacted";
+import { App } from "../App.ts";
+import { Certificate } from "../Certificate.ts";
+import { IpAssignment } from "../IpAssignment.ts";
+import { Service, type ServiceProps } from "../Service.ts";
+import {
+  type FrameworkSite,
+  type Ref,
+  type WebsiteAssetsProps,
+  staticConfigFromAssets,
+} from "./FrameworkSite.ts";
+
+const DEFAULT_PORT = 3000;
+
+const resolveRef = <T>(ref: Ref<T>) => (Effect.isEffect(ref) ? ref : Effect.succeed(ref));
+
+export interface StaticSiteProps {
+  /** Deployment strategy forwarded to the hosted Fly Service. */
+  deploy?: ServiceProps["deploy"];
+  /** Process shutdown policy for the generated server. */
+  shutdown?: ServiceProps["shutdown"];
+  /** Named Machine readiness checks. */
+  checks?: ServiceProps["checks"];
+  /** Override proxy services and their routing health checks. */
+  services?: ServiceProps["services"];
+  /**
+   * Path to the local site directory (working directory for
+   * {@link build.command}).
+   * @default "."
+   */
+  path?: string;
+  /**
+   * Build executed before deploy.
+   */
+  build: {
+    /** Shell command that produces the site (e.g. `"hugo --minify"`). */
+    command: string;
+    /** Directory the command writes, relative to {@link path}. */
+    output: string;
+    /** Environment variables for the build command. */
+    env?: Record<string, string | Redacted.Redacted<string>>;
+  };
+  /**
+   * Controls which files are hashed to decide whether the build re-runs.
+   * @default true
+   */
+  memo?: MemoOptions | boolean;
+  /**
+   * Process environment for the hosted static server.
+   */
+  env?: Record<string, string | Redacted.Redacted<string>>;
+  /**
+   * Miss handling for the generated file server.
+   */
+  assets?: WebsiteAssetsProps;
+  /**
+   * Parent Fly App. When omitted, a `Fly.App` is created. The Service
+   * stays in the caller namespace; only `Build` / `Dev` are pushed.
+   */
+  app?: Ref<App>;
+  /**
+   * Optional custom hostname. Requests ACME (`Fly.Certificate`) on the App.
+   */
+  domain?: string;
+  /**
+   * User-defined tags. Accepted for API parity; Fly Services do not
+   * surface resource tags.
+   */
+  tags?: Record<string, string>;
+  /**
+   * Local dev configuration. When `alchemy dev` runs with `dev.command`,
+   * the build is skipped and `command` is spawned as a long-lived child.
+   */
+  dev?: {
+    /**
+     * Shell command to run as the local dev server (e.g. `npm run dev`).
+     */
+    command: string;
+    /**
+     * Working directory for {@link command}. Defaults to {@link cwd}.
+     */
+    cwd?: string;
+    /**
+     * Environment variables for {@link command}.
+     */
+    env?: Record<string, string | Redacted.Redacted<string>>;
+    /**
+     * Override for the `url` output if alchemy fails to detect it from
+     * stdout of the dev command.
+     */
+    url?: string;
+  };
+}
+
+/**
+ * Deploy a static site built by a shell command to Fly.
+ *
+ * `StaticSite` runs a build command (e.g. `npm run build` / `hugo`),
+ * content-hashes the output directory, and deploys a Service that serves
+ * those files (plus `/health`). Use this when the site has its own build
+ * step — Hugo, Zola, Eleventy, or any custom pipeline.
+ *
+ * For Vite-based projects, prefer `Fly.Website.Vite`.
+ *
+ * `Build` / `Dev` use constant logical ids under `Namespace.push(id)`.
+ * The Service stays in the caller namespace (same as
+ * `Cloudflare.Website.StaticSite`).
+ *
+ *
+ * ### Basic Usage
+ * **Example:** Deploying a Hugo site
+ * ```typescript
+ * const site = yield* Fly.Website.StaticSite("Blog", {
+ *   build: { command: "hugo --minify", output: "public" },
+ * });
+ * ```
+ *
+ * **Example:** SPA-style routing
+ * ```typescript
+ * const site = yield* Fly.Website.StaticSite("App", {
+ *   build: { command: "npm run build", output: "dist" },
+ *   assets: { notFoundHandling: "single-page-application" },
+ * });
+ * ```
+ *
+ * ### Building from a Subdirectory
+ * **Example:** Building a frontend in a monorepo
+ * ```typescript
+ * const site = yield* Fly.Website.StaticSite("Web", {
+ *   path: "apps/web",
+ *   build: { command: "npm run build", output: "dist" },
+ * });
+ * ```
+ *
+ * ### Local Development
+ * **Example:** External dev command
+ * ```typescript
+ * const site = yield* Fly.Website.StaticSite("App", {
+ *   build: { command: "npm run build", output: "dist" },
+ *   dev: { command: "npm run dev" },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const StaticSite = (id: string, props: StaticSiteProps) =>
+  Effect.gen(function* () {
+    const ctx = yield* AlchemyContext;
+    const remoted = yield* ProviderModePolicy;
+    const isLocal = ctx.dev && remoted !== true;
+    const path = yield* Path.Path;
+
+    const empty = (): FrameworkSite => ({
+      url: undefined,
+      app: undefined,
+      service: undefined,
+      ip: undefined,
+      certificate: undefined,
+    });
+
+    if (isLocal && props.dev) {
+      const dev = yield* Command.Dev("Dev", {
+        command: props.dev.command,
+        cwd: props.dev.cwd ?? props.path,
+        env: props.dev.env ?? props.env,
+      }).pipe(Namespace.push(id));
+      const url = Output.map(dev.url, (value) => value ?? props.dev?.url);
+      return { ...empty(), url };
+    }
+
+    const build = yield* Command.Build("Build", {
+      command: props.build.command,
+      cwd: props.path,
+      memo: props.memo,
+      outdir: props.build.output,
+      env: props.build.env ?? props.env,
+    }).pipe(Namespace.push(id));
+
+    const cwd = path.resolve(initialCwd, props.path ?? ".");
+    const outdir = path.resolve(cwd, props.build.output);
+    const internal = staticConfigFromAssets(props.assets);
+    const notFoundHandling =
+      internal.errorPage !== undefined
+        ? ("404-page" as const)
+        : internal.spa === true
+          ? ("spa" as const)
+          : ("none" as const);
+
+    const { NODE_SERVE_ENTRY_FILE_NAME, relativeClientDirExpression, writeNodeServeEntry } =
+      yield* loadFrontendCore;
+    const servePath = path.join(path.dirname(outdir), NODE_SERVE_ENTRY_FILE_NAME);
+    const serveOutput = {
+      clientDirectory: outdir,
+      serverModules: [],
+      externalWorkspaces: new Set<string>(),
+    };
+    yield* writeNodeServeEntry({
+      output: serveOutput,
+      servePath,
+      serveModuleName: NODE_SERVE_ENTRY_FILE_NAME,
+      clientDirExpression: relativeClientDirExpression(servePath, outdir),
+      notFoundHandling,
+      printUrl: isLocal,
+      platform: "node",
+    });
+
+    if (isLocal) {
+      const runtime = yield* Effect.sync(() => process.execPath);
+      const dev = yield* Command.Dev("Dev", {
+        command: `${runtime} ${servePath}`,
+        cwd: path.dirname(servePath),
+        env: {
+          ...props.env,
+          PORT: "0",
+          HOST: "127.0.0.1",
+          ALCHEMY_BUILD_HASH: build.hash.output as unknown as string,
+        },
+      }).pipe(Namespace.push(id));
+      return { ...empty(), url: Output.map(dev.url, (value) => value) };
+    }
+
+    const main = servePath;
+
+    const app =
+      props.app !== undefined
+        ? yield* resolveRef(props.app)
+        : yield* App("App").pipe(Namespace.push(id));
+
+    const ip = yield* IpAssignment("Shared", { app, type: "shared_v4" }).pipe(Namespace.push(id));
+
+    // Serve the built tree from the Machine. Fly Tigris `statics` on
+    // `urlPrefix: "/"` do not rewrite HTML routes and hang GET `/`.
+    // Hashed `/assets` still go to Tigris on FrameworkSite.
+    const service = yield* Service(id, {
+      app,
+      deploy: props.deploy,
+      shutdown: props.shutdown,
+      checks: props.checks,
+      services: props.services,
+      main,
+      port: DEFAULT_PORT,
+      // Generated static-file server is a complete bun/node program.
+      isExternal: true,
+      env: props.env,
+      extraFiles: [
+        {
+          // Keep the build dependency so planning cannot hash the previous artifact.
+          source: Output.map(build.outdir, (dir) => path.resolve(initialCwd, dir)),
+          dest: path.basename(outdir),
+        },
+      ],
+    });
+
+    const certificate =
+      props.domain !== undefined
+        ? yield* Certificate("Certificate", { app, hostname: props.domain, kind: "acme" }).pipe(
+            Namespace.push(id),
+          )
+        : undefined;
+
+    const url = props.domain !== undefined ? `https://${props.domain}` : app.url;
+
+    return { url, app, service, ip, certificate };
+  }).pipe(Effect.orDie);

package/src/Website/SvelteKit.ts

@@ -0,0 +1,49 @@
+import { frameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** The framework-integration package that drives the SvelteKit build. */
+export const SVELTEKIT_FRAMEWORK_SPECIFIER = "@alchemy.run/frontend-frameworks/sveltekit";
+
+/** The Node container deploy target for the SvelteKit build. */
+export const SVELTEKIT_NODE_TARGET_SPECIFIER = "@alchemy.run/frontend-frameworks/sveltekit/node";
+
+export interface SvelteKitProps extends FrameworkSiteProps {
+  /**
+   * SvelteKit configuration passed to the `sveltekit(config)` Vite plugin.
+   * The `adapter` field is injected by the Node deploy target and may not
+   * be set here. Must be JSON-serializable.
+   */
+  kit?: Record<string, unknown>;
+}
+
+/**
+ * Deploy a SvelteKit application to Fly: kit's SSR server on a Machine,
+ * static assets baked into the image, served assets-first then the
+ * framework handler.
+ *
+ *
+ * ### Creating SvelteKit Sites
+ * **Example:** Basic SvelteKit App
+ * ```typescript
+ * const site = yield* Fly.Website.SvelteKit("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* Fly.Website.SvelteKit("Web", {
+ *   rootDir: "./app",
+ *   domain: "app.example.com",
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const SvelteKit = (id: string, props: SvelteKitProps = {}) =>
+  frameworkSite(id, props, {
+    name: "SvelteKit",
+    framework: SVELTEKIT_FRAMEWORK_SPECIFIER,
+    target: SVELTEKIT_NODE_TARGET_SPECIFIER,
+    options: props.kit ? { kit: props.kit } : undefined,
+  });

package/src/Website/TanStackStart.ts

@@ -0,0 +1,72 @@
+import { frameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** The framework-integration package that drives the TanStack Start build. */
+export const TANSTACK_START_FRAMEWORK_SPECIFIER = "@alchemy.run/frontend-frameworks/tanstack-start";
+
+/** The Node container deploy target for the TanStack Start build. */
+export const TANSTACK_START_NODE_TARGET_SPECIFIER =
+  "@alchemy.run/frontend-frameworks/tanstack-start/node";
+
+export interface TanStackStartProps extends FrameworkSiteProps {}
+
+/**
+ * Deploy a [TanStack Start](https://tanstack.com/start) application to Fly:
+ * the SSR server on a Machine, client assets baked into the image, served
+ * assets-first then the framework handler.
+ *
+ * The build runs through
+ * `@alchemy.run/frontend-frameworks/tanstack-start` with the
+ * `@alchemy.run/frontend-frameworks/tanstack-start/node` deploy target —
+ * both must be installed in your project, alongside
+ * `@tanstack/react-start` (or `@tanstack/solid-start`) and `vite`.
+ *
+ * Your `vite.config.ts` needs no adapter wiring: TanStack Start is pure
+ * Vite, so the integration drives the project's own `vite build`, forces
+ * the SSR bundle to be self-contained, and wraps its fetch handler as a
+ * Node HTTP server on port 3000.
+ *
+ *
+ * ### Creating TanStack Start Sites
+ * **Example:** Basic TanStack Start App
+ * ```typescript
+ * const site = yield* Fly.Website.TanStackStart("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* Fly.Website.TanStackStart("Web", {
+ *   rootDir: "./app",
+ *   domain: "app.example.com",
+ * });
+ * ```
+ *
+ * ### Server Configuration
+ * **Example:** Process Environment
+ * ```typescript
+ * const site = yield* Fly.Website.TanStackStart("Web", {
+ *   rootDir: "./app",
+ *   env: {
+ *     GREETING: "Hello from TanStack Start on Fly!",
+ *   },
+ * });
+ * ```
+ *
+ * **Example:** Read An Environment Variable From A Server Function
+ * ```typescript
+ * // src/routes/index.tsx
+ * const getGreeting = createServerFn({ method: "GET" }).handler(
+ *   () => process.env.GREETING ?? "Hello!",
+ * );
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const TanStackStart = (id: string, props: TanStackStartProps = {}) =>
+  frameworkSite(id, props, {
+    name: "TanStackStart",
+    framework: TANSTACK_START_FRAMEWORK_SPECIFIER,
+    target: TANSTACK_START_NODE_TARGET_SPECIFIER,
+  });

package/src/Website/Vinext.ts

@@ -0,0 +1,79 @@
+import * as Namespace from "alchemy/Namespace";
+import * as Effect from "effect/Effect";
+import type { Redis } from "../Redis.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/**
+ * The vinext-on-Node framework module (vinext's Vite build +
+ * `startProdServer`). Not the Cloudflare Worker source.
+ */
+export const VINEXT_NODE_FRAMEWORK_SPECIFIER = "@alchemy.run/frontend-frameworks/vinext/node";
+
+export interface VinextProps extends FrameworkSiteProps {
+  /**
+   * Optional Upstash Redis for ISR / `"use cache"`. Bound onto the
+   * hosted Service so Alchemy writes `REDIS_URL` as an App secret.
+   * The resource injects the Redis data-cache adapter automatically.
+   */
+  redis?: Redis;
+}
+
+/**
+ * Deploy a [vinext](https://vinext.dev) application to Fly as a
+ * long-running Node process: vinext's Vite build, then vinext's production
+ * server (`startProdServer`). The `dist/` output is baked into the
+ * image; `vinext` is installed unbundled.
+ *
+ * Do not use the Cloudflare Worker entry (`vinext/server/fetch-handler`)
+ * — that is workerd.
+ *
+ * ISR / `"use cache"` persist in Redis when you pass {@link VinextProps.redis}.
+ * The resource injects the adapter automatically. Missing `REDIS_URL`
+ * (local `vinext start` / `alchemy dev`) falls back to memory.
+ *
+ * During `alchemy dev` the site is `vinext dev` and no cloud resources
+ * are declared; `Alchemy.remote()` opts back into the live Service path.
+ *
+ * ### Creating vinext Sites
+ * **Example:** Basic vinext App
+ * ```typescript
+ * const site = yield* Fly.Website.Vinext("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Redis data cache
+ * ```typescript
+ * const redis = yield* Fly.Redis("Cache", { eviction: true });
+ * const site = yield* Fly.Website.Vinext("Web", {
+ *   redis,
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* Fly.Website.Vinext("Web", {
+ *   rootDir: "./app",
+ *   domain: "app.example.com",
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const Vinext = (id: string, propsIn: VinextProps = {}) =>
+  Effect.gen(function* () {
+    const { redis, ...props } = propsIn;
+    const site = yield* makeFrameworkSite(id, props, {
+      name: "Vinext",
+      framework: VINEXT_NODE_FRAMEWORK_SPECIFIER,
+      target: VINEXT_NODE_FRAMEWORK_SPECIFIER,
+      install: ["vinext", "react", "react-dom", "react-server-dom-webpack"],
+    });
+    if (redis !== undefined && site.service !== undefined) {
+      yield* site.service.bind`${redis}`({
+        redis: { name: redis.name, id: redis.redisId },
+      });
+    }
+    return site;
+  }).pipe(Namespace.push(id));

package/src/Website/Vite.ts

@@ -0,0 +1,112 @@
+import { frameworkSite, staticConfigFromAssets, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** The framework-integration package that drives the Vite build. */
+export const VITE_FRAMEWORK_SPECIFIER = "@alchemy.run/frontend-frameworks/vite";
+
+/** The Node container deploy target for the Vite build. */
+export const VITE_NODE_TARGET_SPECIFIER = "@alchemy.run/frontend-frameworks/vite/node";
+
+const viteOptions = (props: ViteProps) =>
+  props.vite !== undefined && (props.vite.outDir !== undefined || props.vite.base !== undefined)
+    ? { vite: props.vite }
+    : undefined;
+
+export interface ViteProps extends FrameworkSiteProps {
+  /**
+   * Serializable Vite config merged OVER the project's own `vite.config.*`
+   * (which loads natively, plugins included).
+   */
+  vite?: {
+    /**
+     * Build output directory, relative to `rootDir`.
+     * @default the project config's `build.outDir` (vite's default: "dist")
+     */
+    outDir?: string;
+    /** Public base path the site deploys under (vite's `base`). */
+    base?: string;
+  };
+}
+
+/**
+ * Deploy a plain [Vite](https://vite.dev) application to Fly: a Service
+ * serving the `vite build` output from a tiny static-file server. For
+ * client-only projects — React/Vue/Solid SPAs, `index.html` multi-page
+ * apps — whose entire deployable output is static assets.
+ *
+ * The build runs through `@alchemy.run/frontend-frameworks/vite` with the
+ * `@alchemy.run/frontend-frameworks/vite/node` deploy target — the package
+ * must be installed in your project. Your project's own `vite.config.*`
+ * (plugins included) drives the build.
+ *
+ * During `alchemy dev` the site is Vite's own dev server (native HMR) and
+ * no cloud resources are created — the site's `url` is the dev server's
+ * local address. `Alchemy.remote()` opts back into the full deployment.
+ *
+ *
+ * ### Creating Vite Sites
+ * **Example:** Basic Vite SPA
+ * ```typescript
+ * const site = yield* Fly.Website.Vite("Web");
+ * ```
+ *
+ * **Example:** Project in a Subdirectory
+ * ```typescript
+ * const site = yield* Fly.Website.Vite("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Existing App
+ * ```typescript
+ * const site = yield* Fly.Website.Vite("Web", { app: Site });
+ * ```
+ *
+ * ### Multi-Page Sites
+ * **Example:** Per-Route HTML Pages with a 404 Page
+ * ```typescript
+ * const site = yield* Fly.Website.Vite("Docs", {
+ *   assets: { notFoundHandling: "404-page" },
+ * });
+ * ```
+ *
+ * ### Custom Domain
+ * **Example:** ACME on an existing hostname
+ * ```typescript
+ * const site = yield* Fly.Website.Vite("Web", {
+ *   domain: "app.example.com",
+ * });
+ * ```
+ *
+ * ### Build Configuration
+ * **Example:** Custom Output Directory and Base Path
+ * ```typescript
+ * const site = yield* Fly.Website.Vite("Docs", {
+ *   vite: { outDir: "build", base: "/docs/" },
+ * });
+ * ```
+ *
+ * ### Local Development
+ * **Example:** Vite Dev Server Under `alchemy dev`
+ * ```typescript
+ * // `alchemy dev` starts `vite` programmatically: site.url is the local
+ * // dev server (HMR included); no Fly App or Service is created.
+ * const site = yield* Fly.Website.Vite("Web");
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const Vite = (id: string, props: ViteProps = {}) =>
+  frameworkSite(id, props, {
+    name: "Vite",
+    framework: VITE_FRAMEWORK_SPECIFIER,
+    target: VITE_NODE_TARGET_SPECIFIER,
+    options: {
+      ...viteOptions(props),
+      notFoundHandling: "spa",
+      htmlHandling: props.assets?.htmlHandling,
+    },
+    static: staticConfigFromAssets(props.assets, {
+      notFoundHandling: "single-page-application",
+    }),
+  });