alchemy 0.11.4 → 0.12.1

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,
+        main: props?.main ?? ".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" | "entrypoint"> {
     /**
      * 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/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.4",
+  "version": "0.12.1",
   "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,
+    main: props?.main ?? ".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" | "entrypoint"> {
+  /**
+   * 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/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,71 +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 ??
-                (await (async () => {
-                    try {
-                        await fs.access(path.join("dist", "client", "index.html"));
-                        return path.join(".", "dist", "client");
-                    }
-                    catch {
-                        return path.join(".", "dist");
-                    }
-                })()),
-        });
-        const worker = await Worker("worker", {
-            name: props.name ?? id,
-            entrypoint: props.main,
-            assets: {
-                html_handling: "auto-trailing-slash",
-                not_found_handling: "single-page-application",
-                run_worker_first: false,
-            },
-            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,
-            },
-        });
-        await WranglerJson("wrangler.jsonc", {
-            worker,
-        });
-        return worker;
-    });
-}

package/src/cloudflare/vite-site.ts

@@ -1,126 +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 ??
-        (await (async () => {
-          try {
-            await fs.access(path.join("dist", "client", "index.html"));
-            return path.join(".", "dist", "client");
-          } catch {
-            return path.join(".", "dist");
-          }
-        })()),
-    });
-    const worker = await Worker("worker", {
-      name: props.name ?? id,
-      entrypoint: props.main,
-      assets: {
-        html_handling: "auto-trailing-slash",
-        not_found_handling: "single-page-application",
-        run_worker_first: false,
-      },
-      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,
-      },
-    });
-
-    await WranglerJson("wrangler.jsonc", {
-      worker,
-    });
-
-    return worker;
-  });
-}