alchemy 2.0.0-beta.cli-platform-split → 2.0.0-beta.pkg-setup-rc

package/lib/Cloudflare/Website/StaticSite.d.ts

@@ -0,0 +1,79 @@
+import * as Effect from "effect/Effect";
+import { Command, type CommandProps } from "../../Build/Command.ts";
+import type { InputProps } from "../../Input.ts";
+import type { AssetsConfig } from "../Workers/Assets.ts";
+import { Worker, type WorkerAssetsConfig, type WorkerBindingProps, type WorkerProps } from "../Workers/Worker.ts";
+export interface StaticSiteProps<Bindings extends WorkerBindingProps = {}> extends Omit<WorkerProps<Bindings, WorkerAssetsConfig>, "assets">, Omit<CommandProps, "env"> {
+    /**
+     * Optional configuration for static asset routing behavior.
+     * Supports `runWorkerFirst`, `htmlHandling`, `notFoundHandling`, etc.
+     */
+    assetsConfig?: AssetsConfig;
+    dev?: {
+        command: string;
+    };
+}
+export type StaticSite = ReturnType<typeof StaticSite>;
+/**
+ * A Cloudflare Worker that serves static assets built by a shell command.
+ *
+ * `StaticSite` runs a build command (e.g. `npm run build`), content-hashes
+ * the output directory, and deploys the result as a Cloudflare Worker with
+ * static assets. Use this when your site has its own build step that
+ * produces a directory of files — Hugo, Zola, Eleventy, or any custom
+ * pipeline.
+ *
+ * For Vite-based projects, prefer `Cloudflare.Vite` which handles
+ * building automatically.
+ *
+ * @resource
+ *
+ * @section Basic Usage
+ * Point `command` at your build script and `outdir` at where it writes
+ * output. Alchemy runs the command, hashes the output, and deploys it.
+ *
+ * @example Deploying a Hugo site
+ * ```typescript
+ * const site = yield* Cloudflare.StaticSite("Blog", {
+ *   command: "hugo --minify",
+ *   outdir: "public",
+ * });
+ * ```
+ *
+ * @section Asset Configuration
+ * Use `assetsConfig` to control how Cloudflare handles routing for
+ * your static files — HTML handling, not-found behavior, etc.
+ *
+ * @example SPA-style routing
+ * ```typescript
+ * const site = yield* Cloudflare.StaticSite("App", {
+ *   command: "npm run build",
+ *   outdir: "dist",
+ *   assetsConfig: {
+ *     htmlHandling: "auto-trailing-slash",
+ *     notFoundHandling: "single-page-application",
+ *   },
+ * });
+ * ```
+ *
+ * @section Custom Rebuild Scope
+ * By default, all non-gitignored files are hashed to decide whether
+ * the build should re-run. Use `memo` to narrow the scope.
+ *
+ * @example Narrowing the memo scope
+ * ```typescript
+ * const site = yield* Cloudflare.StaticSite("Docs", {
+ *   command: "npm run build",
+ *   outdir: "dist",
+ *   memo: {
+ *     include: ["content/**", "templates/**", "config.toml"],
+ *   },
+ * });
+ * ```
+ */
+export declare const StaticSite: <const Bindings extends WorkerBindingProps = {}, Req = never>(id: string, propsEff: InputProps<StaticSiteProps<Bindings>> | Effect.Effect<InputProps<StaticSiteProps<Bindings>>, never, Req>) => Effect.Effect<Worker<{ [binding in keyof ({ [B in keyof Bindings]: Bindings[B] extends Effect.Effect<infer T extends import("../index.ts").WorkerBindingResource, any, any> ? T : Extract<Bindings[B], import("../index.ts").WorkerBindingResource>; } & {
+    ASSETS: import("../index.ts").Assets;
+})]: ({ [B in keyof Bindings]: Bindings[B] extends Effect.Effect<infer T extends import("../index.ts").WorkerBindingResource, any, any> ? T : Extract<Bindings[B], import("../index.ts").WorkerBindingResource>; } & {
+    ASSETS: import("../index.ts").Assets;
+})[binding]; }>, never, import("../../Provider.ts").Provider<Command> | import("../Providers.ts").Providers | Req>;
+//# sourceMappingURL=StaticSite.d.ts.map

