alchemy 0.11.3 → 0.12.0

package/lib/alchemy.d.ts

@@ -1,4 +1,5 @@
 import { destroy } from "./destroy";
+import { env } from "./env";
 import { Scope } from "./scope";
 import { secret } from "./secret";
 import type { StateStoreType } from "./state";
@@ -143,5 +144,4 @@ declare function run<T>(...args: [id: string, fn: (this: Scope, scope: Scope) =>
     options: RunOptions,
     fn: (this: Scope, scope: Scope) => Promise<T>
 ]): Promise<T>;
-export declare function env<T = string>(name: string, value?: T | undefined, error?: string): Promise<T>;
 export {};

package/lib/alchemy.js

@@ -1,9 +1,14 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { destroy, DestroyedSignal } from "./destroy";
+import { env } from "./env";
 import { Scope } from "./scope";
 import { secret } from "./secret";
 export const alchemy = _alchemy;
+_alchemy.destroy = destroy;
+_alchemy.run = run;
+_alchemy.secret = secret;
+_alchemy.env = env;
 /**
  * Implementation of the alchemy function that handles both application scoping
  * and template string interpolation.
@@ -119,10 +124,6 @@ async function _alchemy(...args) {
         ].join("\n");
     }
 }
-_alchemy.destroy = destroy;
-_alchemy.run = run;
-_alchemy.secret = secret;
-_alchemy.env = env;
 /**
  * Run a function in a new scope asynchronously.
  * Useful for isolating secret handling with a specific password.
@@ -183,23 +184,3 @@ async function run(...args) {
         await _scope.finalize();
     }
 }
-export async function env(name, value, error) {
-    if (value !== undefined) {
-        return value;
-    }
-    else if (typeof process !== undefined) {
-        // we are in a node environment
-        return process.env[name];
-    }
-    else {
-        // we are in a browser environment
-        try {
-            const { env } = await import("cloudflare:workers");
-            if (name in env) {
-                return env[name];
-            }
-        }
-        catch (error) { }
-    }
-    throw new Error(error ?? `Environment variable ${name} is not set`);
-}

package/lib/cloudflare/index.d.ts

@@ -13,9 +13,11 @@ export * from "./permission-groups";
 export * from "./pipeline";
 export * from "./queue";
 export * from "./r2-rest-state-store";
+export * from "./tanstack-start";
 export * from "./vectorize-index";
 export * from "./vectorize-metadata-index";
-export * from "./vite-site";
+export * from "./vite";
+export * from "./website";
 export * from "./worker";
 export { Workflow } from "./workflow";
 export * from "./wrangler.json";

package/lib/cloudflare/index.js

@@ -13,9 +13,11 @@ export * from "./permission-groups";
 export * from "./pipeline";
 export * from "./queue";
 export * from "./r2-rest-state-store";
+export * from "./tanstack-start";
 export * from "./vectorize-index";
 export * from "./vectorize-metadata-index";
-export * from "./vite-site";
+export * from "./vite";
+export * from "./website";
 export * from "./worker";
 export { Workflow } from "./workflow";
 export * from "./wrangler.json";

package/lib/cloudflare/tanstack-start.d.ts

@@ -0,0 +1,12 @@
+import type { Assets } from "./assets";
+import type { Bindings } from "./bindings";
+import { type WebsiteProps } from "./website";
+import type { Worker } from "./worker";
+export interface TanStackStartProps<B extends Bindings> extends WebsiteProps<B> {
+}
+export type TanStackStart<B extends Bindings> = B extends {
+    ASSETS: any;
+} ? never : Worker<B & {
+    ASSETS: Assets;
+}>;
+export declare function TanStackStart<B extends Bindings>(id: string, props?: Partial<TanStackStartProps<B>>): Promise<TanStackStart<B>>;

package/lib/cloudflare/tanstack-start.js

@@ -0,0 +1,11 @@
+import { Website } from "./website";
+export async function TanStackStart(id, props) {
+    return Website(id, {
+        ...props,
+        command: props?.command ?? "bun run build",
+        wrangler: props?.wrangler ?? false,
+        entrypoint: props?.entrypoint ?? ".output/server/index.mjs",
+        compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
+        assets: props?.assets ?? ".output/public",
+    });
+}

package/lib/cloudflare/vite.d.ts

@@ -0,0 +1,12 @@
+import type { Assets } from "./assets";
+import type { Bindings } from "./bindings";
+import { type WebsiteProps } from "./website";
+import type { Worker } from "./worker";
+export interface ViteProps<B extends Bindings> extends WebsiteProps<B> {
+}
+export type Vite<B extends Bindings> = B extends {
+    ASSETS: any;
+} ? never : Worker<B & {
+    ASSETS: Assets;
+}>;
+export declare function Vite<B extends Bindings>(id: string, props: ViteProps<B>): Promise<Vite<B>>;

package/lib/cloudflare/vite.js

@@ -0,0 +1,18 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Website } from "./website";
+export async function Vite(id, props) {
+    return Website(id, {
+        ...props,
+        assets: props.assets ??
+            (await (async () => {
+                try {
+                    await fs.access(path.join("dist", "client", "index.html"));
+                    return path.join(".", "dist", "client");
+                }
+                catch {
+                    return path.join(".", "dist");
+                }
+            })()),
+    });
+}

package/lib/cloudflare/{vite-site.d.ts → website.d.ts}

@@ -1,7 +1,7 @@
 import { Assets } from "./assets";
 import type { Bindings } from "./bindings";
-import { Worker } from "./worker";
-export interface ViteSiteProps<B extends Bindings> {
+import { Worker, type AssetsConfig, type WorkerProps } from "./worker";
+export interface WebsiteProps<B extends Bindings> extends Omit<WorkerProps<B>, "name" | "assets"> {
     /**
      * The command to run to build the site
      */
