alchemy 2.0.0-beta.77 → 2.0.0-beta.79

package/src/Prisma/Website/FrameworkSite.ts

@@ -0,0 +1,204 @@
+import * as Effect from "effect/Effect";
+import * as Output from "../../Output.ts";
+import * as Redacted from "effect/Redacted";
+import { AlchemyContext } from "../../AlchemyContext.ts";
+import type { MemoOptions } from "../../Command/Memo.ts";
+import { ProviderModePolicy } from "../../ProviderMode.ts";
+import type { WebsiteAssetsProps } from "../../Website/assets.ts";
+import { Server, type ServerDevProps } from "../../Website/Server.ts";
+import { Compute, type ComputeProps } from "../Compute.ts";
+import { CustomDomain } from "../CustomDomain.ts";
+import { Project } from "../Project.ts";
+import type { Providers } from "../Providers.ts";
+import type { PrismaRegionId } from "../Types.ts";
+import { WebsiteArtifact } from "./Artifact.ts";
+
+/** A Prisma Project resource, ID, or lightweight ID reference. */
+export type WebsiteProjectReference =
+  | Project
+  | string
+  | {
+      /** Existing Prisma project ID; no project is created or owned by the site. */
+      readonly projectId: string | Output.Output<string>;
+    };
+
+/** Deployment controls that do not replace the framework build or artifact. */
+export type WebsiteComputeOptions = Pick<
+  ComputeProps,
+  | "appName"
+  | "port"
+  | "envClass"
+  | "start"
+  | "skipPromote"
+  | "destroyOldDeployment"
+  | "timeoutSeconds"
+  | "pollIntervalMs"
+  | "verifyUrl"
+  | "healthCheck"
+  | "urlReadinessTimeoutSeconds"
+>;
+
+/** Shared contract for Prisma's framework website composites. */
+export interface FrameworkSiteProps {
+  /** Existing Project or ID reference, optionally produced by an Effect. Omission creates a project without a database, only on live deployments. */
+  project?:
+    | WebsiteProjectReference
+    | Effect.Effect<WebsiteProjectReference, never, Providers>;
+  /** Application directory containing package.json and framework configuration. @default "." */
+  rootDir?: string;
+  /** Build input hashing options. Set false to rebuild on every deployment. @default true */
+  memo?: MemoOptions | boolean;
+  /** Build, development, and runtime environment. Wrap secrets in Redacted; public framework variables can be compiled into browser assets. */
+  env?: Record<
+    string,
+    string | Redacted.Redacted<string> | Output.Output<string | undefined>
+  >;
+  /** Origin static-file routing, using the same vocabulary as Fly and Railway websites. */
+  assets?: WebsiteAssetsProps;
+  /** Native framework development server options, including external-server mode. */
+  dev?: ServerDevProps;
+  /** Custom hostname attached using Prisma.CustomDomain. Only apps on the default branch support custom domains; configure the returned DNS records before routing traffic. */
+  domain?: string;
+  /** Compute region. Defaults to the project's default region, then us-east-1. */
+  regionId?: PrismaRegionId;
+  /** Existing branch ID. Mutually exclusive with branchGitName. */
+  branchId?: string;
+  /** Existing branch git name. Defaults to the project's default branch. */
+  branchGitName?: string;
+  /** Compute deployment, readiness, and rollout options. The website owns its build, artifact, and runtime environment. */
+  compute?: WebsiteComputeOptions;
+  /** Accepted for website API parity; Prisma Compute does not persist resource tags. */
+  tags?: Record<string, string>;
+}
+
+/** Outputs of a Prisma framework or static website. */
+export interface Website {
+  /** Native dev-server URL locally; Compute URL or configured custom-domain URL on live deployments. */
+  url: string | Output.Output<string | undefined> | undefined;
+  /** Compute app serving the artifact. Undefined during native development. */
+  compute: Compute | undefined;
+  /** Project resource or existing project reference. Undefined during native development. */
+  project: WebsiteProjectReference | undefined;
+  /** Custom-domain resource, including DNS records and certificate status. Undefined without domain or during native development. */
+  domain: CustomDomain | undefined;
+}
+
+/** Internal framework-to-Node-target wiring. */
+export interface FrameworkSiteConfig {
+  /** Framework integration module. */
+  framework: string;
+  /** Existing Node deploy-target module. */
+  target: string;
+  /** Serializable framework-specific overrides. */
+  options?: Record<string, unknown>;
+  /** Artifact layout; Next.js serves from the application root. */
+  layout?: "output" | "next";
+  /** Default not-found behavior, overridden by assets.notFoundHandling. */
+  notFoundHandling?: "none" | "spa" | "404-page";
+  /** Default extensionless HTML behavior, overridden by assets.htmlHandling. */
+  htmlHandling?: "none" | "drop-trailing-slash";
+}
+
+/** Resolve build-time secrets without changing the redacted runtime env props. */
+export const websiteBuildEnv = (env: FrameworkSiteProps["env"]) =>
+  env === undefined
+    ? undefined
+    : Object.fromEntries(
+        Object.entries(env).map(([key, value]) => [
+          key,
+          Redacted.isRedacted(value) ? Redacted.value(value) : value,
+        ]),
+      );
+
+/** Shared live half, called only after a build resource has been declared. */
+export const deployWebsite = Effect.fn(function* (
+  props: Omit<FrameworkSiteProps, "dev">,
+  artifact: WebsiteArtifact,
+): Effect.fn.Return<Website, never, Providers> {
+  const project = Effect.isEffect(props.project)
+    ? yield* props.project
+    : (props.project ??
+      (yield* Project("Project", {
+        createDatabase: false,
+        region: props.regionId,
+      })));
+  const port = props.compute?.port ?? 3000;
+  const compute = yield* Compute("Compute", {
+    ...props.compute,
+    project: typeof project === "string" ? project : project.projectId,
+    artifactPath: artifact.artifactPath,
+    isExternal: true,
+    port,
+    regionId: props.regionId,
+    branchId: props.branchId,
+    branchGitName: props.branchGitName,
+    env: {
+      ...props.env,
+      PORT: String(port),
+      HOST: "0.0.0.0",
+      NODE_ENV: "production",
+    },
+  });
+  const domain = props.domain
+    ? yield* CustomDomain("Domain", { app: compute, hostname: props.domain })
+    : undefined;
+  return {
+    url: domain
+      ? Output.map(domain.hostname, (hostname) => `https://${hostname}`)
+      : compute.url,
+    compute,
+    project,
+    domain,
+  };
+});
+
+/** Compose a real framework build/dev server with a traced Prisma artifact. */
+export const makeFrameworkSite = Effect.fn(function* (
+  _id: string,
+  props: FrameworkSiteProps,
+  config: FrameworkSiteConfig,
+) {
+  const context = yield* AlchemyContext;
+  const remote = yield* ProviderModePolicy;
+  const handling = props.assets?.notFoundHandling;
+  const targetConfig = {
+    notFoundHandling:
+      handling === "single-page-application"
+        ? "spa"
+        : (handling ?? config.notFoundHandling),
+    htmlHandling: props.assets?.htmlHandling ?? config.htmlHandling,
+  };
+  const build = yield* Server("Build", {
+    framework: config.framework,
+    target: config.target,
+    root: props.rootDir,
+    env: websiteBuildEnv(props.env),
+    options: { ...config.options, ...targetConfig, targetConfig },
+    memo: props.memo,
+    dev: props.dev,
+  });
+  if (context.dev && remote !== true) {
+    return {
+      url: build.url,
+      compute: undefined,
+      project: undefined,
+      domain: undefined,
+    } satisfies Website;
+  }
+  const requiredPath = (value: string | undefined) =>
+    value === undefined
+      ? Effect.die(
+          new Error(
+            `The ${config.framework} Node build produced no deployable server output.`,
+          ),
+        )
+      : Effect.succeed(value);
+  const artifact = yield* WebsiteArtifact("Artifact", {
+    root: props.rootDir ?? ".",
+    distDir: Output.mapEffect(requiredPath)(build.distDir),
+    serverEntry: Output.mapEffect(requiredPath)(build.serverEntry),
+    layout: config.layout,
+    buildHash: build.hash.output,
+  });
+  return yield* deployWebsite(props, artifact);
+});