package/lib/Cloudflare/Website/StaticSite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaticSite.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Website/StaticSite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EACL,MAAM,EACN,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,eAAe,CAAC,QAAQ,SAAS,kBAAkB,GAAG,EAAE,CACvE,SACE,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,EAAE,QAAQ,CAAC,EACzD,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,GAAG,CAAC,EAAE;QACJ,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,eAAO,MAAM,UAAU,GACrB,KAAK,CAAC,QAAQ,SAAS,kBAAkB,GAAG,EAAE,EAC9C,GAAG,GAAG,KAAK,EAEX,IAAI,MAAM,EACV,UACI,UAAU,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,GACrC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC;;;;kHA8BzC,CAAC"}

package/lib/Cloudflare/Website/StaticSite.js

@@ -0,0 +1,83 @@
+import * as Effect from "effect/Effect";
+import { Command } from "../../Build/Command.js";
+import * as Namespace from "../../Namespace.js";
+import { Worker, } from "../Workers/Worker.js";
+/**
+ * A Cloudflare Worker that serves static assets built by a shell command.
+ *
+ * `StaticSite` runs a build command (e.g. `npm run build`), content-hashes
+ * the output directory, and deploys the result as a Cloudflare Worker with
+ * static assets. Use this when your site has its own build step that
+ * produces a directory of files — Hugo, Zola, Eleventy, or any custom
+ * pipeline.
+ *
+ * For Vite-based projects, prefer `Cloudflare.Vite` which handles
+ * building automatically.
+ *
+ * @resource
+ *
+ * @section Basic Usage
+ * Point `command` at your build script and `outdir` at where it writes
+ * output. Alchemy runs the command, hashes the output, and deploys it.
+ *
+ * @example Deploying a Hugo site
+ * ```typescript
+ * const site = yield* Cloudflare.StaticSite("Blog", {
+ *   command: "hugo --minify",
+ *   outdir: "public",
+ * });
+ * ```
+ *
+ * @section Asset Configuration
+ * Use `assetsConfig` to control how Cloudflare handles routing for
+ * your static files — HTML handling, not-found behavior, etc.
+ *
+ * @example SPA-style routing
+ * ```typescript
+ * const site = yield* Cloudflare.StaticSite("App", {
+ *   command: "npm run build",
+ *   outdir: "dist",
+ *   assetsConfig: {
+ *     htmlHandling: "auto-trailing-slash",
+ *     notFoundHandling: "single-page-application",
+ *   },
+ * });
+ * ```
+ *
+ * @section Custom Rebuild Scope
+ * By default, all non-gitignored files are hashed to decide whether
+ * the build should re-run. Use `memo` to narrow the scope.
+ *
+ * @example Narrowing the memo scope
+ * ```typescript
+ * const site = yield* Cloudflare.StaticSite("Docs", {
+ *   command: "npm run build",
+ *   outdir: "dist",
+ *   memo: {
+ *     include: ["content/**", "templates/**", "config.toml"],
+ *   },
+ * });
+ * ```
+ */
+export const StaticSite = (id, propsEff) => Effect.gen(function* () {
+    const props = Effect.isEffect(propsEff)
+        ? propsEff
+        : Effect.succeed(propsEff);
+    // TODO(sam): local dev/hmr support?
+    const build = yield* Command("Build", Effect.map(props, (props) => ({
+        command: props.command,
+        cwd: props.cwd,
+        memo: props.memo,
+        outdir: props.outdir,
+        env: props.env,
+    })));
+    return yield* Worker("Worker", Effect.map(props, (props) => ({
+        ...props,
+        assets: {
+            path: build.outdir,
+            hash: build.hash,
+            config: props.assetsConfig,
+        },
+    })));
+}).pipe(Namespace.push(id));
+//# sourceMappingURL=StaticSite.js.map