@@ -23,19 +23,23 @@ export interface ViteSiteProps<B extends Bindings> {
      *
      * @default "./dist"
      */
-    assets?: string;
-    /**
-     * The bindings to pass to the worker
-     */
-    bindings?: B;
+    assets?: string | ({
+        dist?: string;
+    } & AssetsConfig);
     /**
      * @default process.cwd()
      */
     cwd?: string;
+    /**
+     * Write a wrangler.jsonc file
+     *
+     * @default - no wrangler.jsonc file is written
+     */
+    wrangler?: boolean | string;
 }
-export type ViteSite<B extends Bindings> = Promise<B extends {
+export type Website<B extends Bindings> = B extends {
     ASSETS: any;
 } ? never : Worker<B & {
     ASSETS: Assets;
-}>>;
-export declare function ViteSite<B extends Bindings>(id: string, props: ViteSiteProps<B>): ViteSite<B>;
+}>;
+export declare function Website<B extends Bindings>(id: string, props: WebsiteProps<B>): Promise<Website<B>>;

package/lib/cloudflare/website.js

@@ -0,0 +1,72 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { alchemy } from "../alchemy";
+import { Exec } from "../os";
+import { Assets } from "./assets";
+import { Worker } from "./worker";
+import { WranglerJson } from "./wrangler.json";
+export async function Website(id, props) {
+    if (props.bindings?.ASSETS) {
+        throw new Error("ASSETS binding is reserved for internal use");
+    }
+    return alchemy.run(id, async () => {
+        // building the site requires a wrangler.jsonc file to start
+        // - so initialize an empty one if it doesn't exist
+        const cwd = path.resolve(props.cwd || process.cwd());
+        const fileName = typeof props.wrangler === "boolean" ? "wrangler.jsonc" : props.wrangler;
+        const wranglerPath = fileName && path.relative(cwd, path.join(cwd, fileName));
+        if (props.wrangler) {
+            try {
+                await fs.access(wranglerPath);
+            }
+            catch {
+                await fs.writeFile(wranglerPath, JSON.stringify({
+                    name: id,
+                    main: props.main,
+                    compatibility_date: new Date().toISOString().split("T")[0],
+                }, null, 2));
+            }
+        }
+        await Exec("build", {
+            command: props.command,
+        });
+        const dist = typeof props.assets === "string"
+            ? props.assets
+            : (props.assets?.dist ?? "dist");
+        const staticAssets = await Assets("assets", {
+            path: dist,
+        });
+        const worker = await Worker("worker", {
+            ...props,
+            name: props.name ?? id,
+            entrypoint: props.main,
+            assets: {
+                html_handling: "auto-trailing-slash",
+                not_found_handling: "single-page-application",
+                run_worker_first: false,
+                ...(typeof props.assets === "string" ? {} : props.assets),
+            },
+            script: props.main
+                ? undefined
+                : `
+export default {
+async fetch(request, env) {
+  return new Response("Not Found", { status: 404 });
+},
+};`,
+            url: true,
+            adopt: true,
+            bindings: {
+                ...props.bindings,
+                ASSETS: staticAssets,
+            },
+        });
+        if (props.wrangler) {
+            await WranglerJson("wrangler.jsonc", {
+                path: wranglerPath,
+                worker,
+            });
+        }
+        return worker;
+    });
+}

package/lib/cloudflare/worker.d.ts

@@ -5,6 +5,40 @@ import { type CloudflareApiOptions } from "./api";
 import { type Bindings } from "./bindings";
 import type { Bound } from "./bound";
 import type { SingleStepMigration } from "./worker-migration";
+/**
+ * Configuration options for static assets
+ */
+export interface AssetsConfig {
+    /**
+     * The contents of a _headers file (used to attach custom headers on asset responses)
+     */
+    _headers?: string;
+    /**
+     * The contents of a _redirects file (used to apply redirects or proxy paths ahead of asset serving)
+     */
+    _redirects?: string;
+    /**
+     * Determines the redirects and rewrites of requests for HTML content
+     * @default "auto-trailing-slash"
+     */
+    html_handling?: "auto-trailing-slash" | "force-trailing-slash" | "drop-trailing-slash" | "none";
+    /**
+     * Determines the response when a request does not match a static asset, and there is no Worker script
+     */
+    not_found_handling?: "none" | "404-page" | "single-page-application";
+    /**
+     * When true, requests will always invoke the Worker script.
+     * Otherwise, attempt to serve an asset matching the request, falling back to the Worker script.
+     */
+    run_worker_first?: boolean;
+    /**
+     * When true and the incoming request matches an asset, that will be served instead of invoking the Worker script.
+     * When false, requests will always invoke the Worker script.
+     * @default true
+     * @deprecated
+     */
+    serve_directly?: boolean;
+}
 /**
  * Properties for creating or updating a Worker
  */
