alchemy-effect 0.6.2 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy-effect",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
@@ -81,11 +81,6 @@
       "bun": "./src/Construct/index.ts",
       "import": "./lib/Construct/index.js"
     },
-    "./Kubernetes": {
-      "types": "./src/Kubernetes/index.d.ts",
-      "bun": "./src/Kubernetes/index.ts",
-      "import": "./lib/Kubernetes/index.js"
-    },
     "./Bundle": {
       "types": "./src/Bundle/index.d.ts",
       "bun": "./src/Bundle/index.ts",
@@ -116,10 +111,10 @@
       "bun": "./src/Endpoint/index.ts",
       "import": "./lib/Endpoint/index.js"
     },
-    "./SQLite": {
-      "types": "./src/SQLite/index.d.ts",
-      "bun": "./src/SQLite/index.ts",
-      "import": "./lib/SQLite/index.js"
+    "./Kubernetes": {
+      "types": "./src/Kubernetes/index.d.ts",
+      "bun": "./src/Kubernetes/index.ts",
+      "import": "./lib/Kubernetes/index.js"
     },
     "./Output": {
       "types": "./src/Output.d.ts",
@@ -131,6 +126,11 @@
       "bun": "./src/Process/index.ts",
       "import": "./lib/Process/index.js"
     },
+    "./SQLite": {
+      "types": "./src/SQLite/index.d.ts",
+      "bun": "./src/SQLite/index.ts",
+      "import": "./lib/SQLite/index.js"
+    },
     "./TUI": {
       "types": "./src/TUI/index.d.ts",
       "bun": "./src/TUI/index.ts",
@@ -168,11 +168,11 @@
     "@ai-sdk/openai": "^3.0.23",
     "@ai-sdk/provider": "^3.0.8",
     "@aws-sdk/credential-providers": "^3.0.0",
-    "@distilled.cloud/aws": "^0.7.6",
-    "@distilled.cloud/cloudflare": "^0.7.6",
-    "@distilled.cloud/cloudflare-rolldown-plugin": "0.1.2",
-    "@distilled.cloud/core": "^0.7.6",
-    "@effect/vitest": "4.0.0-beta.38",
+    "@distilled.cloud/aws": "^0.7.11",
+    "@distilled.cloud/cloudflare": "^0.7.11",
+    "@distilled.cloud/cloudflare-rolldown-plugin": "^0.1.2",
+    "@distilled.cloud/core": "^0.7.11",
+    "@effect/vitest": "4.0.0-beta.43",
     "@libsql/client": "^0.17.0",
     "@smithy/node-config-provider": "^4.0.0",
     "@smithy/shared-ini-file-loader": "^4.3.4",
@@ -180,6 +180,7 @@
     "@types/aws-lambda": "^8.10.152",
     "ai": "^6.0.62",
     "aws4fetch": "^1.0.20",
+    "capnp-es": "^0.0.14",
     "cloudflare": "^5.2.0",
     "fast-glob": "^3.3.2",
     "fast-xml-parser": "^5.3.4",
@@ -188,19 +189,21 @@
     "rolldown": "1.0.0-rc.13",
     "solid-js": "latest",
     "web-tree-sitter": "0.25.10",
+    "workerd": "1.20260405.1",
     "yaml": "^2.0.0"
   },
   "devDependencies": {
     "@clack/prompts": "^0.11.0",
     "@cloudflare/workers-types": "^4.20250805.0",
-    "@effect/platform-bun": "4.0.0-beta.38",
-    "@effect/platform-node": "4.0.0-beta.38",
-    "@effect/platform-node-shared": "4.0.0-beta.38",
+    "@effect/platform-bun": "4.0.0-beta.43",
+    "@effect/platform-node": "4.0.0-beta.43",
+    "@effect/platform-node-shared": "4.0.0-beta.43",
     "@types/aws-lambda": "^8.10.152",
     "@types/bun": "latest",
     "@types/node": "latest",
     "@types/react": "^19.2.2",
-    "effect": "4.0.0-beta.38",
+    "better-auth": "^1.6.2",
+    "effect": "4.0.0-beta.43",
     "ink": "^6.3.1",
     "pathe": "^2.0.3",
     "react": "^19.2.0",

package/src/AWS/AutoScaling/AutoScalingGroup.ts

@@ -348,7 +348,7 @@ export const AutoScalingGroupProvider = () =>
             Effect.retry({
               while: () => true,
               schedule: Schedule.recurs(8).pipe(
-                Schedule.compose(Schedule.exponential("250 millis")),
+                Schedule.both(Schedule.exponential("250 millis")),
               ),
             }),
           );
@@ -430,7 +430,7 @@ export const AutoScalingGroupProvider = () =>
               while: (error) =>
                 (error as Error).message === "AutoScalingGroupStillExists",
               schedule: Schedule.recurs(12).pipe(
-                Schedule.compose(Schedule.exponential("250 millis")),
+                Schedule.both(Schedule.exponential("250 millis")),
               ),
             }),
           );