package/lib/Cloudflare/Website/StaticSite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaticSite.js","sourceRoot":"","sources":["../../../src/Cloudflare/Website/StaticSite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,OAAO,EAAqB,MAAM,wBAAwB,CAAC;AAEpE,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAC;AAEhD,OAAO,EACL,MAAM,GAIP,MAAM,sBAAsB,CAAC;AAkB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAIxB,EAAU,EACV,QAEoE,EACpE,EAAE,CACF,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACrC,CAAC,CAAC,QAAQ;QACV,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE7B,oCAAoC;IACpC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,OAAO,CAC1B,OAAO,EACP,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC5B,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,GAAG,EAAE,KAAK,CAAC,GAAG;KACf,CAAC,CAAC,CACJ,CAAC;IAEF,OAAO,KAAK,CAAC,CAAC,MAAM,CAClB,QAAQ,EACR,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC5B,GAAG,KAAK;QACR,MAAM,EAAE;YACN,IAAI,EAAE,KAAK,CAAC,MAAM;YAClB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,MAAM,EAAE,KAAK,CAAC,YAAY;SAC3B;KACF,CAAC,CAAC,CACJ,CAAC;AACJ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/lib/Cloudflare/Website/Vite.d.ts

@@ -0,0 +1,106 @@
+import * as Effect from "effect/Effect";
+import type { MemoOptions } from "../../Build/Memo.ts";
+import type { InputProps } from "../../Input.ts";
+import { Worker, type WorkerBindingProps, type WorkerProps } from "../Workers/Worker.ts";
+export interface ViteProps<Bindings extends WorkerBindingProps = {}> extends Omit<WorkerProps<Bindings>, "vite" | "main"> {
+    /**
+     * Root directory passed to Vite's `root` option.
+     * Defaults to the current working directory (`process.cwd()`).
+     */
+    rootDir?: string;
+    /**
+     * Controls which files are hashed to decide whether a rebuild is needed.
+     * By default every non-gitignored file in `cwd` is hashed, plus the nearest
+     * lockfile. Provide explicit globs to narrow the scope.
+     *
+     * @see {@link MemoOptions}
+     */
+    memo?: MemoOptions;
+}
+/**
+ * A Cloudflare Worker deployed from a Vite project.
+ *
+ * `Vite` uses the Cloudflare Vite plugin to build both the server bundle
+ * and client assets in a single `vite build` invocation — no manual
+ * `main` entrypoint, build command, output directory, or Wrangler
+ * configuration required.
+ *
+ * Input files are content-hashed (respecting `.gitignore` by default) so
+ * unchanged projects skip the build and deploy entirely.
+ *
+ * @resource
+ *
+ * @section Deploying a Static Site
+ * For a pure static site (no SSR), a single call is all you need.
+ * Vite builds the project and Alchemy deploys the output as a
+ * Cloudflare Worker with static assets.
+ *
+ * @example Static Vite site
+ * ```typescript
+ * const site = yield* Cloudflare.Vite("Website");
+ * ```
+ *
+ * @section SSR Frameworks
+ * For SSR frameworks like TanStack Start, SolidStart, or Nuxt, enable
+ * `nodejs_compat` so the server bundle can use Node.js APIs.
+ *
+ * @example TanStack Start
+ * ```typescript
+ * const app = yield* Cloudflare.Vite("TanStackStart", {
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *   },
+ * });
+ * ```
+ *
+ * @example SolidStart with worker-first routing
+ * ```typescript
+ * const app = yield* Cloudflare.Vite("SolidStart", {
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *   },
+ *   assets: {
+ *     config: { runWorkerFirst: true },
+ *   },
+ * });
+ * ```
+ *
+ * @section Single-Page Applications
+ * For SPAs (React, Vue, etc.), configure asset handling so all
+ * routes fall back to `index.html`.
+ *
+ * @example Vue SPA
+ * ```typescript
+ * const app = yield* Cloudflare.Vite("Vue", {
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *   },
+ *   assets: {
+ *     config: {
+ *       htmlHandling: "auto-trailing-slash",
+ *       notFoundHandling: "single-page-application",
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @section Custom Rebuild Scope
+ * By default, every non-gitignored file is hashed to decide whether
+ * a rebuild is needed. Use `memo` to narrow the scope when your
+ * project has large directories that don't affect the build output.
+ *
+ * @example Narrowing the memo scope
+ * ```typescript
+ * const site = yield* Cloudflare.Vite("Docs", {
+ *   memo: {
+ *     include: ["src/**", "content/**", "package.json"],
+ *   },
+ * });
+ * ```
+ */
+export declare const Vite: <const Bindings extends WorkerBindingProps = {}, Req = never>(id: string, propsEff?: InputProps<ViteProps<Bindings>> | Effect.Effect<InputProps<ViteProps<Bindings>>, never, Req>) => Effect.Effect<Worker<{ [binding in keyof ({ [B in keyof Bindings]: Bindings[B] extends Effect.Effect<infer T extends import("../index.ts").WorkerBindingResource, any, any> ? T : Extract<Bindings[B], import("../index.ts").WorkerBindingResource>; } & {
+    ASSETS: import("../index.ts").Assets;
+})]: ({ [B in keyof Bindings]: Bindings[B] extends Effect.Effect<infer T extends import("../index.ts").WorkerBindingResource, any, any> ? T : Extract<Bindings[B], import("../index.ts").WorkerBindingResource>; } & {
+    ASSETS: import("../index.ts").Assets;
+})[binding]; }>, never, import("../Providers.ts").Providers | Req>;
+//# sourceMappingURL=Vite.d.ts.map