@@ -83,6 +117,10 @@ export interface WorkerProps<B extends Bindings = Bindings> extends CloudflareAp
      * The compatibility flags for the worker
      */
     compatibilityFlags?: string[];
+    /**
+     * Configuration for static assets
+     */
+    assets?: AssetsConfig;
 }
 /**
  * Output returned after Worker creation/update
@@ -110,6 +148,10 @@ export interface Worker<B extends Bindings = Bindings> extends Resource<"cloudfl
      * The bindings that were created
      */
     bindings: B | undefined;
+    /**
+     * Configuration for static assets
+     */
+    assets?: AssetsConfig;
     Env: {
         [bindingName in keyof B]: Bound<B[bindingName]>;
     };

package/lib/cloudflare/worker.js

@@ -132,7 +132,7 @@ export const Worker = Resource("cloudflare::Worker", {
         // In the future, we might want to support multiple asset bindings
         const assetBinding = assetsBindings[0];
         // Upload the assets and get the completion token
-        assetUploadResult = await uploadAssets(api, workerName, assetBinding.assets);
+        assetUploadResult = await uploadAssets(api, workerName, assetBinding.assets, props.assets);
     }
     // Prepare metadata with bindings
     const scriptMetadata = await prepareWorkerMetadata(this, oldBindings, props, assetUploadResult);
@@ -165,6 +165,8 @@ export const Worker = Resource("cloudflare::Worker", {
         createdAt: now,
         updatedAt: now,
         url: workerUrl,
+        // Include assets configuration in the output
+        assets: props.assets,
         // phantom property
         Env: undefined,
     });
@@ -236,6 +238,35 @@ class NotFoundError extends Error {
         this.name = "NotFoundError";
     }
 }
+/**
+ * Creates asset configuration object from provided config or defaults
+ */
+function createAssetConfig(config) {
+    const assetConfig = {
+        html_handling: "auto-trailing-slash",
+    };
+    if (config) {
+        if (config._headers !== undefined) {
+            assetConfig._headers = config._headers;
+        }
+        if (config._redirects !== undefined) {
+            assetConfig._redirects = config._redirects;
+        }
+        if (config.html_handling !== undefined) {
+            assetConfig.html_handling = config.html_handling;
+        }
+        if (config.not_found_handling !== undefined) {
+            assetConfig.not_found_handling = config.not_found_handling;
+        }
+        if (config.run_worker_first !== undefined) {
+            assetConfig.run_worker_first = config.run_worker_first;
+        }
+        if (config.serve_directly !== undefined) {
+            assetConfig.serve_directly = config.serve_directly;
+        }
+    }
+    return assetConfig;
+}
 async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult) {
     // Prepare metadata with bindings
     const meta = {
@@ -260,8 +291,16 @@ async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult)
         meta.assets = {
             jwt: assetUploadResult.completionToken,
         };
+        // Initialize config from assetUploadResult if it exists
         if (assetUploadResult.assetConfig) {
-            meta.assets.config = assetUploadResult.assetConfig;
+            meta.assets.config = {
+                ...assetUploadResult.assetConfig,
+            };
+        }
+        // If there's no config from assetUploadResult but we have props.assets,
+        // we need to create the config ourselves (this handles the case when no assets were uploaded)
+        if (!meta.assets.config && props.assets) {
+            meta.assets.config = createAssetConfig(props.assets);
         }
     }
     const bindings = (props.bindings ?? {});