package/src/Prisma/Website/Nextjs.ts

@@ -0,0 +1,41 @@
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** Configuration for a Prisma Nextjs website. */
+export interface NextjsProps extends FrameworkSiteProps {}
+
+/**
+ * Next.js on Prisma Compute using next build and the existing Node custom-server target, not OpenNext. The artifact contains .next, public, configuration, and traced runtime dependencies, preserving installed package versions.
+ *
+ * Native framework development and HMR run without Prisma cloud resources.
+ * Apply `Alchemy.remote()` to use the live Compute deployment during dev.
+ * Packaging requires the optional `@vercel/nft` peer dependency.
+ *
+ * ### Creating a Website
+ * **Example:** Nextjs application
+ * ```typescript
+ * const site = yield* Prisma.Website.Nextjs("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * ### Deployment Configuration
+ * **Example:** Existing project and custom hostname
+ * ```typescript
+ * const site = yield* Prisma.Website.Nextjs("Web", {
+ *   project,
+ *   domain: "www.example.com",
+ *   env: { API_BASE: "https://api.example.com" },
+ *   compute: { destroyOldDeployment: true },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const Nextjs = (id: string, props: NextjsProps = {}) =>
+  makeFrameworkSite(id, props, {
+    framework: "@alchemy.run/frontend-frameworks/nextjs/node",
+    target: "@alchemy.run/frontend-frameworks/nextjs/node",
+    layout: "next",
+  }).pipe(Namespace.push(id));

package/src/Prisma/Website/Nuxt.ts

@@ -0,0 +1,44 @@
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** Configuration for a Prisma Nuxt website. */
+export interface NuxtProps extends FrameworkSiteProps {
+  /** Serializable overrides merged over nuxt.config.*; nitro.preset is owned by the Node target. */
+  nuxt?: Record<string, unknown>;
+}
+
+/**
+ * Nuxt SSR and prerendered assets on Prisma Compute. The Node target owns Nitro’s node preset; do not override nitro.preset.
+ *
+ * Native framework development and HMR run without Prisma cloud resources.
+ * Apply `Alchemy.remote()` to use the live Compute deployment during dev.
+ * Packaging requires the optional `@vercel/nft` peer dependency.
+ *
+ * ### Creating a Website
+ * **Example:** Nuxt application
+ * ```typescript
+ * const site = yield* Prisma.Website.Nuxt("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * ### Deployment Configuration
+ * **Example:** Existing project and custom hostname
+ * ```typescript
+ * const site = yield* Prisma.Website.Nuxt("Web", {
+ *   project,
+ *   domain: "www.example.com",
+ *   env: { API_BASE: "https://api.example.com" },
+ *   compute: { destroyOldDeployment: true },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const Nuxt = (id: string, props: NuxtProps = {}) =>
+  makeFrameworkSite(id, props, {
+    framework: "@alchemy.run/frontend-frameworks/nuxt",
+    target: "@alchemy.run/frontend-frameworks/nuxt/node",
+    options: { nuxt: props.nuxt },
+  }).pipe(Namespace.push(id));

package/src/Prisma/Website/Octane.ts

@@ -0,0 +1,40 @@
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** Configuration for a Prisma Octane website. */
+export interface OctaneProps extends FrameworkSiteProps {}
+
+/**
+ * Octane SSR and client assets on Prisma Compute. Select node() from @alchemy.run/frontend-frameworks/octane/node-adapter in the project’s octane.config.ts.
+ *
+ * Native framework development and HMR run without Prisma cloud resources.
+ * Apply `Alchemy.remote()` to use the live Compute deployment during dev.
+ * Packaging requires the optional `@vercel/nft` peer dependency.
+ *
+ * ### Creating a Website
+ * **Example:** Octane application
+ * ```typescript
+ * const site = yield* Prisma.Website.Octane("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * ### Deployment Configuration
+ * **Example:** Existing project and custom hostname
+ * ```typescript
+ * const site = yield* Prisma.Website.Octane("Web", {
+ *   project,
+ *   domain: "www.example.com",
+ *   env: { API_BASE: "https://api.example.com" },
+ *   compute: { destroyOldDeployment: true },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const Octane = (id: string, props: OctaneProps = {}) =>
+  makeFrameworkSite(id, props, {
+    framework: "@alchemy.run/frontend-frameworks/octane",
+    target: "@alchemy.run/frontend-frameworks/octane/node",
+  }).pipe(Namespace.push(id));

package/src/Prisma/Website/ReactRouter.ts

@@ -0,0 +1,40 @@
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** Configuration for a Prisma ReactRouter website. */
+export interface ReactRouterProps extends FrameworkSiteProps {}
+
+/**
+ * React Router SSR and browser assets on Prisma Compute using the existing Node framework target.
+ *
+ * Native framework development and HMR run without Prisma cloud resources.
+ * Apply `Alchemy.remote()` to use the live Compute deployment during dev.
+ * Packaging requires the optional `@vercel/nft` peer dependency.
+ *
+ * ### Creating a Website
+ * **Example:** ReactRouter application
+ * ```typescript
+ * const site = yield* Prisma.Website.ReactRouter("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * ### Deployment Configuration
+ * **Example:** Existing project and custom hostname
+ * ```typescript
+ * const site = yield* Prisma.Website.ReactRouter("Web", {
+ *   project,
+ *   domain: "www.example.com",
+ *   env: { API_BASE: "https://api.example.com" },
+ *   compute: { destroyOldDeployment: true },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const ReactRouter = (id: string, props: ReactRouterProps = {}) =>
+  makeFrameworkSite(id, props, {
+    framework: "@alchemy.run/frontend-frameworks/react-router",
+    target: "@alchemy.run/frontend-frameworks/react-router/node",
+  }).pipe(Namespace.push(id));

package/src/Prisma/Website/SolidStart.ts

@@ -0,0 +1,44 @@
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** Configuration for a Prisma SolidStart website. */
+export interface SolidStartProps extends FrameworkSiteProps {
+  /** Serializable Nitro plugin options, including prerender and routeRules. The Node target owns preset. */
+  nitro?: Record<string, unknown>;
+}
+
+/**
+ * SolidStart SSR and prerendered assets on Prisma Compute. The integration owns the Nitro plugin; omit nitroV2Plugin() from vite.config.* and configure prerendering through nitro.
+ *
+ * Native framework development and HMR run without Prisma cloud resources.
+ * Apply `Alchemy.remote()` to use the live Compute deployment during dev.
+ * Packaging requires the optional `@vercel/nft` peer dependency.
+ *
+ * ### Creating a Website
+ * **Example:** SolidStart application
+ * ```typescript
+ * const site = yield* Prisma.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * ### Deployment Configuration
+ * **Example:** Existing project and custom hostname
+ * ```typescript
+ * const site = yield* Prisma.Website.SolidStart("Web", {
+ *   project,
+ *   domain: "www.example.com",
+ *   env: { API_BASE: "https://api.example.com" },
+ *   compute: { destroyOldDeployment: true },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const SolidStart = (id: string, props: SolidStartProps = {}) =>
+  makeFrameworkSite(id, props, {
+    framework: "@alchemy.run/frontend-frameworks/solidstart",
+    target: "@alchemy.run/frontend-frameworks/solidstart/node",
+    options: { nitro: props.nitro },
+  }).pipe(Namespace.push(id));

package/src/Prisma/Website/StaticSite.ts

@@ -0,0 +1,149 @@
+import { makeNodeServeEntrySource } from "@alchemy.run/frontend-frameworks/core";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import * as Redacted from "effect/Redacted";
+import { AlchemyContext } from "../../AlchemyContext.ts";
+import * as Command from "../../Command/index.ts";
+import * as Namespace from "../../Namespace.ts";
+import * as Output from "../../Output.ts";
+import { ProviderModePolicy } from "../../ProviderMode.ts";
+import { initialCwd } from "../../Util/Node.ts";
+import { WebsiteArtifact } from "./Artifact.ts";
+import {
+  deployWebsite,
+  type FrameworkSiteProps,
+  type Website,
+} from "./FrameworkSite.ts";
+
+/** A command-built website with the same build vocabulary as Fly and Railway. */
+export interface StaticSiteProps
+  extends
+    Omit<Command.BuildProps, "env">,
+    Omit<FrameworkSiteProps, "dev" | "memo"> {
+  /** Local command; skips the production build. Without a command, a local static server serves the built output. */
+  dev?: {
+    /** Shell command that starts the native dev server. */
+    command: string;
+    /** Dev command directory; defaults to cwd or rootDir. */
+    cwd?: string;
+    /** Additional development environment variables. */
+    env?: Record<string, string | Redacted.Redacted<string>>;
+    /** Explicit dev URL when the command does not print one. */
+    url?: string;
+  };
+  /** Return index.html on unmatched paths. Mutually exclusive with errorPage. */
+  spa?: boolean;
+  /** HTML file returned with HTTP 404; relative to outdir. Mutually exclusive with spa. */
+  errorPage?: string;
+}
+
+const quote = (value: string) => `'${value.replaceAll("'", "'\\''")}'`;
+
+/**
+ * Build a static website with a shell command and serve it on Prisma Compute.
+ * Only the output directory is packaged; the repository is never uploaded.
+ * Native development declares no Prisma Project, Compute, or custom domain.
+ * `Alchemy.remote()` opts into the live deployment during development.
+ *
+ * ### Creating a Static Website
+ * **Example:** Hugo website
+ * ```typescript
+ * const site = yield* Prisma.Website.StaticSite("Blog", {
+ *   command: "hugo --minify",
+ *   outdir: "public",
+ * });
+ * ```
+ *
+ * ### Monorepos and Development
+ * **Example:** A custom frontend build
+ * ```typescript
+ * const site = yield* Prisma.Website.StaticSite("Web", {
+ *   cwd: "apps/web",
+ *   command: "npm run build",
+ *   outdir: "dist",
+ *   spa: true,
+ *   dev: { command: "npm run dev" },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const StaticSite = (id: string, props: StaticSiteProps) =>
+  Effect.gen(function* () {
+    const context = yield* AlchemyContext;
+    const remote = yield* ProviderModePolicy;
+    const local = context.dev && remote !== true;
+    const cwd = props.cwd ?? props.rootDir;
+    if (local && props.dev !== undefined) {
+      const dev = yield* Command.Dev("Dev", {
+        command: props.dev.command,
+        cwd: props.dev.cwd ?? cwd,
+        env: { ...props.env, ...props.dev.env },
+      });
+      return {
+        url: props.dev.url ?? dev.url,
+        compute: undefined,
+        project: undefined,
+        domain: undefined,
+      } satisfies Website;
+    }
+    if (props.spa && props.errorPage !== undefined) {
+      return yield* Effect.die(
+        new Error("StaticSite spa and errorPage are mutually exclusive."),
+      );
+    }
+    const build = yield* Command.Build("Build", {
+      command: props.command,
+      cwd,
+      env: props.env,
+      outdir: props.outdir,
+      memo: props.memo,
+      shell: props.shell,
+      timeout: props.timeout,
+    });
+    const handling = props.assets?.notFoundHandling;
+    const options = {
+      notFoundHandling:
+        props.errorPage !== undefined
+          ? ("404-page" as const)
+          : props.spa
+            ? ("spa" as const)
+            : handling === "single-page-application"
+              ? ("spa" as const)
+              : (handling ?? ("none" as const)),
+      htmlHandling: props.assets?.htmlHandling,
+      errorPage: props.errorPage,
+    };
+    if (local) {
+      const path = yield* Path.Path;
+      const runtime = yield* Effect.sync(() => process.execPath);
+      const command = Output.map(build.outdir, (outdir) => {
+        const source = makeNodeServeEntrySource({
+          ...options,
+          clientDirExpression: JSON.stringify(path.resolve(initialCwd, outdir)),
+          printUrl: true,
+        });
+        return `${quote(runtime)} --eval ${quote(source)}`;
+      });
+      const dev = yield* Command.Dev("Dev", {
+        command,
+        cwd,
+        shell: true,
+        env: { ...props.env, HOST: "127.0.0.1", PORT: "0" },
+      });
+      return {
+        url: dev.url,
+        compute: undefined,
+        project: undefined,
+        domain: undefined,
+      } satisfies Website;
+    }
+    const artifact = yield* WebsiteArtifact("Artifact", {
+      root: cwd ?? ".",
+      distDir: build.outdir,
+      buildHash: build.hash.output,
+      static: options,
+    });
+    return yield* deployWebsite(props, artifact);
+  }).pipe(Namespace.push(id));

package/src/Prisma/Website/SvelteKit.ts

@@ -0,0 +1,44 @@
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** Configuration for a Prisma SvelteKit website. */
+export interface SvelteKitProps extends FrameworkSiteProps {
+  /** Serializable SvelteKit v3 plugin configuration. The Node target owns adapter. */
+  kit?: Record<string, unknown>;
+}
+
+/**
+ * SvelteKit SSR and prerendered assets on Prisma Compute. The Node target injects the adapter. For Kit v3, pass configuration through kit rather than a svelte.config.js file.
+ *
+ * Native framework development and HMR run without Prisma cloud resources.
+ * Apply `Alchemy.remote()` to use the live Compute deployment during dev.
+ * Packaging requires the optional `@vercel/nft` peer dependency.
+ *
+ * ### Creating a Website
+ * **Example:** SvelteKit application
+ * ```typescript
+ * const site = yield* Prisma.Website.SvelteKit("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * ### Deployment Configuration
+ * **Example:** Existing project and custom hostname
+ * ```typescript
+ * const site = yield* Prisma.Website.SvelteKit("Web", {
+ *   project,
+ *   domain: "www.example.com",
+ *   env: { API_BASE: "https://api.example.com" },
+ *   compute: { destroyOldDeployment: true },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const SvelteKit = (id: string, props: SvelteKitProps = {}) =>
+  makeFrameworkSite(id, props, {
+    framework: "@alchemy.run/frontend-frameworks/sveltekit",
+    target: "@alchemy.run/frontend-frameworks/sveltekit/node",
+    options: { kit: props.kit },
+  }).pipe(Namespace.push(id));

package/src/Prisma/Website/TanStackStart.ts

@@ -0,0 +1,40 @@
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** Configuration for a Prisma TanStackStart website. */
+export interface TanStackStartProps extends FrameworkSiteProps {}
+
+/**
+ * TanStack Start SSR and browser assets on Prisma Compute using the existing Node framework target.
+ *
+ * Native framework development and HMR run without Prisma cloud resources.
+ * Apply `Alchemy.remote()` to use the live Compute deployment during dev.
+ * Packaging requires the optional `@vercel/nft` peer dependency.
+ *
+ * ### Creating a Website
+ * **Example:** TanStackStart application
+ * ```typescript
+ * const site = yield* Prisma.Website.TanStackStart("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * ### Deployment Configuration
+ * **Example:** Existing project and custom hostname
+ * ```typescript
+ * const site = yield* Prisma.Website.TanStackStart("Web", {
+ *   project,
+ *   domain: "www.example.com",
+ *   env: { API_BASE: "https://api.example.com" },
+ *   compute: { destroyOldDeployment: true },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Website
+ */
+export const TanStackStart = (id: string, props: TanStackStartProps = {}) =>
+  makeFrameworkSite(id, props, {
+    framework: "@alchemy.run/frontend-frameworks/tanstack-start",
+    target: "@alchemy.run/frontend-frameworks/tanstack-start/node",
+  }).pipe(Namespace.push(id));