package/lib/Cloudflare/Website/Vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vite.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Website/Vite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EACL,MAAM,EAEN,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,SAAS,CACxB,QAAQ,SAAS,kBAAkB,GAAG,EAAE,CACxC,SAAQ,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACpD;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,CAAC,QAAQ,SAAS,kBAAkB,GAAG,EAAE,EAC9C,GAAG,GAAG,KAAK,EAEX,IAAI,MAAM,EACV,WACI,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,GAC/B,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC;;;;kEAe7D,CAAC"}

package/lib/Cloudflare/Website/Vite.js

@@ -0,0 +1,92 @@
+import * as Effect from "effect/Effect";
+import { Worker, } from "../Workers/Worker.js";
+/**
+ * A Cloudflare Worker deployed from a Vite project.
+ *
+ * `Vite` uses the Cloudflare Vite plugin to build both the server bundle
+ * and client assets in a single `vite build` invocation — no manual
+ * `main` entrypoint, build command, output directory, or Wrangler
+ * configuration required.
+ *
+ * Input files are content-hashed (respecting `.gitignore` by default) so
+ * unchanged projects skip the build and deploy entirely.
+ *
+ * @resource
+ *
+ * @section Deploying a Static Site
+ * For a pure static site (no SSR), a single call is all you need.
+ * Vite builds the project and Alchemy deploys the output as a
+ * Cloudflare Worker with static assets.
+ *
+ * @example Static Vite site
+ * ```typescript
+ * const site = yield* Cloudflare.Vite("Website");
+ * ```
+ *
+ * @section SSR Frameworks
+ * For SSR frameworks like TanStack Start, SolidStart, or Nuxt, enable
+ * `nodejs_compat` so the server bundle can use Node.js APIs.
+ *
+ * @example TanStack Start
+ * ```typescript
+ * const app = yield* Cloudflare.Vite("TanStackStart", {
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *   },
+ * });
+ * ```
+ *
+ * @example SolidStart with worker-first routing
+ * ```typescript
+ * const app = yield* Cloudflare.Vite("SolidStart", {
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *   },
+ *   assets: {
+ *     config: { runWorkerFirst: true },
+ *   },
+ * });
+ * ```
+ *
+ * @section Single-Page Applications
+ * For SPAs (React, Vue, etc.), configure asset handling so all
+ * routes fall back to `index.html`.
+ *
+ * @example Vue SPA
+ * ```typescript
+ * const app = yield* Cloudflare.Vite("Vue", {
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *   },
+ *   assets: {
+ *     config: {
+ *       htmlHandling: "auto-trailing-slash",
+ *       notFoundHandling: "single-page-application",
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @section Custom Rebuild Scope
+ * By default, every non-gitignored file is hashed to decide whether
+ * a rebuild is needed. Use `memo` to narrow the scope when your
+ * project has large directories that don't affect the build output.
+ *
+ * @example Narrowing the memo scope
+ * ```typescript
+ * const site = yield* Cloudflare.Vite("Docs", {
+ *   memo: {
+ *     include: ["src/**", "content/**", "package.json"],
+ *   },
+ * });
+ * ```
+ */
+export const Vite = (id, propsEff) => Worker(id, Effect.map(Effect.isEffect(propsEff) ? propsEff : Effect.succeed(propsEff), (props) => ({
+    ...props,
+    main: undefined,
+    vite: {
+        rootDir: props?.rootDir,
+        memo: props?.memo,
+    },
+})));
+//# sourceMappingURL=Vite.js.map