@@ -538,9 +577,12 @@ async function getWorkerBindings(api, workerName, environment = "production") {
  * @param api CloudflareApi instance
  * @param workerName Name of the worker
  * @param assets Assets resource containing files to upload
+ * @param assetConfig Configuration for the assets
  * @returns Completion token for the assets upload
  */
-async function uploadAssets(api, workerName, assets) {
+async function uploadAssets(api, workerName, assets, assetConfig) {
+    // Process the assets configuration once at the beginning
+    const processedConfig = createAssetConfig(assetConfig);
     // Generate the file manifest
     const fileMetadata = {};
     // Process each file in the assets
@@ -561,7 +603,10 @@ async function uploadAssets(api, workerName, assets) {
     const sessionData = (await uploadSessionResponse.json());
     // If there are no buckets, assets are already uploaded or empty
     if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
-        return { completionToken: sessionData.result.jwt };
+        return {
+            completionToken: sessionData.result.jwt,
+            assetConfig: processedConfig,
+        };
     }
     // Upload the files in batches as specified by the API
     let completionToken = sessionData.result.jwt;
@@ -607,12 +652,10 @@ async function uploadAssets(api, workerName, assets) {
             completionToken = uploadData.result.jwt;
         }
     }
-    // Return the final completion token
+    // Return the final completion token with asset configuration
     return {
         completionToken,
-        assetConfig: {
-            html_handling: "auto-trailing-slash",
-        },
+        assetConfig: processedConfig,
     };
 }
 /**

package/lib/env.d.ts

@@ -0,0 +1,5 @@
+export interface Env {
+    [key: string]: Promise<string>;
+    <T = string>(name: string, value?: T | undefined, error?: string): Promise<T>;
+}
+export declare const env: Env;

package/lib/env.js

@@ -0,0 +1,24 @@
+export const env = new Proxy(_env, {
+    get: (_, name) => _env(name),
+    apply: (_, __, args) => _env(...args),
+});
+async function _env(name, value, error) {
+    if (value !== undefined) {
+        return value;
+    }
+    else if (typeof process !== undefined) {
+        // we are in a node environment
+        return process.env[name];
+    }
+    else {
+        // we are in a browser environment
+        try {
+            const { env } = await import("cloudflare:workers");
+            if (name in env) {
+                return env[name];
+            }
+        }
+        catch (error) { }
+    }
+    throw new Error(error ?? `Environment variable ${name} is not set`);
+}

package/lib/internal/docs/providers.js

@@ -49,7 +49,7 @@ async function generateProviderDocs({ provider, outDir, parallel, }) {
                 reasoningEffort: "high",
             },
         },
-        freeze: true,
+        freeze: false,
         temperature: 0.1,
         schema: type({
             groups: type({
@@ -96,7 +96,7 @@ async function generateProviderDocs({ provider, outDir, parallel, }) {
         return Document(`docs/${providerName}/${g.identifier}`, {
             title: g.identifier,
             path: path.join(providerDocsDir, `${g.filename.replace(".ts", "").replace(".md", "")}.md`),
-            freeze: true,
+            freeze: false,
             model: {
                 id: "claude-3-5-sonnet-latest",
                 provider: "anthropic",

package/lib/secret.d.ts

@@ -73,5 +73,9 @@ export declare function isSecret(binding: any): binding is Secret;
  */
 export declare function secret<S extends string | undefined>(unencrypted: S): Secret;
 export declare namespace secret {
-    function env(name: string, value?: string, error?: string): Promise<Secret>;
+    interface Env {
+        [key: string]: Promise<Secret>;
+        (name: string, value?: string, error?: string): Promise<Secret>;
+    }
+    const env: Env;
 }

package/lib/secret.js

@@ -1,3 +1,4 @@
+import { alchemy } from "./alchemy";
 /**
  * Internal wrapper for sensitive values like API keys and credentials.
  * When stored in alchemy state files, the value is automatically encrypted
@@ -83,8 +84,11 @@ export function secret(unencrypted) {
     return new Secret(unencrypted);
 }
 (function (secret) {
-    async function env(name, value, error) {
-        const alchemy = await import("./alchemy");
+    secret.env = new Proxy(_env, {
+        get: (_, name) => _env(name),
+        apply: (_, __, args) => _env(...args),
+    });
+    async function _env(name, value, error) {
         const result = await alchemy.env(name, value, error);
         if (typeof result === "string") {
             return secret(result);
@@ -93,5 +97,4 @@ export function secret(unencrypted) {
             throw new Error(`Secret environment variable ${name} is not a string`);
         }
     }
-    secret.env = env;
 })(secret || (secret = {}));

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "alchemy",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {
     "publish:npm": "cp ../README.md . && rm -rf ./*.tsbuildinfo && rm -rf ./lib && tsc -b && npm publish && rm README.md",
     "docs:gen": "rm -rf ./docs && typedoc"
   },
-  "files": ["lib", "src"],
+  "files": [
+    "lib",
+    "src"
+  ],
   "exports": {
     ".": "./lib/index.js",
     "./ai": "./lib/ai/index.js",

package/src/alchemy.ts

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 
 import { destroy, DestroyedSignal } from "./destroy";
+import { env } from "./env";
 import type { PendingResource } from "./resource";
 import { Scope } from "./scope";
 import { secret } from "./secret";
@@ -81,6 +82,11 @@ export interface Alchemy {
   (template: TemplateStringsArray, ...values: any[]): Promise<string>;
 }
 
+_alchemy.destroy = destroy;
+_alchemy.run = run;
+_alchemy.secret = secret;
+_alchemy.env = env;
+
 /**
  * Implementation of the alchemy function that handles both application scoping
  * and template string interpolation.
@@ -214,10 +220,6 @@ async function _alchemy(
     ].join("\n");
   }
 }
-_alchemy.destroy = destroy;
-_alchemy.run = run;
-_alchemy.secret = secret;
-_alchemy.env = env;
 
 export interface AlchemyOptions {
   /**
@@ -349,25 +351,3 @@ async function run<T>(
     await _scope.finalize();
   }
 }
-
-export async function env<T = string>(
-  name: string,
-  value?: T | undefined,
-  error?: string
-): Promise<T> {
-  if (value !== undefined) {
-    return value;
-  } else if (typeof process !== undefined) {
-    // we are in a node environment
-    return process.env[name]! as T;
-  } else {
-    // we are in a browser environment
-    try {
-      const { env } = await import("cloudflare:workers");
-      if (name in env) {
-        return env[name as keyof typeof env];
-      }
-    } catch (error) {}
-  }
-  throw new Error(error ?? `Environment variable ${name} is not set`);
-}

package/src/cloudflare/index.ts

@@ -13,9 +13,11 @@ export * from "./permission-groups";
 export * from "./pipeline";
 export * from "./queue";
 export * from "./r2-rest-state-store";
+export * from "./tanstack-start";
 export * from "./vectorize-index";
 export * from "./vectorize-metadata-index";
-export * from "./vite-site";
+export * from "./vite";
+export * from "./website";
 export * from "./worker";
 export { Workflow } from "./workflow";
 export * from "./wrangler.json";

package/src/cloudflare/tanstack-start.ts

@@ -0,0 +1,26 @@
+import type { Assets } from "./assets";
+import type { Bindings } from "./bindings";
+import { Website, type WebsiteProps } from "./website";
+import type { Worker } from "./worker";
+
+export interface TanStackStartProps<B extends Bindings>
+  extends WebsiteProps<B> {}
+
+// don't allow the ASSETS to be overriden
+export type TanStackStart<B extends Bindings> = B extends { ASSETS: any }
+  ? never
+  : Worker<B & { ASSETS: Assets }>;
+
+export async function TanStackStart<B extends Bindings>(
+  id: string,
+  props?: Partial<TanStackStartProps<B>>
+): Promise<TanStackStart<B>> {
+  return Website(id, {
+    ...props,
+    command: props?.command ?? "bun run build",
+    wrangler: props?.wrangler ?? false,
+    entrypoint: props?.entrypoint ?? ".output/server/index.mjs",
+    compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
+    assets: props?.assets ?? ".output/public",
+  });
+}

package/src/cloudflare/vite.ts

@@ -0,0 +1,32 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { Assets } from "./assets";
+import type { Bindings } from "./bindings";
+import { Website, type WebsiteProps } from "./website";
+import type { Worker } from "./worker";
+
+export interface ViteProps<B extends Bindings> extends WebsiteProps<B> {}
+
+// don't allow the ASSETS to be overriden
+export type Vite<B extends Bindings> = B extends { ASSETS: any }
+  ? never
+  : Worker<B & { ASSETS: Assets }>;
+
+export async function Vite<B extends Bindings>(
+  id: string,
+  props: ViteProps<B>
+): Promise<Vite<B>> {
+  return Website(id, {
+    ...props,
+    assets:
+      props.assets ??
+      (await (async () => {
+        try {
+          await fs.access(path.join("dist", "client", "index.html"));
+          return path.join(".", "dist", "client");
+        } catch {
+          return path.join(".", "dist");
+        }
+      })()),
+  });
+}

package/src/cloudflare/website.ts

@@ -0,0 +1,140 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { alchemy } from "../alchemy";
+import { Exec } from "../os";
+import { Assets } from "./assets";
+import type { Bindings } from "./bindings";
+import { Worker, type AssetsConfig, type WorkerProps } from "./worker";
+import { WranglerJson } from "./wrangler.json";
+
+export interface WebsiteProps<B extends Bindings>
+  extends Omit<WorkerProps<B>, "name" | "assets"> {
+  /**
+   * The command to run to build the site
+   */
+  command: string;
+  /**
+   * The name of the worker
+   *
+   * @default id
+   */
+  name?: string;
+  /**
+   * The entrypoint to your server
+   *
+   * @default - a simple server that serves static assets is generated
+   */
+  main?: string;
+  /**
+   * The directory containing your static assets
+   *
+   * @default "./dist"
+   */
+  assets?:
+    | string
+    | ({
+        dist?: string;
+      } & AssetsConfig);
+  /**
+   * @default process.cwd()
+   */
+  cwd?: string;
+
+  /**
+   * Write a wrangler.jsonc file
+   *
+   * @default - no wrangler.jsonc file is written
+   */
+  wrangler?: boolean | string;
+}
+
+export type Website<B extends Bindings> = B extends { ASSETS: any }
+  ? never
+  : Worker<B & { ASSETS: Assets }>;
+
+export async function Website<B extends Bindings>(
+  id: string,
+  props: WebsiteProps<B>
+): Promise<Website<B>> {
+  if (props.bindings?.ASSETS) {
+    throw new Error("ASSETS binding is reserved for internal use");
+  }
+
+  return alchemy.run(id, async () => {
+    // building the site requires a wrangler.jsonc file to start
+    // - so initialize an empty one if it doesn't exist
+
+    const cwd = path.resolve(props.cwd || process.cwd());
+    const fileName =
+      typeof props.wrangler === "boolean" ? "wrangler.jsonc" : props.wrangler;
+    const wranglerPath =
+      fileName && path.relative(cwd, path.join(cwd, fileName));
+
+    if (props.wrangler) {
+      try {
+        await fs.access(wranglerPath!);
+      } catch {
+        await fs.writeFile(
+          wranglerPath!,
+          JSON.stringify(
+            {
+              name: id,
+              main: props.main,
+              compatibility_date: new Date().toISOString().split("T")[0],
+            },
+            null,
+            2
+          )
+        );
+      }
+    }
+
+    await Exec("build", {
+      command: props.command,
+    });
+
+    const dist =
+      typeof props.assets === "string"
+        ? props.assets
+        : (props.assets?.dist ?? "dist");
+
+    const staticAssets = await Assets("assets", {
+      path: dist,
+    });
+
+    const worker = await Worker("worker", {
+      ...props,
+      name: props.name ?? id,
+      entrypoint: props.main,
+      assets: {
+        html_handling: "auto-trailing-slash",
+        not_found_handling: "single-page-application",
+        run_worker_first: false,
+        ...(typeof props.assets === "string" ? {} : props.assets),
+      },
+      script: props.main
+        ? undefined
+        : `
+export default {
+async fetch(request, env) {
+  return new Response("Not Found", { status: 404 });
+},
+};`,
+      url: true,
+      adopt: true,
+      bindings: {
+        ...props.bindings,
+        ASSETS: staticAssets,
+      },
+    });
+
+    if (props.wrangler) {
+      await WranglerJson("wrangler.jsonc", {
+        path: wranglerPath,
+        worker,
+      });
+    }
+
+    return worker as Website<B>;
+  });
+}

