alchemy 2.0.0-beta.74 → 2.0.0-beta.75

package/src/AWS/Website/Astro.ts

@@ -1,3 +1,4 @@
+import type { InputProps } from "../../Input.ts";
 import * as Namespace from "../../Namespace.ts";
 import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
 
@@ -10,42 +11,54 @@ export const ASTRO_AWS_TARGET_SPECIFIER =
   "@alchemy.run/frontend-frameworks/astro/aws";
 
 export interface AstroProps extends FrameworkSiteProps {
+  // Astro is configured in YOUR `astro.config.*`, which loads natively —
+  // this resource only deploys it. The `astro` bag is a deploy-time
+  // overlay merged OVER the file for values a config file cannot hold
+  // (per-stage values, other resources' Outputs).
   /**
-   * Serializable Astro config merged OVER the project's own
-   * `astro.config.*` (which loads natively). `adapter` is owned by the AWS
-   * deploy target and may not be set here.
+   * Deploy-time Astro config overrides, merged OVER your natively-loaded
+   * `astro.config.*` (values here win). Use it for values that vary per
+   * stage or derive from other resources' Outputs — everything else
+   * belongs in the config file.
    */
   astro?: {
-    /** The full URL the site deploys to (`Astro.site`). */
+    /** Deployed URL origin (astro's `site`). */
     site?: string;
-    /** Base path the site deploys under. */
+    /** Base path the site is served from (astro's `base`). */
     base?: string;
     /**
-     * Astro output target. `"server"` renders pages on demand in the
-     * Lambda; individual pages opt into prerendering with
-     * `export const prerender = true`. `"static"` prerenders every page at
-     * build time and deploys assets-only (no Lambda).
+     * Astro output target — a deploy-topology decision (whether a
+     * server function exists). `"server"` renders pages on demand in
+     * the Lambda; individual pages opt into prerendering with
+     * `export const prerender = true`. `"static"` prerenders every
+     * page at build time and deploys assets-only (no Lambda).
+     * Supersedes a file-level `output`.
      * @default "server"
      */
     output?: "server" | "static";
-    /** Source directory, relative to `rootDir`. @default "./src" */
+    /** Source directory (astro's `srcDir`). */
     srcDir?: string;
-    /** Public (static passthrough) directory. @default "./public" */
+    /** Public assets directory (astro's `publicDir`). */
     publicDir?: string;
-    /** Build output directory. @default "./dist" */
+    /** Build output directory (astro's `outDir`). */
     outDir?: string;
-    /** Trailing-slash handling for routes. */
+    /** Trailing-slash handling (astro's `trailingSlash`). */
     trailingSlash?: "always" | "never" | "ignore";
   };
+  /**
+   * Path to an alternate astro config file, relative to `rootDir`.
+   * Defaults to astro's own config discovery.
+   */
+  config?: string;
   /**
    * Serve the built error page (e.g. astro's `404.html`) for requests that
-   * match no uploaded file. Only applies to `output: "static"` sites — a
-   * server-backed site forwards misses to the Lambda instead.
+   * match no uploaded file. Only applies to `astro: { output: "static" }`
+   * sites — a server-backed site forwards misses to the Lambda instead.
    */
   errorPage?: string;
   /**
    * Answer misses with the index page (200) instead of a 404. Only applies
-   * to `output: "static"` sites.
+   * to `astro: { output: "static" }` sites.
    */
   spa?: boolean;
 }