package/lib/Cloudflare/Website/Vite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vite.js","sourceRoot":"","sources":["../../../src/Cloudflare/Website/Vite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EACL,MAAM,GAIP,MAAM,sBAAsB,CAAC;AAoB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAIlB,EAAU,EACV,QAE8D,EAC9D,EAAE,CACF,MAAM,CACJ,EAAE,EACF,MAAM,CAAC,GAAG,CACR,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC/D,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACV,GAAG,KAAK;IACR,IAAI,EAAE,SAAU;IAChB,IAAI,EAAE;QACJ,OAAO,EAAE,KAAK,EAAE,OAAO;QACvB,IAAI,EAAE,KAAK,EAAE,IAAI;KAClB;CACF,CAAC,CACH,CACF,CAAC"}

package/lib/Cloudflare/Website/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./StaticSite.ts";
+export * from "./Vite.ts";
+//# sourceMappingURL=index.d.ts.map

package/lib/Cloudflare/Website/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Website/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC"}

package/lib/Cloudflare/Website/index.js

@@ -0,0 +1,3 @@
+export * from "./StaticSite.js";
+export * from "./Vite.js";
+//# sourceMappingURL=index.js.map

package/lib/Cloudflare/Website/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Cloudflare/Website/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC"}

package/lib/Cloudflare/Workers/Assets.d.ts

@@ -0,0 +1,81 @@
+import * as workers from "@distilled.cloud/cloudflare/workers";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type { PlatformError } from "effect/PlatformError";
+import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
+export interface Assets {
+    kind: "Cloudflare.Workers.Assets";
+}
+export declare const isAssets: (value: any) => value is Assets;
+export interface AssetsConfig extends Exclude<Exclude<workers.PutScriptRequest["metadata"]["assets"], undefined>["config"], undefined> {
+}
+export interface AssetReadResult {
+    directory: string;
+    config: AssetsConfig | undefined;
+    manifest: Record<string, {
+        hash: string;
+        size: number;
+    }>;
+    _headers: string | undefined;
+    _redirects: string | undefined;
+    hash: string;
+}
+export interface AssetsProps {
+    directory: string;
+    config?: AssetsConfig;
+}
+export type ValidationError = AssetTooLargeError | TooManyAssetsError | AssetNotFoundError | FailedToReadAssetError;
+declare const AssetTooLargeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AssetTooLargeError";
+} & Readonly<A>;
+export declare class AssetTooLargeError extends AssetTooLargeError_base<{
+    message: string;
+    name: string;
+    size: number;
+}> {
+}
+declare const TooManyAssetsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TooManyAssetsError";
+} & Readonly<A>;
+export declare class TooManyAssetsError extends TooManyAssetsError_base<{
+    message: string;
+    directory: string;
+    count: number;
+}> {
+}
+declare const AssetNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AssetNotFoundError";
+} & Readonly<A>;
+export declare class AssetNotFoundError extends AssetNotFoundError_base<{
+    message: string;
+    hash: string;
+}> {
+}
+declare const FailedToReadAssetError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FailedToReadAssetError";
+} & Readonly<A>;
+export declare class FailedToReadAssetError extends FailedToReadAssetError_base<{
+    message: string;
+    name: string;
+    cause: PlatformError;
+}> {
+}
+export declare const readAssets: (props: AssetsProps) => Effect.Effect<{
+    hash: string;
+    directory: string;
+    config: AssetsConfig | undefined;
+    manifest: {
+        [k: string]: {
+            hash: string;
+            size: number;
+        };
+    };
+    _headers: string | undefined;
+    _redirects: string | undefined;
+}, PlatformError | AssetTooLargeError | TooManyAssetsError, FileSystem.FileSystem | Path.Path>;
+export declare const uploadAssets: (accountId: string, workerName: string, assets: AssetReadResult, args_3: ScopedPlanStatusSession) => Effect.Effect<{
+    jwt: string | undefined;
+}, import("@distilled.cloud/cloudflare").Unauthorized | import("@distilled.cloud/cloudflare").TooManyRequests | import("@distilled.cloud/cloudflare").InternalServerError | import("@distilled.cloud/cloudflare").BadGateway | import("@distilled.cloud/cloudflare").ServiceUnavailable | import("@distilled.cloud/cloudflare").GatewayTimeout | import("@distilled.cloud/cloudflare").CloudflareHttpError | import("@distilled.cloud/cloudflare").CloudflareParseError | import("@distilled.cloud/cloudflare").UnknownCloudflareError | workers.InvalidRoute | AssetNotFoundError | FailedToReadAssetError, FileSystem.FileSystem | Path.Path | import("effect/unstable/http/HttpClient").HttpClient | import("@distilled.cloud/cloudflare").Credentials>;
+export {};
+//# sourceMappingURL=Assets.d.ts.map