package/src/cloudflare/worker.ts

@@ -19,6 +19,50 @@ import type { WorkerScriptMetadata } from "./worker-metadata";
 import type { SingleStepMigration } from "./worker-migration";
 import { upsertWorkflow, type Workflow } from "./workflow";
 
+/**
+ * Configuration options for static assets
+ */
+export interface AssetsConfig {
+  /**
+   * The contents of a _headers file (used to attach custom headers on asset responses)
+   */
+  _headers?: string;
+
+  /**
+   * The contents of a _redirects file (used to apply redirects or proxy paths ahead of asset serving)
+   */
+  _redirects?: string;
+
+  /**
+   * Determines the redirects and rewrites of requests for HTML content
+   * @default "auto-trailing-slash"
+   */
+  html_handling?:
+    | "auto-trailing-slash"
+    | "force-trailing-slash"
+    | "drop-trailing-slash"
+    | "none";
+
+  /**
+   * Determines the response when a request does not match a static asset, and there is no Worker script
+   */
+  not_found_handling?: "none" | "404-page" | "single-page-application";
+
+  /**
+   * When true, requests will always invoke the Worker script.
+   * Otherwise, attempt to serve an asset matching the request, falling back to the Worker script.
+   */
+  run_worker_first?: boolean;
+
+  /**
+   * When true and the incoming request matches an asset, that will be served instead of invoking the Worker script.
+   * When false, requests will always invoke the Worker script.
+   * @default true
+   * @deprecated
+   */
+  serve_directly?: boolean;
+}
+
 /**
  * Properties for creating or updating a Worker
  */