package/src/AWS/DynamoDB/PutItem.ts

@@ -24,12 +24,12 @@ export class PutItem extends Binding.Service<
 export const PutItemLive = Layer.effect(
   PutItem,
   Effect.gen(function* () {
-    const Policy = yield* PutItemPolicy;
+    const bind = yield* PutItemPolicy;
     const putItem = yield* DynamoDB.putItem;
 
     return Effect.fn(function* <T extends Table>(table: T) {
       const TableName = yield* table.tableName;
-      yield* Policy(table);
+      yield* bind(table);
       return Effect.fn(function* (request: PutItemRequest) {
         const tableName = yield* TableName;
         return yield* putItem({

package/src/AWS/EC2/Instance.ts

@@ -499,7 +499,7 @@ export const InstanceProvider = () =>
               error instanceof InstanceStateMismatch ||
               isPendingInstanceLookupError(error),
             schedule: Schedule.exponential("250 millis").pipe(
-              Schedule.compose(Schedule.recurs(8)),
+              Schedule.both(Schedule.recurs(8)),
             ),
           }),
         );
@@ -526,7 +526,7 @@ export const InstanceProvider = () =>
           Effect.retry({
             while: (error) => error instanceof InstanceStillExists,
             schedule: Schedule.exponential("250 millis").pipe(
-              Schedule.compose(Schedule.recurs(8)),
+              Schedule.both(Schedule.recurs(8)),
             ),
           }),
           Effect.catchTag("InvalidInstanceID.NotFound", () => Effect.void),
@@ -678,7 +678,7 @@ export const InstanceProvider = () =>
               Effect.retry({
                 while: isPendingInstanceProfileError,
                 schedule: Schedule.exponential("500 millis").pipe(
-                  Schedule.compose(Schedule.recurs(8)),
+                  Schedule.both(Schedule.recurs(8)),
                 ),
               }),
             );

package/src/AWS/Providers.ts

@@ -3,6 +3,7 @@ import { pipe } from "effect/Function";
 import * as Layer from "effect/Layer";
 import { CommandProvider } from "../Build/Command.ts";
 import type { Provider } from "../Provider.ts";
+import { RandomProvider } from "../Random.ts";
 import * as Account from "./Account.ts";
 import * as ACM from "./ACM/index.ts";
 import * as Assets from "./Assets.ts";
@@ -84,6 +85,7 @@ export const credentials = () =>
 export const resources = () =>
   Layer.mergeAll(
     CommandProvider(),
+    RandomProvider(),
     ACM.CertificateProvider(),
     AutoScaling.AutoScalingGroupProvider(),
     AutoScaling.LaunchTemplateProvider(),

package/src/Apply.ts

@@ -455,7 +455,6 @@ const executeNode = (
         };
         yield* signalReady;
 
-        yield* report("created");
         yield* markTerminal("created");
         return;
       }
@@ -562,7 +561,6 @@ const executeNode = (
           instanceId,
         };
 
-        yield* report("updated");
         yield* markTerminal("updated");
         return;
       }
@@ -579,7 +577,6 @@ const executeNode = (
             instanceId,
           };
           yield* signalReady;
-          yield* report("created");
           yield* markTerminal("created");
           return;
         }
@@ -707,7 +704,6 @@ const executeNode = (
 
         // Keep progress anchored to the live replacement while GC drains the
         // previous generation(s) in the background.
-        yield* report("created");
         yield* markTerminal("created");
         return;
       }

package/src/Cloudflare/D1/D1Connection.ts

@@ -0,0 +1,74 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Binding from "../../Binding.ts";
+import { WorkerEnvironment } from "../Workers/Worker.ts";
+import type { D1Database } from "./D1Database.ts";
+import { DatabaseBinding } from "./D1DatabaseBinding.ts";
+
+export interface D1ConnectionClient {
+  /**
+   * An Effect that resolves to the raw underlying Cloudflare D1Database binding.
+   * Use this when you need direct access for libraries like Better Auth.
+   */
+  raw: Effect.Effect<runtime.D1Database>;
+  /**
+   * Prepare a SQL query statement for later execution.
+   */
+  prepare: (query: string) => Effect.Effect<runtime.D1PreparedStatement>;
+  /**
+   * Execute raw SQL without prepared statements.
+   */
+  exec: (query: string) => Effect.Effect<runtime.D1ExecResult>;
+  /**
+   * Send multiple prepared statements in a single call.
+   * Statements execute sequentially and are rolled back on failure.
+   */
+  batch: <T = unknown>(
+    statements: runtime.D1PreparedStatement[],
+  ) => Effect.Effect<runtime.D1Result<T>[]>;
+}
+
+export class D1Connection extends Binding.Service<
+  D1Connection,
+  (database: D1Database) => Effect.Effect<D1ConnectionClient>
+>()("Cloudflare.D1.Connection") {}
+
+export const D1ConnectionLive = Layer.effect(
+  D1Connection,
+  Effect.gen(function* () {
+    const Policy = yield* D1ConnectionPolicy;
+
+    return Effect.fn(function* (database: D1Database) {
+      yield* Policy(database);
+      const d1 = yield* Effect.serviceOption(WorkerEnvironment).pipe(
+        Effect.map(Option.getOrUndefined),
+        Effect.map((env) => env?.[database.LogicalId]! as runtime.D1Database),
+        Effect.cached,
+      );
+
+      return {
+        raw: d1,
+        prepare: (query: string) =>
+          d1.pipe(Effect.map((d1) => d1.prepare(query))),
+        exec: (query: string) =>
+          d1.pipe(Effect.flatMap((d1) => Effect.promise(() => d1.exec(query)))),
+        batch: <T = unknown>(statements: runtime.D1PreparedStatement[]) =>
+          d1.pipe(
+            Effect.flatMap((d1) =>
+              Effect.promise(() => d1.batch<T>(statements)),
+            ),
+          ),
+      } satisfies D1ConnectionClient;
+    });
+  }),
+);
+
+export class D1ConnectionPolicy extends Binding.Policy<
+  D1ConnectionPolicy,
+  (database: D1Database) => Effect.Effect<void>
+>()("Cloudflare.D1.Connection") {}
+
+export const D1ConnectionPolicyLive =
+  D1ConnectionPolicy.layer.succeed(DatabaseBinding);

package/src/Cloudflare/D1/D1Database.ts

@@ -0,0 +1,222 @@
+import * as d1 from "@distilled.cloud/cloudflare/d1";
+import * as Effect from "effect/Effect";
+
+import type { Credentials } from "@distilled.cloud/cloudflare";
+import type { Layer } from "effect/Layer";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+import { isResolved } from "../../Diff.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import type { Provider } from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import type { Stack } from "../../Stack.ts";
+import type { Stage } from "../../Stage.ts";
+import { Account } from "../Account.ts";
+
+export type Jurisdiction = "default" | "eu" | "fedramp";
+export type PrimaryLocationHint =
+  | "wnam"
+  | "enam"
+  | "weur"
+  | "eeur"
+  | "apac"
+  | "oc";
+
+export type DatabaseProps = {
+  /**
+   * Name of the database. If omitted, a unique name will be generated.
+   * @default ${app}-${stage}-${id}
+   */
+  name?: string;
+  /**
+   * Optional primary location hint for the database.
+   */
+  primaryLocationHint?: PrimaryLocationHint;
+  /**
+   * Read replication configuration. Only mutable property during updates.
+   */
+  readReplication?: {
+    mode: "auto" | "disabled";
+  };
+  /**
+   * Jurisdiction where data is guaranteed to be stored.
+   * @default "default"
+   */
+  jurisdiction?: Jurisdiction;
+};
+
+export type D1Database = Resource<
+  "Cloudflare.D1Database",
+  DatabaseProps,
+  {
+    databaseId: string;
+    databaseName: string;
+    jurisdiction: Jurisdiction;
+    readReplication: { mode: "auto" | "disabled" } | undefined;
+    accountId: string;
+  }
+>;
+
+/**
+ * A Cloudflare D1 serverless SQL database built on SQLite.
+ *
+ * @section Creating a Database
+ * @example Basic Database
+ * ```typescript
+ * const db = yield* Database("my-db", {});
+ * ```
+ *
+ * @example Database with Location Hint
+ * ```typescript
+ * const db = yield* Database("my-db", {
+ *   primaryLocationHint: "wnam",
+ * });
+ * ```
+ */
+export const D1Database = Resource<D1Database>("Cloudflare.D1Database");
+
+export const DatabaseProvider = (): Layer<
+  Provider<D1Database>,
+  never,
+  Account | Credentials | HttpClient | Stack | Stage
+> =>
+  D1Database.provider.effect(
+    Effect.gen(function* () {
+      const accountId = yield* Account;
+      const createDb = yield* d1.createDatabase;
+      const getDb = yield* d1.getDatabase;
+      const patchDb = yield* d1.patchDatabase;
+      const deleteDb = yield* d1.deleteDatabase;
+      const listDbs = yield* d1.listDatabases;
+
+      const createDatabaseName = (id: string, name: string | undefined) =>
+        Effect.gen(function* () {
+          return name ?? (yield* createPhysicalName({ id }));
+        });
+
+      return {
+        stables: ["databaseId", "accountId"],
+        diff: Effect.fn(function* ({ id, olds = {}, news = {}, output }) {
+          if (!isResolved(news)) return undefined;
+          if ((output?.accountId ?? accountId) !== accountId) {
+            return { action: "replace" } as const;
+          }
+          const name = yield* createDatabaseName(id, news.name);
+          const oldName = output?.databaseName
+            ? output.databaseName
+            : yield* createDatabaseName(id, olds.name);
+          const oldJurisdiction =
+            output?.jurisdiction ?? olds.jurisdiction ?? "default";
+          if (
+            oldName !== name ||
+            oldJurisdiction !== (news.jurisdiction ?? "default") ||
+            (olds.primaryLocationHint !== news.primaryLocationHint &&
+              news.primaryLocationHint !== undefined)
+          ) {
+            return { action: "replace" } as const;
+          }
+          const oldReplicationMode =
+            output?.readReplication?.mode ??
+            olds.readReplication?.mode ??
+            "disabled";
+          const newReplicationMode = news.readReplication?.mode ?? "disabled";
+          if (oldReplicationMode !== newReplicationMode) {
+            return { action: "update" } as const;
+          }
+        }),
+        create: Effect.fn(function* ({ id, news = {} }) {
+          const name = yield* createDatabaseName(id, news.name);
+          const jurisdiction = news.jurisdiction ?? "default";
+          const db = yield* createDb({
+            accountId,
+            name,
+            jurisdiction: jurisdiction !== "default" ? jurisdiction : undefined,
+            primaryLocationHint: news.primaryLocationHint,
+          }).pipe(
+            Effect.catchTag("InvalidProperty", () =>
+              Effect.gen(function* () {
+                const dbs = yield* listDbs({ accountId, name });
+                const match = dbs.result.find((db) => db.name === name);
+                if (match) {
+                  return match;
+                }
+                return yield* Effect.die(
+                  `Database with name "${name}" already exists but could not be found`,
+                );
+              }),
+            ),
+          );
+
+          const databaseId = db.uuid!;
+
+          if (news.readReplication?.mode) {
+            yield* patchDb({
+              accountId,
+              databaseId,
+              readReplication: news.readReplication,
+            });
+          }
+
+          return {
+            databaseId,
+            databaseName: db.name ?? name,
+            jurisdiction,
+            readReplication: news.readReplication,
+            accountId,
+          };
+        }),
+        update: Effect.fn(function* ({ news = {}, output }) {
+          const replicationMode = news.readReplication?.mode ?? "disabled";
+          const updated = yield* patchDb({
+            accountId: output.accountId,
+            databaseId: output.databaseId,
+            readReplication: { mode: replicationMode },
+          });
+          return {
+            databaseId: updated.uuid ?? output.databaseId,
+            databaseName: updated.name ?? output.databaseName,
+            jurisdiction: output.jurisdiction,
+            readReplication: news.readReplication,
+            accountId: output.accountId,
+          };
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* deleteDb({
+            accountId: output.accountId,
+            databaseId: output.databaseId,
+          }).pipe(Effect.catchTag("DatabaseNotFound", () => Effect.void));
+        }),
+        read: Effect.fn(function* ({ id, output, olds }) {
+          if (output?.databaseId) {
+            return yield* getDb({
+              accountId: output.accountId,
+              databaseId: output.databaseId,
+            }).pipe(
+              Effect.map((db) => ({
+                databaseId: db.uuid ?? output.databaseId,
+                databaseName: db.name ?? output.databaseName,
+                jurisdiction: output.jurisdiction,
+                readReplication: db.readReplication ?? undefined,
+                accountId: output.accountId,
+              })),
+              Effect.catchTag("DatabaseNotFound", () =>
+                Effect.succeed(undefined),
+              ),
+            );
+          }
+          const name = yield* createDatabaseName(id, olds?.name);
+          const dbs = yield* listDbs({ accountId, name });
+          const match = dbs.result.find((db) => db.name === name);
+          if (match) {
+            return {
+              databaseId: match.uuid!,
+              databaseName: match.name ?? name,
+              jurisdiction: (olds?.jurisdiction ?? "default") as Jurisdiction,
+              readReplication: olds?.readReplication,
+              accountId,
+            };
+          }
+          return undefined;
+        }),
+      };
+    }),
+  );

package/src/Cloudflare/D1/D1DatabaseBinding.ts

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker } from "../Workers/Worker.ts";
+import type { D1Database } from "./D1Database.ts";
+
+export const DatabaseBinding = Effect.fn(function* (
+  host: ResourceLike,
+  database: D1Database,
+) {
+  if (isWorker(host)) {
+    yield* host.bind`Bind(${database})`({
+      bindings: [
+        {
+          type: "d1",
+          name: database.LogicalId,
+          id: database.databaseId,
+        },
+      ],
+    });
+  } else {
+    return yield* Effect.die(
+      new Error(`DatabaseBinding does not support runtime '${host.Type}'`),
+    );
+  }
+});

package/src/Cloudflare/D1/index.ts

@@ -0,0 +1,3 @@
+export * from "./D1Connection.ts";
+export * from "./D1Database.ts";
+export * from "./D1DatabaseBinding.ts";

package/src/Cloudflare/Logs.ts

@@ -3,19 +3,7 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import type { LogLine, LogsInput } from "../Provider.ts";
 
-/**
- * Progressively wider lookback windows used when `since` is omitted.
- * We try each in order, stopping as soon as we get results.
- * This keeps the common case (recent activity) fast while still finding
- * older logs without asking Cloudflare to scan an enormous range up-front.
- */
-const LOOKBACK_WINDOWS_MS = [
-  1 * 60 * 60 * 1000, //  1 hour
-  6 * 60 * 60 * 1000, //  6 hours
-  24 * 60 * 60 * 1000, //  1 day
-  7 * 24 * 60 * 60 * 1000, //  7 days
-  30 * 24 * 60 * 60 * 1000, // 30 days
-];
+const DEFAULT_LOOKBACK_MS = 1 * 60 * 60 * 1000;
 
 export interface TelemetryFilter {
   key: string;
@@ -81,23 +69,18 @@ export const CloudflareLogs = Effect.gen(function* () {
         return parseEvents(response);
       }
 
-      for (const window of LOOKBACK_WINDOWS_MS) {
-        const response = yield* queryTelemetry({
-          accountId: opts.accountId,
-          queryId: "events",
-          view: "events",
-          timeframe: { from: now - window, to: now },
-          limit,
-          parameters: {
-            filters: opts.filters,
-            orderBy: { value: "timestamp", order: "desc" },
-          },
-        });
-        const lines = parseEvents(response);
-        if (lines.length > 0) return lines;
-      }
+      const response = yield* queryTelemetry({
+        accountId: opts.accountId,
+        queryId: "events",
+        view: "events",
+        timeframe: { from: now - DEFAULT_LOOKBACK_MS, to: now },
+        limit,
+        parameters: {
+          filters: opts.filters,
+        },
+      });
 
-      return [];
+      return parseEvents(response);
     });
 
   const tailStream = (opts: {

package/src/Cloudflare/Providers.ts

@@ -5,8 +5,10 @@ import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import * as Socket from "effect/unstable/socket/Socket";
 import { CommandProvider } from "../Build/Command.ts";
 import type { Provider } from "../Provider.ts";
+import { RandomProvider } from "../Random.ts";
 import * as Account from "./Account.ts";
 import { ContainerProvider } from "./Container.ts";
+import * as D1 from "./D1/index.ts";
 import * as KV from "./KV/index.ts";
 import * as R2 from "./R2/index.ts";
 import { AssetsProvider } from "./Workers/Assets.ts";
@@ -45,9 +47,11 @@ export const credentials = () =>
 export const resources = () =>
   Layer.mergeAll(
     CommandProvider(),
+    RandomProvider(),
     ContainerProvider(),
     WorkerProvider(),
     WorkflowProvider(),
+    D1.DatabaseProvider(),
     KV.NamespaceProvider(),
     R2.BucketProvider(),
   );
@@ -57,6 +61,7 @@ export const resources = () =>
  */
 export const bindings = () =>
   Layer.mergeAll(
+    D1.D1ConnectionPolicyLive,
     R2.GetObjectPolicyLive,
     R2.PutObjectPolicyLive,
     R2.DeleteObjectPolicyLive,

package/src/Cloudflare/Workers/HttpServer.ts

@@ -10,7 +10,10 @@ import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import * as Socket from "effect/unstable/socket/Socket";
 import * as util from "node:util";
 import * as Http from "../../Http.ts";
-import { isWorkerEvent } from "./Worker.ts";
+import { Request } from "./Request.ts";
+import { isWorkerEvent, type WorkerServices } from "./Worker.ts";
+
+export type HttpEffect = Http.HttpEffect<WorkerServices>;
 
 export const workersHttpHandler = <Req = never>(
   handler: Http.HttpEffect<Req>,
@@ -130,6 +133,7 @@ export const serveWebRequest = <Req = never>(
     const request = make();
     const response = yield* handler.pipe(
       Effect.provideService(HttpServerRequest.HttpServerRequest, request),
+      Effect.provideService(Request, webRequest as any),
       Effect.catchCause((cause) => {
         console.error(
           "[serveWebRequest] handler error:",

package/src/Cloudflare/Workers/Request.ts

@@ -0,0 +1,5 @@
+import * as ServiceMap from "effect/ServiceMap";
+
+export class Request extends ServiceMap.Service<Request, globalThis.Request>()(
+  "Request",
+) {}

package/src/Cloudflare/Workers/index.ts

@@ -4,6 +4,7 @@ export * from "./DurableObject.ts";
 export * from "./DynamicWorker.ts";
 export * from "./Fetch.ts";
 export * from "./HttpServer.ts";
+export * from "./Request.ts";
 export * from "./Rpc.ts";
 export * from "./WebSocket.ts";
 export * from "./Worker.ts";

package/src/Cloudflare/index.ts

@@ -1,4 +1,5 @@
 export * from "./Container.ts";
+export * from "./D1/index.ts";
 export * as KV from "./KV/index.ts";
 export * from "./Providers.ts";
 export * as R2 from "./R2/index.ts";