package/lib/Cloudflare/Workers/Assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Assets.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/Assets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qCAAqC,CAAC;AAE/D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAMhE,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,2BAA2B,CAAC;CACnC;AAED,eAAO,MAAM,QAAQ,GAAI,OAAO,GAAG,KAAG,KAAK,IAAI,MACF,CAAC;AAE9C,MAAM,WAAW,YAAa,SAAQ,OAAO,CAC3C,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,EAC5E,SAAS,CACV;CAAG;AAEJ,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED,MAAM,MAAM,eAAe,GACvB,kBAAkB,GAClB,kBAAkB,GAClB,kBAAkB,GAClB,sBAAsB,CAAC;;;;AAE3B,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;CAAG;;;;AAEL,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;CAAG;;;;AAEL,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;CAAG;;;;AAEL,qBAAa,sBAAuB,SAAQ,4BAE1C;IACA,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;CAAG;AAuCL,eAAO,MAAM,UAAU;;;;;;kBAmBoB,MAAM;kBAAQ,MAAM;;;;;8FAuD7D,CAAC;AAEH,eAAO,MAAM,YAAY;;0tBA6EvB,CAAC"}

package/lib/Cloudflare/Workers/Assets.js

@@ -0,0 +1,177 @@
+import * as workers from "@distilled.cloud/cloudflare/workers";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { sha256, sha256Object } from "../../Util/index.js";
+const MAX_ASSET_SIZE = 1024 * 1024 * 25; // 25MB
+const MAX_ASSET_COUNT = 20_000;
+export const isAssets = (value) => value?.kind === "Cloudflare.Workers.Assets";
+export class AssetTooLargeError extends Data.TaggedError("AssetTooLargeError") {
+}
+export class TooManyAssetsError extends Data.TaggedError("TooManyAssetsError") {
+}
+export class AssetNotFoundError extends Data.TaggedError("AssetNotFoundError") {
+}
+export class FailedToReadAssetError extends Data.TaggedError("FailedToReadAssetError") {
+}
+const getContentType = (name) => {
+    if (name.endsWith(".html"))
+        return "text/html";
+    if (name.endsWith(".txt"))
+        return "text/plain";
+    if (name.endsWith(".sql"))
+        return "text/sql";
+    if (name.endsWith(".json"))
+        return "application/json";
+    if (name.endsWith(".js") || name.endsWith(".mjs")) {
+        // Browsers only accept JavaScript module scripts when the MIME type is a
+        // "JavaScript MIME type" (e.g. text/javascript). application/javascript+module
+        // is not valid and causes strict module loading to fail.
+        return "text/javascript; charset=utf-8";
+    }
+    if (name.endsWith(".css"))
+        return "text/css";
+    if (name.endsWith(".wasm"))
+        return "application/wasm";
+    if (name.endsWith(".png"))
+        return "image/png";
+    if (name.endsWith(".svg"))
+        return "image/svg+xml";
+    if (name.endsWith(".ico"))
+        return "image/x-icon";
+    return "application/octet-stream";
+};
+const maybeReadString = Effect.fnUntraced(function* (file) {
+    const fs = yield* FileSystem.FileSystem;
+    return yield* fs.readFileString(file).pipe(Effect.catchIf((error) => error._tag === "PlatformError" && error.reason._tag === "NotFound", () => Effect.succeed(undefined)));
+});
+const createIgnoreMatcher = Effect.fnUntraced(function* (patterns) {
+    const matcher = yield* Effect.promise(() => import("ignore").then(({ default: ignore }) => ignore().add(patterns)));
+    return (file) => matcher.ignores(file);
+});
+export const readAssets = Effect.fnUntraced(function* (props) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const resolvedDirectory = path.resolve(props.directory);
+    const [files, ignore, _headers, _redirects] = yield* Effect.all([
+        fs.readDirectory(resolvedDirectory, { recursive: true }),
+        maybeReadString(path.join(resolvedDirectory, ".assetsignore")),
+        maybeReadString(path.join(resolvedDirectory, "_headers")),
+        maybeReadString(path.join(resolvedDirectory, "_redirects")),
+    ]);
+    const ignores = yield* createIgnoreMatcher([
+        ".assetsignore",
+        "_headers",
+        "_redirects",
+        ...(ignore
+            ?.split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("#")) ?? []),
+    ]);
+    const manifest = new Map();
+    let count = 0;
+    yield* Effect.forEach(files, Effect.fnUntraced(function* (name) {
+        if (ignores(name)) {
+            return;
+        }
+        const file = path.join(resolvedDirectory, name);
+        const stat = yield* fs.stat(file);
+        if (stat.type !== "File") {
+            return;
+        }
+        const size = Number(stat.size);
+        if (size > MAX_ASSET_SIZE) {
+            return yield* new AssetTooLargeError({
+                message: `Asset ${name} is too large (the maximum size is ${MAX_ASSET_SIZE / 1024 / 1024} MB; this asset is ${size / 1024 / 1024} MB)`,
+                name,
+                size,
+            });
+        }
+        const hash = yield* fs.readFile(file).pipe(Effect.flatMap(sha256), Effect.map((hash) => hash.slice(0, 32)));
+        count++;
+        if (count > MAX_ASSET_COUNT) {
+            return yield* new TooManyAssetsError({
+                message: `Too many assets (the maximum count is ${MAX_ASSET_COUNT}; this directory has ${count} assets)`,
+                directory: props.directory,
+                count,
+            });
+        }
+        manifest.set((name.startsWith("/") ? name : `/${name}`).replaceAll("\\", "/"), {
+            hash,
+            size,
+        });
+    }));
+    const result = {
+        directory: props.directory,
+        config: props.config,
+        manifest: Object.fromEntries(Array.from(manifest.entries()).sort((a, b) => a[0].localeCompare(b[0]))),
+        _headers,
+        _redirects,
+    };
+    return {
+        ...result,
+        hash: yield* sha256Object(result),
+    };
+});
+export const uploadAssets = Effect.fnUntraced(function* (accountId, workerName, assets, { note }) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const createScriptAssetUpload = yield* workers.createScriptAssetUpload;
+    const createAssetUpload = yield* workers.createAssetUpload;
+    yield* note("Checking assets...");
+    const session = yield* createScriptAssetUpload({
+        accountId,
+        scriptName: workerName,
+        manifest: assets.manifest,
+    });
+    if (!session.buckets?.length) {
+        return { jwt: session.jwt ?? undefined };
+    }
+    if (!session.jwt) {
+        return { jwt: undefined };
+    }
+    const uploadJwt = session.jwt;
+    let uploaded = 0;
+    const total = session.buckets.flat().length;
+    yield* note(`Uploaded ${uploaded} of ${total} assets...`);
+    const assetsByHash = new Map();
+    for (const [name, { hash }] of Object.entries(assets.manifest)) {
+        assetsByHash.set(hash, name);
+    }
+    let jwt;
+    const directory = path.resolve(assets.directory);
+    yield* Effect.forEach(session.buckets, Effect.fnUntraced(function* (bucket) {
+        const body = {};
+        yield* Effect.forEach(bucket, Effect.fnUntraced(function* (hash) {
+            const name = assetsByHash.get(hash);
+            if (!name) {
+                return yield* new AssetNotFoundError({
+                    message: `Asset ${hash} not found in manifest`,
+                    hash,
+                });
+            }
+            const file = yield* fs.readFile(path.join(directory, name)).pipe(Effect.mapError((error) => new FailedToReadAssetError({
+                message: `Failed to read asset ${name}: ${error.message}`,
+                name,
+                cause: error,
+            })));
+            body[hash] = new File([Buffer.from(file).toString("base64")], hash, {
+                type: getContentType(name),
+            });
+        }));
+        const result = yield* createAssetUpload({
+            accountId,
+            base64: true,
+            body,
+            jwtToken: uploadJwt,
+        });
+        uploaded += bucket.length;
+        yield* note(`Uploaded ${uploaded} of ${total} assets...`);
+        if (result.jwt) {
+            jwt = result.jwt;
+        }
+    }));
+    return { jwt: jwt ?? undefined };
+});
+//# sourceMappingURL=Assets.js.map