@@ -110,6 +154,11 @@ export interface WorkerProps<B extends Bindings = Bindings>
    * The compatibility flags for the worker
    */
   compatibilityFlags?: string[];
+
+  /**
+   * Configuration for static assets
+   */
+  assets?: AssetsConfig;
 }
 
 /**
@@ -146,6 +195,11 @@ export interface Worker<B extends Bindings = Bindings>
    */
   bindings: B | undefined;
 
+  /**
+   * Configuration for static assets
+   */
+  assets?: AssetsConfig;
+
   // phantom property (for typeof myWorker.Env)
   Env: {
     [bindingName in keyof B]: Bound<B[bindingName]>;
@@ -291,7 +345,8 @@ export const Worker = Resource(
       assetUploadResult = await uploadAssets(
         api,
         workerName,
-        assetBinding.assets
+        assetBinding.assets,
+        props.assets
       );
     }
 
@@ -342,6 +397,8 @@ export const Worker = Resource(
       createdAt: now,
       updatedAt: now,
       url: workerUrl,
+      // Include assets configuration in the output
+      assets: props.assets,
       // phantom property
       Env: undefined!,
     });
@@ -480,19 +537,50 @@ interface WorkerMetadata {
   assets?: {
     jwt?: string;
     keep_assets?: boolean;
-    config?: {
-      html_handling?: "auto-trailing-slash" | "none";
-      not_found_handling?: "none" | "fall-through";
-    };
+    config?: AssetsConfig;
   };
 }
 
 interface AssetUploadResult {
   completionToken: string;
-  assetConfig?: {
-    html_handling?: "auto-trailing-slash" | "none";
-    not_found_handling?: "none" | "fall-through";
+  assetConfig?: AssetsConfig;
+}
+
+/**
+ * Creates asset configuration object from provided config or defaults
+ */
+function createAssetConfig(config?: AssetsConfig): AssetsConfig {
+  const assetConfig: AssetsConfig = {
+    html_handling: "auto-trailing-slash",
   };
+
+  if (config) {
+    if (config._headers !== undefined) {
+      assetConfig._headers = config._headers;
+    }
+
+    if (config._redirects !== undefined) {
+      assetConfig._redirects = config._redirects;
+    }
+
+    if (config.html_handling !== undefined) {
+      assetConfig.html_handling = config.html_handling;
+    }
+
+    if (config.not_found_handling !== undefined) {
+      assetConfig.not_found_handling = config.not_found_handling;
+    }
+
+    if (config.run_worker_first !== undefined) {
+      assetConfig.run_worker_first = config.run_worker_first;
+    }
+
+    if (config.serve_directly !== undefined) {
+      assetConfig.serve_directly = config.serve_directly;
+    }
+  }
+
+  return assetConfig;
 }
 
 async function prepareWorkerMetadata<B extends Bindings>(
@@ -526,8 +614,17 @@ async function prepareWorkerMetadata<B extends Bindings>(
       jwt: assetUploadResult.completionToken,
     };
 
+    // Initialize config from assetUploadResult if it exists
     if (assetUploadResult.assetConfig) {
-      meta.assets.config = assetUploadResult.assetConfig;
+      meta.assets.config = {
+        ...assetUploadResult.assetConfig,
+      };
+    }
+
+    // If there's no config from assetUploadResult but we have props.assets,
+    // we need to create the config ourselves (this handles the case when no assets were uploaded)
+    if (!meta.assets.config && props.assets) {
+      meta.assets.config = createAssetConfig(props.assets);
     }
   }
 
@@ -910,13 +1007,18 @@ interface UploadResponse {
  * @param api CloudflareApi instance
  * @param workerName Name of the worker
  * @param assets Assets resource containing files to upload
+ * @param assetConfig Configuration for the assets
  * @returns Completion token for the assets upload
  */
 async function uploadAssets(
   api: CloudflareApi,
   workerName: string,
-  assets: Assets
+  assets: Assets,
+  assetConfig?: WorkerProps["assets"]
 ): Promise<AssetUploadResult> {
+  // Process the assets configuration once at the beginning
+  const processedConfig = createAssetConfig(assetConfig);
+
   // Generate the file manifest
   const fileMetadata: Record<string, FileMetadata> = {};
 
@@ -949,7 +1051,10 @@ async function uploadAssets(
 
   // If there are no buckets, assets are already uploaded or empty
   if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
-    return { completionToken: sessionData.result.jwt };
+    return {
+      completionToken: sessionData.result.jwt,
+      assetConfig: processedConfig,
+    };
   }
 
   // Upload the files in batches as specified by the API
@@ -1013,12 +1118,10 @@ async function uploadAssets(
     }
   }
 
-  // Return the final completion token
+  // Return the final completion token with asset configuration
   return {
     completionToken,
-    assetConfig: {
-      html_handling: "auto-trailing-slash",
-    },
+    assetConfig: processedConfig,
   };
 }
 

package/src/env.ts

@@ -0,0 +1,31 @@
+export interface Env {
+  [key: string]: Promise<string>;
+  <T = string>(name: string, value?: T | undefined, error?: string): Promise<T>;
+}
+
+export const env = new Proxy(_env, {
+  get: (_, name: string) => _env(name),
+  apply: (_, __, args: [string, any?, string?]) => _env(...args),
+}) as Env;
+
+async function _env<T = string>(
+  name: string,
+  value?: T | undefined,
+  error?: string
+): Promise<T> {
+  if (value !== undefined) {
+    return value;
+  } else if (typeof process !== undefined) {
+    // we are in a node environment
+    return process.env[name]! as T;
+  } else {
+    // we are in a browser environment
+    try {
+      const { env } = await import("cloudflare:workers");
+      if (name in env) {
+        return env[name as keyof typeof env];
+      }
+    } catch (error) {}
+  }
+  throw new Error(error ?? `Environment variable ${name} is not set`);
+}

package/src/internal/docs/providers.ts

@@ -118,7 +118,7 @@ async function generateProviderDocs({
         reasoningEffort: "high",
       },
     },
-    freeze: true,
+    freeze: false,
     temperature: 0.1,
     schema: type({
       groups: type({
@@ -178,7 +178,7 @@ async function generateProviderDocs({
         providerDocsDir,
         `${g.filename.replace(".ts", "").replace(".md", "")}.md`
       ),
-      freeze: true,
+      freeze: false,
       model: {
         id: "claude-3-5-sonnet-latest",
         provider: "anthropic",

package/src/secret.ts

@@ -1,3 +1,5 @@
+import { alchemy } from "./alchemy";
+
 /**
  * Internal wrapper for sensitive values like API keys and credentials.
  * When stored in alchemy state files, the value is automatically encrypted
@@ -85,12 +87,21 @@ export function secret<S extends string | undefined>(unencrypted: S): Secret {
 }
 
 export namespace secret {
-  export async function env(
+  export interface Env {
+    [key: string]: Promise<Secret>;
+    (name: string, value?: string, error?: string): Promise<Secret>;
+  }
+
+  export const env = new Proxy(_env, {
+    get: (_, name: string) => _env(name),
+    apply: (_, __, args: [string, any?, string?]) => _env(...args),
+  }) as Env;
+
+  async function _env(
     name: string,
     value?: string,
     error?: string
   ): Promise<Secret> {
-    const alchemy = await import("./alchemy");
     const result = await alchemy.env(name, value, error);
     if (typeof result === "string") {
       return secret(result);

package/src/web/vitepress/process-front-matter-files.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+
 /**
  * Process markdown files with frontmatter to generate navigation items
  * @param directoryPath The directory containing markdown files

package/lib/cloudflare/vite-site.js

@@ -1,57 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { alchemy } from "../alchemy";
-import { Exec } from "../os";
-import { Assets } from "./assets";
-import { Worker } from "./worker";
-import { WranglerJson } from "./wrangler.json";
-export async function ViteSite(id, props) {
-    if (props.bindings?.ASSETS) {
-        throw new Error("ASSETS binding is reserved for internal use");
-    }
-    // @ts-ignore - we know the types are correct
-    return await alchemy.run(id, async () => {
-        // Create minimal wrangler.jsonc if it doesn't exist
-        // `building the site requires a wrangler.jsonc file to start - so initialize an empty one if it doesn't exist`
-        const cwd = props.cwd || process.cwd();
-        const wranglerPath = path.join(cwd, "wrangler.jsonc");
-        try {
-            await fs.access(wranglerPath);
-        }
-        catch {
-            await fs.writeFile(wranglerPath, JSON.stringify({
-                name: id,
-                main: props.main,
-                compatibility_date: new Date().toISOString().split("T")[0],
-            }, null, 2));
-        }
-        await Exec("build", {
-            command: props.command,
-        });
-        const staticAssets = await Assets("assets", {
-            path: props.assets ?? "./dist",
-        });
-        const worker = await Worker("worker", {
-            name: props.name ?? id,
-            entrypoint: props.main,
-            script: props.main
-                ? undefined
-                : `
-export default {
-  async fetch(request, env) {
-    return env.ASSETS.fetch(request);
-  },
-};`,
-            url: true,
-            adopt: true,
-            bindings: {
-                ...props.bindings,
-                ASSETS: staticAssets,
-            },
-        });
-        await WranglerJson("wrangler.jsonc", {
-            worker,
-        });
-        return worker;
-    });
-}

package/src/cloudflare/vite-site.ts

@@ -1,113 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { alchemy } from "../alchemy";
-import { Exec } from "../os";
-import { Assets } from "./assets";
-import type { Bindings } from "./bindings";
-import { Worker } from "./worker";
-import { WranglerJson } from "./wrangler.json";
-
-export interface ViteSiteProps<B extends Bindings> {
-  /**
-   * The command to run to build the site
-   */
-  command: string;
-  /**
-   * The name of the worker
-   *
-   * @default id
-   */
-  name?: string;
-  /**
-   * The entrypoint to your server
-   *
-   * @default - a simple server that serves static assets is generated
-   */
-  main?: string;
-  /**
-   * The directory containing your static assets
-   *
-   * @default "./dist"
-   */
-  assets?: string;
-  /**
-   * The bindings to pass to the worker
-   */
-  bindings?: B;
-  /**
-   * @default process.cwd()
-   */
-  cwd?: string;
-}
-
-export type ViteSite<B extends Bindings> = Promise<
-  // don't allow the ASSETS to be overriden
-  B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }>
->;
-
-export async function ViteSite<B extends Bindings>(
-  id: string,
-  props: ViteSiteProps<B>
-): ViteSite<B> {
-  if (props.bindings?.ASSETS) {
-    throw new Error("ASSETS binding is reserved for internal use");
-  }
-
-  // @ts-ignore - we know the types are correct
-  return await alchemy.run(id, async () => {
-    // Create minimal wrangler.jsonc if it doesn't exist
-
-    // `building the site requires a wrangler.jsonc file to start - so initialize an empty one if it doesn't exist`
-    const cwd = props.cwd || process.cwd();
-    const wranglerPath = path.join(cwd, "wrangler.jsonc");
-    try {
-      await fs.access(wranglerPath);
-    } catch {
-      await fs.writeFile(
-        wranglerPath,
-        JSON.stringify(
-          {
-            name: id,
-            main: props.main,
-            compatibility_date: new Date().toISOString().split("T")[0],
-          },
-          null,
-          2
-        )
-      );
-    }
-
-    await Exec("build", {
-      command: props.command,
-    });
-
-    const staticAssets = await Assets("assets", {
-      path: props.assets ?? "./dist",
-    });
-
-    const worker = await Worker("worker", {
-      name: props.name ?? id,
-      entrypoint: props.main,
-      script: props.main
-        ? undefined
-        : `
-export default {
-  async fetch(request, env) {
-    return env.ASSETS.fetch(request);
-  },
-};`,
-      url: true,
-      adopt: true,
-      bindings: {
-        ...props.bindings,
-        ASSETS: staticAssets,
-      },
-    });
-
-    await WranglerJson("wrangler.jsonc", {
-      worker,
-    });
-
-    return worker;
-  });
-}