@@ -66,6 +79,12 @@ export interface AstroProps extends FrameworkSiteProps {
  * from S3. With `astro: { output: "static" }` every page is prerendered
  * and the deploy is assets-only — no Lambda.
  *
+ * Your `astro.config.*` is the home for Astro configuration and loads
+ * natively; the `astro` prop is a deploy-time override bag merged OVER
+ * the file for values that vary per stage or derive from other
+ * resources' Outputs. `config` points at an alternate config file
+ * (relative to `rootDir`).
+ *
  * ### Creating Astro Sites
  * **Example:** Basic Astro App
  * ```typescript
@@ -74,6 +93,14 @@ export interface AstroProps extends FrameworkSiteProps {
  * });
  * ```
  *
+ * **Example:** Per-stage site URL override
+ * ```typescript
+ * const site = yield* AWS.Website.Astro("Blog", {
+ *   rootDir: "./blog",
+ *   astro: { site: "https://blog.example.com" },
+ * });
+ * ```
+ *
  * **Example:** Custom Domain
  * ```typescript
  * const site = yield* AWS.Website.Astro("Web", {
@@ -100,31 +127,28 @@ export interface AstroProps extends FrameworkSiteProps {
  * ```typescript
  * const site = yield* AWS.Website.Astro("Web", {
  *   rootDir: "./app",
- *   server: {
- *     memorySize: 2048,
- *     environment: {
- *       API_BASE: api.url,
- *     },
+ *   memorySize: 2048,
+ *   env: {
+ *     API_BASE: api.url,
  *   },
  * });
  * ```
  *
  * @resource
  */
-export const Astro = (id: string, props: AstroProps = {}) => {
+export const Astro = (id: string, props: InputProps<AstroProps> = {}) => {
+  const p = props as AstroProps;
   // Server output is the documented default: astro's own zero-config
   // default is `"static"`. The inline config merges OVER the project's
   // `astro.config.*`, so an explicit file-level `output` is superseded;
   // opt into a fully prerendered site with `astro: { output: "static" }`.
-  const output = props.astro?.output ?? "server";
+  const output = p.astro?.output ?? "server";
   return makeFrameworkSite(id, props, {
     name: "Astro",
     framework: ASTRO_FRAMEWORK_SPECIFIER,
     target: ASTRO_AWS_TARGET_SPECIFIER,
-    options: { astro: { ...props.astro, output } },
+    options: { astro: { ...p.astro, output }, config: p.config },
     static:
-      output === "static"
-        ? { spa: props.spa, errorPage: props.errorPage }
-        : undefined,
+      output === "static" ? { spa: p.spa, errorPage: p.errorPage } : undefined,
   }).pipe(Namespace.push(id));
 };

package/src/AWS/Website/Foldkit.ts

@@ -0,0 +1,126 @@
+import type { InputProps } from "../../Input.ts";
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite } from "./FrameworkSite.ts";
+import {
+  VITE_AWS_TARGET_SPECIFIER,
+  VITE_FRAMEWORK_SPECIFIER,
+  viteFrameworkOptions,
+  type ViteProps,
+} from "./Vite.ts";
+
+/**
+ * Props for {@link Foldkit}. A Foldkit app is a plain Vite project, so the
+ * surface is {@link ViteProps} — `rootDir`, `vite`, `domain`, `spa`,
+ * `errorPage`, and the rest of the shared website props.
+ */
+export interface FoldkitProps extends ViteProps {}
+
+/**
+ * Deploy a [Foldkit](https://foldkit.dev) app to AWS: the client build in
+ * S3 behind a CloudFront distribution. Foldkit is an Elm-architecture
+ * frontend framework built on Effect, and its apps are client-only Vite
+ * projects — so the deployment is assets-only and never creates a server
+ * function.
+ *
+ * The Foldkit Vite plugin lives in your project's own `vite.config.*`,
+ * which loads natively. The build runs through
+ * `@alchemy.run/frontend-frameworks/vite` with the
+ * `@alchemy.run/frontend-frameworks/vite/aws` deploy target — the package
+ * must be installed in your project. Input files are content-hashed so
+ * unchanged projects skip the build and deploy entirely.
+ *
+ * Foldkit apps route on the client, so `spa` defaults on: unmatched paths
+ * serve `index.html` with a `200` and the Foldkit runtime resolves the
+ * route once the app boots.
+ *
+ * During `alchemy dev` the site is Vite's own dev server — Foldkit's HMR
+ * and devtools wiring work unchanged — and no AWS resources are created.
+ * `Alchemy.remote()` opts back into the full deployment.
+ *
+ * ### Creating Foldkit Sites
+ * **Example:** Basic Foldkit App
+ * ```typescript
+ * const site = yield* AWS.Website.Foldkit("Web");
+ * ```
+ *
+ * **Example:** Project in a Subdirectory
+ * ```typescript
+ * const site = yield* AWS.Website.Foldkit("Web", {
+ *   rootDir: "applications/web",
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* AWS.Website.Foldkit("Web", {
+ *   domain: {
+ *     name: "app.example.com",
+ *     hostedZoneId: zone.hostedZoneId,
+ *   },
+ * });
+ * ```
+ *
+ * ### Deep Links
+ * A deep link like `/counter/42` arrives at the edge as a request for a
+ * file that does not exist. `spa` is on by default so the shell is served
+ * instead of a 404. An app that ships a real 404 page opts out with
+ * `errorPage` — the two are mutually exclusive.
+ *
+ * **Example:** Serving a Real 404 Page
+ * ```typescript
+ * const site = yield* AWS.Website.Foldkit("Web", {
+ *   spa: false,
+ *   errorPage: "404.html",
+ * });
+ * ```
+ *
+ * ### Sharing a Router
+ * **Example:** Serve Through an Existing AWS.Website.Router
+ * ```typescript
+ * const router = yield* AWS.Website.Router("Router", {});
+ * const site = yield* AWS.Website.Foldkit("Web", {
+ *   domain: { router },
+ * });
+ * ```
+ *
+ * ### Build Configuration
+ * Vite configuration (the Foldkit plugin included) lives in your
+ * project's own `vite.config.*`. The `vite` bag holds deploy-time
+ * overrides merged over that file, and `config` selects an alternate
+ * config file.
+ *
+ * **Example:** Deploy-Time Base Path Override
+ * ```typescript
+ * const site = yield* AWS.Website.Foldkit("Web", {
+ *   vite: { base: "/app/" },
+ * });
+ * ```
+ *
+ * ### Local Development
+ * **Example:** Foldkit's Vite Dev Server Under `alchemy dev`
+ * ```typescript
+ * // `alchemy dev` starts `vite` programmatically: site.url is the local
+ * // dev server (Foldkit HMR included); no bucket or distribution is
+ * // created.
+ * const site = yield* AWS.Website.Foldkit("Web");
+ * ```
+ *
+ * @resource
+ */
+export const Foldkit = (id: string, props: InputProps<FoldkitProps> = {}) => {
+  const p = props as FoldkitProps;
+  return makeFrameworkSite(id, props, {
+    name: "Foldkit",
+    framework: VITE_FRAMEWORK_SPECIFIER,
+    target: VITE_AWS_TARGET_SPECIFIER,
+    options: viteFrameworkOptions(p),
+    // Foldkit is client-only: the whole deployable output is the client
+    // build, so the deploy never creates a server function. Foldkit routes
+    // on the client, so `spa` defaults on — but yields to an explicit
+    // `errorPage` (the two are mutually exclusive downstream).
+    static: {
+      spa: p.spa ?? (p.errorPage === undefined ? true : undefined),
+      errorPage: p.errorPage,
+    },
+  }).pipe(Namespace.push(id));
+};

package/src/AWS/Website/FrameworkSite.ts

@@ -2,7 +2,7 @@ import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import { AlchemyContext } from "../../AlchemyContext.ts";
 import type { MemoOptions } from "../../Command/Memo.ts";
-import type { Input } from "../../Input.ts";
+import type { Input, InputProps } from "../../Input.ts";
 import * as Output from "../../Output.ts";
 import { ProviderModePolicy } from "../../ProviderMode.ts";
 import {
@@ -10,7 +10,7 @@ import {
   type FunctionProps,
 } from "../Lambda/Function.ts";
 import { asRouterDomain, registerDevRouterRoute } from "./DevRouterRoute.ts";
-import { Server, type ServerDevProps } from "./Server.ts";
+import { Server, type ServerDevProps } from "../../Website/Server.ts";
 import { makeKvSite, type StaticSiteProps } from "./StaticSite.ts";
 import {
   normalizeWebsiteDomain,
@@ -21,26 +21,39 @@ import {
 } from "./shared.ts";
 
 /**
- * SSR server (Lambda) configuration shared by the framework website
- * composites.
+ * Props shared by every framework website composite (SvelteKit, Nuxt,
+ * Waku, Octane, Astro). Each composite extends this with its
+ * framework-specific configuration, kept FLAT — the composite is the
+ * framework, so framework keys need no namespace.
  */
-export interface FrameworkServerProps {
+export interface FrameworkSiteProps {
+  /**
+   * Project root directory (the directory containing `package.json`).
+   * @default "."
+   */
+  rootDir?: string;
+  /**
+   * Controls which files are hashed to decide whether the build re-runs.
+   * @default true
+   */
+  memo?: MemoOptions | boolean;
+  /**
+   * Environment variables for the SSR server (Lambda environment).
+   * Values accept `Output`s (e.g. `API_URL: api.url`).
+   */
+  env?: Record<string, any>;
   /**
    * Memory allocated to the server function, in MB.
    * @default 1024
    */
   memorySize?: number;
   /**
-   * Maximum request duration.
+   * Maximum server request duration.
    * @default 30 seconds
    */
   timeout?: Duration.Duration;
   /**
-   * Environment variables for the server function.
-   */
-  environment?: Record<string, any>;
-  /**
-   * Instruction set architecture.
+   * Server instruction set architecture.
    * @default "x86_64"
    */
   architecture?: "x86_64" | "arm64";
@@ -49,28 +62,6 @@ export interface FrameworkServerProps {
    * @default "nodejs24.x"
    */
   runtime?: FunctionProps["runtime"];
-}
-
-/**
- * Props shared by every framework website composite (SvelteKit, Nuxt,
- * Waku, Octane, Astro). Each composite extends this with its
- * framework-specific configuration field.
- */
-export interface FrameworkSiteProps {
-  /**
-   * Project root directory (the directory containing `package.json`).
-   * @default "."
-   */
-  rootDir?: string;
-  /**
-   * Controls which files are hashed to decide whether the build re-runs.
-   * @default true
-   */
-  memo?: MemoOptions | boolean;
-  /**
-   * SSR server (Lambda) configuration.
-   */
-  server?: FrameworkServerProps;
   /**
    * Static asset upload configuration.
    */
@@ -159,9 +150,16 @@ export interface FrameworkSiteConfig {
 export const makeFrameworkSite = Effect.fn("AWS.Website.FrameworkSite")(
   function* (
     id: string,
-    props: FrameworkSiteProps,
+    propsIn: InputProps<FrameworkSiteProps>,
     config: FrameworkSiteConfig,
   ) {
+    // Props accept `Input<T>` throughout (matching the Cloudflare
+    // composites); values flow into the resources below, which resolve
+    // them at reconcile time. The plan-time reads in this function
+    // (domain-shape branching, dev wiring, the build's rootDir/memo)
+    // need concrete values — passing an `Output` for those specific
+    // fields is unsupported, same as on the Cloudflare side.
+    const props = propsIn as FrameworkSiteProps;
     const ctx = yield* AlchemyContext;
     const remoted = yield* ProviderModePolicy;
     const isLocal = ctx.dev && remoted !== true;
@@ -184,7 +182,7 @@ export const makeFrameworkSite = Effect.fn("AWS.Website.FrameworkSite")(
       framework: config.framework,
       target: config.target,
       root: props.rootDir,
-      env: props.server?.environment,
+      env: props.env,
       options: config.options,
       memo: props.memo,
       dev,
@@ -245,11 +243,11 @@ export const makeFrameworkSite = Effect.fn("AWS.Website.FrameworkSite")(
       // as a complete Node deployment unit (entry + chunks) — ship it
       // as-is.
       bundle: false,
-      runtime: props.server?.runtime ?? "nodejs24.x",
-      architecture: props.server?.architecture,
-      memorySize: props.server?.memorySize ?? 1024,
-      timeout: props.server?.timeout ?? Duration.seconds(30),
-      env: props.server?.environment,
+      runtime: props.runtime ?? "nodejs24.x",
+      architecture: props.architecture,
+      memorySize: props.memorySize ?? 1024,
+      timeout: props.timeout ?? Duration.seconds(30),
+      env: props.env,
       functionUrl: {
         authType: "NONE",
         invokeMode: "RESPONSE_STREAM",

package/src/AWS/Website/Nextjs.ts

@@ -1,3 +1,4 @@
+import type { InputProps } from "../../Input.ts";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import { AlchemyContext } from "../../AlchemyContext.ts";
@@ -17,7 +18,7 @@ import { Bucket } from "../S3/Bucket.ts";
 import { Queue } from "../SQS/Queue.ts";
 import { AssetDeployment } from "./AssetDeployment.ts";
 import { asRouterDomain, registerDevRouterRoute } from "./DevRouterRoute.ts";
-import { Server, type ServerDevProps } from "./Server.ts";
+import { Server, type ServerDevProps } from "../../Website/Server.ts";
 import { makeKvSite, type StaticSiteProps } from "./StaticSite.ts";
 import {
   normalizeWebsiteDomain,
@@ -56,32 +57,31 @@ export interface NextjsProps {
   /**
    * SSR server (Lambda) configuration.
    */
-  server?: {
-    /**
-     * Memory allocated to the server function, in MB.
-     * @default 1024
-     */
-    memorySize?: number;
-    /**
-     * Maximum request duration.
-     * @default 30 seconds
-     */
-    timeout?: Duration.Duration;
-    /**
-     * Environment variables for the server function.
-     */
-    environment?: Record<string, any>;
-    /**
-     * Instruction set architecture.
-     * @default "x86_64"
-     */
-    architecture?: "x86_64" | "arm64";
-    /**
-     * Lambda runtime for the server function.
-     * @default "nodejs24.x"
-     */
-    runtime?: FunctionProps["runtime"];
-  };
+  /**
+   * Memory allocated to the server function, in MB.
+   * @default 1024
+   */
+  memorySize?: number;
+  /**
+   * Maximum server request duration.
+   * @default 30 seconds
+   */
+  timeout?: Duration.Duration;
+  /**
+   * Environment variables for the SSR server (Lambda environment).
+   * Values accept `Output`s (e.g. `API_URL: api.url`).
+   */
+  env?: Record<string, any>;
+  /**
+   * Server instruction set architecture.
+   * @default "x86_64"
+   */
+  architecture?: "x86_64" | "arm64";
+  /**
+   * Lambda runtime for the server function.
+   * @default "nodejs24.x"
+   */
+  runtime?: FunctionProps["runtime"];
   /**
    * Image optimization (Lambda) configuration.
    */
@@ -177,19 +177,19 @@ export interface NextjsProps {
  * ```typescript
  * const site = yield* AWS.Website.Nextjs("Web", {
  *   rootDir: "./app",
- *   server: {
- *     memorySize: 2048,
- *     environment: {
- *       API_BASE: api.url,
- *     },
+ *   memorySize: 2048,
+ *   env: {
+ *     API_BASE: api.url,
  *   },
  * });
  * ```
  *
  * @resource
  */
+
 export const Nextjs = Effect.fn("AWS.Website.Nextjs")(
-  function* (id: string, props: NextjsProps = {}) {
+  function* (id: string, propsIn: InputProps<NextjsProps> = {}) {
+    const props = propsIn as NextjsProps;
     const ctx = yield* AlchemyContext;
     const remoted = yield* ProviderModePolicy;
     // Mirrors the other Website composites: during `alchemy dev` the site
@@ -201,7 +201,7 @@ export const Nextjs = Effect.fn("AWS.Website.Nextjs")(
       framework: NEXTJS_AWS_FRAMEWORK_SPECIFIER,
       target: NEXTJS_AWS_FRAMEWORK_SPECIFIER,
       root: props.rootDir,
-      env: props.server?.environment,
+      env: props.env,
       memo: props.memo,
       dev: props.dev,
     });
@@ -306,10 +306,10 @@ export const Nextjs = Effect.fn("AWS.Website.Nextjs")(
       // OpenNext's server-functions/default is a complete deployment unit
       // (entry + traced .next output + its own node_modules) — ship as-is.
       bundle: false,
-      runtime: props.server?.runtime ?? "nodejs24.x",
-      architecture: props.server?.architecture,
-      memorySize: props.server?.memorySize ?? 1024,
-      timeout: props.server?.timeout ?? Duration.seconds(30),
+      runtime: props.runtime ?? "nodejs24.x",
+      architecture: props.architecture,
+      memorySize: props.memorySize ?? 1024,
+      timeout: props.timeout ?? Duration.seconds(30),
       env: {
         // The env names OpenNext's s3/sqs/dynamodb overrides read. Regions
         // are omitted: the SDK falls back to the Lambda runtime's own
@@ -318,7 +318,7 @@ export const Nextjs = Effect.fn("AWS.Website.Nextjs")(
         CACHE_BUCKET_KEY_PREFIX: NEXTJS_CACHE_PREFIX,
         REVALIDATION_QUEUE_URL: revalidationQueue.queueUrl,
         CACHE_DYNAMO_TABLE: tagCacheTable.tableName,
-        ...props.server?.environment,
+        ...props.env,
       },
       functionUrl: {
         authType: "NONE",

package/src/AWS/Website/Nuxt.ts

@@ -1,3 +1,4 @@
+import type { InputProps } from "../../Input.ts";
 import * as Namespace from "../../Namespace.ts";
 import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
 
@@ -11,8 +12,15 @@ export const NUXT_AWS_TARGET_SPECIFIER =
 export interface NuxtProps extends FrameworkSiteProps {
   /**
    * Nuxt config overrides merged over the project's own `nuxt.config.ts`
-   * (highest-priority layer). `nitro.preset` is owned by the AWS deploy
-   * target and may not be set here.
+   * (the highest-priority c12 layer — a value here wins over the file).
+   * Use it for deploy-time values the config file can't express, e.g.
+   * per-stage `runtimeConfig`; `nuxt.config.ts` remains the primary home
+   * for everything else.
+   *
+   * Must be JSON-serializable — no functions, plugins, or modules (the
+   * value persists in state and participates in the rebuild hash).
+   * `nitro.preset` is always owned by the deploy target and cannot be
+   * overridden here.
    */
   nuxt?: Record<string, unknown>;
 }
@@ -51,10 +59,29 @@ export interface NuxtProps extends FrameworkSiteProps {
  * ```typescript
  * const site = yield* AWS.Website.Nuxt("Web", {
  *   rootDir: "./app",
- *   server: {
- *     memorySize: 2048,
- *     environment: {
- *       NUXT_PUBLIC_API_BASE: api.url,
+ *   memorySize: 2048,
+ *   env: {
+ *     NUXT_PUBLIC_API_BASE: api.url,
+ *   },
+ * });
+ * ```
+ *
+ * ### Config Overrides
+ * `nuxt.config.ts` is the primary home for Nuxt configuration — it loads
+ * natively. The `nuxt` prop layers deploy-time overrides on top (the
+ * highest-priority c12 layer) for values the file can't express, like
+ * per-stage settings. The bag must be JSON-serializable — no functions,
+ * plugins, or modules — and `nitro.preset` stays owned by the deploy
+ * target.
+ *
+ * **Example:** Deploy-time config overrides
+ * ```typescript
+ * const site = yield* AWS.Website.Nuxt("Web", {
+ *   rootDir: "./app",
+ *   nuxt: {
+ *     app: { baseURL: "/docs/" },
+ *     runtimeConfig: {
+ *       public: { apiBase: "https://api.example.com" },
  *     },
  *   },
  * });
@@ -62,10 +89,12 @@ export interface NuxtProps extends FrameworkSiteProps {
  *
  * @resource
  */
-export const Nuxt = (id: string, props: NuxtProps = {}) =>
-  makeFrameworkSite(id, props, {
+export const Nuxt = (id: string, props: InputProps<NuxtProps> = {}) => {
+  const p = props as NuxtProps;
+  return makeFrameworkSite(id, props, {
     name: "Nuxt",
     framework: NUXT_FRAMEWORK_SPECIFIER,
     target: NUXT_AWS_TARGET_SPECIFIER,
-    options: props.nuxt ? { nuxt: props.nuxt } : undefined,
+    options: p.nuxt !== undefined ? { nuxt: p.nuxt } : undefined,
   }).pipe(Namespace.push(id));
+};

package/src/AWS/Website/Octane.ts

@@ -1,3 +1,4 @@
+import type { InputProps } from "../../Input.ts";
 import * as Namespace from "../../Namespace.ts";
 import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
 
@@ -65,18 +66,16 @@ export interface OctaneProps extends FrameworkSiteProps {
  * ```typescript
  * const site = yield* AWS.Website.Octane("Web", {
  *   rootDir: "./app",
- *   server: {
- *     memorySize: 2048,
- *     environment: {
- *       API_BASE: api.url,
- *     },
+ *   memorySize: 2048,
+ *   env: {
+ *     API_BASE: api.url,
  *   },
  * });
  * ```
  *
  * @resource
  */
-export const Octane = (id: string, props: OctaneProps = {}) =>
+export const Octane = (id: string, props: InputProps<OctaneProps> = {}) =>
   makeFrameworkSite(id, props, {
     name: "Octane",
     framework: OCTANE_FRAMEWORK_SPECIFIER,