alchemy 2.0.0-beta.50 → 2.0.0-beta.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.50",
+  "version": "2.0.0-beta.51",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",

package/src/AWS/Lambda/BucketEventSource.ts

@@ -113,13 +113,25 @@ export const BucketEventSourcePolicyLive = BucketEventSourcePolicy.layer.effect(
       bucket: Bucket,
       {
         events: Events = ["s3:ObjectCreated:*"],
+        prefix,
+        suffix,
       }: {
         events?: S3EventType[];
+        prefix?: string;
+        suffix?: string;
       } = {},
     ) {
       if (Lambda.isFunction(host)) {
+        const filterRules = [
+          ...(prefix !== undefined
+            ? [{ Name: "prefix" as const, Value: prefix }]
+            : []),
+          ...(suffix !== undefined
+            ? [{ Name: "suffix" as const, Value: suffix }]
+            : []),
+        ];
         yield* Permission(`AWS.Lambda.InvokeFunction(${bucket.LogicalId})`, {
-          action: "lambda.InvokeFunction",
+          action: "lambda:InvokeFunction",
           functionName: host.functionName,
           principal: "s3.amazonaws.com",
           sourceArn: bucket.bucketArn,
@@ -130,6 +142,9 @@ export const BucketEventSourcePolicyLive = BucketEventSourcePolicy.layer.effect(
               {
                 LambdaFunctionArn: host.functionArn,
                 Events,
+                ...(filterRules.length > 0
+                  ? { Filter: { Key: { FilterRules: filterRules } } }
+                  : {}),
               },
             ],
           },

package/src/AWS/S3/Bucket.ts

@@ -1,7 +1,9 @@
 import { Region } from "@distilled.cloud/aws/Region";
 import type { BucketLocationConstraint } from "@distilled.cloud/aws/s3";
 import * as s3 from "@distilled.cloud/aws/s3";
+import * as Arr from "effect/Array";
 import * as Effect from "effect/Effect";
+import * as Order from "effect/Order";
 import * as Schedule from "effect/Schedule";
 import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
 import { isResolved } from "../../Diff.ts";
@@ -475,6 +477,75 @@ export const BucketProvider = () =>
         yield* session.note(`Removed bucket policy: ${bucketName}`);
       });
 
+      // Apply S3 event notification configuration declared via bindings
+      // (e.g. `S3.notifications(bucket).subscribe(...)`). Without this the
+      // binding is recorded in state but never reaches the bucket, so no
+      // events are ever delivered.
+      // Canonical form of the Lambda targets, ignoring S3-assigned `Id`s and
+      // event ordering, so drift detection doesn't churn across deploys.
+      const canonicalLambda = (
+        configs: readonly s3.LambdaFunctionConfiguration[],
+      ) =>
+        JSON.stringify(
+          Arr.map(configs, (c) => ({
+            arn: c.LambdaFunctionArn,
+            events: Arr.sort(c.Events ?? [], Order.String),
+            filter: c.Filter ?? null,
+          })),
+        );
+
+      const syncBucketNotifications = Effect.fnUntraced(function* ({
+        bucketName,
+        bindings,
+        session,
+        operation,
+      }: {
+        bucketName: string;
+        session: ScopedPlanStatusSession;
+        bindings: ResourceBinding<Bucket["Binding"]>[];
+        operation: "create" | "update";
+      }) {
+        const desired = Arr.flatMap(
+          bindings,
+          (binding) =>
+            binding.data.notificationConfiguration
+              ?.LambdaFunctionConfigurations ?? [],
+        );
+
+        // Nothing declared — leave any externally-managed config untouched.
+        if (Arr.isReadonlyArrayEmpty(desired)) return;
+
+        const existing = yield* s3.getBucketNotificationConfiguration({
+          Bucket: bucketName,
+        });
+
+        if (
+          canonicalLambda(existing.LambdaFunctionConfigurations ?? []) ===
+          canonicalLambda(desired)
+        ) {
+          return;
+        }
+
+        yield* Effect.logInfo(
+          `S3 Bucket ${operation}: applying notification configuration to ${bucketName}`,
+        );
+        yield* s3.putBucketNotificationConfiguration({
+          Bucket: bucketName,
+          // Preserve any Topic/Queue/EventBridge config already on the bucket;
+          // only manage the Lambda targets declared through bindings.
+          NotificationConfiguration: {
+            ...existing,
+            LambdaFunctionConfigurations: desired,
+          },
+          // The Lambda invoke permission is created as a separate resource
+          // that may be applied after this bucket reconcile. Skip S3's
+          // synchronous test-invoke so the PUT doesn't fail on ordering;
+          // the permission exists by the time events are delivered.
+          SkipDestinationValidation: true,
+        });
+        yield* session.note(`Updated bucket notifications: ${bucketName}`);
+      });
+
       return {
         stables: ["bucketName", "bucketArn", "region", "accountId"],
         // S3 bucket names are globally unique. `headBucket` succeeds only when
@@ -554,6 +625,13 @@ export const BucketProvider = () =>
             operation,
           });
 
+          yield* syncBucketNotifications({
+            bucketName: resolved.bucketName,
+            bindings,
+            session,
+            operation,
+          });
+
           if (operation === "create") {
             yield* session.note(`Ensured bucket: ${resolved.bucketName}`);
           }

package/src/AWS/S3/BucketNotifications.ts

@@ -24,6 +24,16 @@ export type BucketNotification = {
 export interface NotificationsProps<Events extends S3EventType[]> {
   /** S3 event types to subscribe to. Defaults to all event types. */
   events?: Events;
+  /**
+   * Only deliver events for object keys beginning with this prefix.
+   * Maps to an S3 `prefix` filter rule on the notification configuration.
+   */
+  prefix?: string;
+  /**
+   * Only deliver events for object keys ending with this suffix.
+   * Maps to an S3 `suffix` filter rule on the notification configuration.
+   */
+  suffix?: string;
 }
 
 /**

package/src/Cloudflare/AiGateway/AiGatewayBinding.ts

@@ -76,7 +76,7 @@ export interface AiGatewayClient {
   ): Effect.Effect<Response, AiGatewayError, RuntimeContext>;
 
   model(
-    options: LanguageModelOptions,
+    options: Omit<LanguageModelOptions, "client">,
   ): Layer.Layer<LanguageModel, never, RuntimeContext>;
 }
 
@@ -166,7 +166,7 @@ export const AiGatewayBindingLive = Layer.effect(
           Effect.flatMap((gateway) => tryPromise(() => fn(gateway))),
         );
 
-      return {
+      const self: AiGatewayClient = {
         raw: ai,
         gateway: runtimeGateway,
         id: gatewayIdAccessor,
@@ -175,8 +175,13 @@ export const AiGatewayBindingLive = Layer.effect(
         getLog: (logId) => use((gateway) => gateway.getLog(logId)),
         getUrl: (provider) => use((gateway) => gateway.getUrl(provider)),
         run: (data, options) => use((gateway) => gateway.run(data, options)),
-        model: (options) => makeLanguageModelLayer(options),
+        model: (options) =>
+          makeLanguageModelLayer({
+            ...options,
+            client: self,
+          }),
       } satisfies AiGatewayClient;
+      return self;
     });
   }),
 );

package/src/Cloudflare/Providers.ts

@@ -31,6 +31,7 @@ import * as KV from "./KV/index.ts";
 import * as Queue from "./Queue/index.ts";
 import * as R2 from "./R2/index.ts";
 import * as RateLimit from "./RateLimit/index.ts";
+import * as Ruleset from "./Ruleset/index.ts";
 import * as SecretsStore from "./SecretsStore/index.ts";
 import * as Tunnel from "./Tunnel/index.ts";
 import * as Vectorize from "./Vectorize/index.ts";
@@ -85,6 +86,7 @@ export const providers = () =>
       R2.R2Bucket,
       R2.R2BucketBindingPolicy,
       RateLimit.RateLimitBindingPolicy,
+      Ruleset.Ruleset,
       SecretsStore.SecretBindingPolicy,
       SecretsStore.SecretsStore,
       SecretsStore.Secret,
@@ -138,6 +140,7 @@ export const providers = () =>
         R2.R2BucketBindingPolicyLive,
         R2.R2BucketProvider(),
         RateLimit.RateLimitBindingPolicyLive,
+        Ruleset.RulesetProvider(),
         SecretsStore.SecretBindingPolicyLive,
         SecretsStore.SecretsStoreProvider(),
         SecretsStore.StoreSecretProvider(),

package/src/Cloudflare/Ruleset/Ruleset.ts

@@ -0,0 +1,223 @@
+import * as rulesets from "@distilled.cloud/cloudflare/rulesets";
+import * as Effect from "effect/Effect";
+import { deepEqual, isResolved } from "../../Diff.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import type { Providers } from "../Providers.ts";
+import type { Zone, ZoneAttributes } from "../Zone/index.ts";
+
+export type RulesetPhase = rulesets.CreateRulesetForZoneRequest["phase"];
+export type RulesetRule = NonNullable<
+  rulesets.PutPhasForZoneRequest["rules"]
+>[number];
+export type RulesetOutputRule = Omit<
+  NonNullable<rulesets.GetPhasResponse["rules"]>[number],
+  "lastUpdated" | "version"
+>;
+
+export type RulesetProps = {
+  /**
+   * Zone to apply the ruleset to. Pass a `Cloudflare.Zone`.
+   */
+  zone: Zone;
+  /**
+   * Ruleset phase entrypoint to own.
+   */
+  phase: RulesetPhase;
+  /**
+   * Rules to apply to the phase entrypoint.
+   */
+  rules: RulesetRule[];
+  /**
+   * Human-readable name for the ruleset.
+   * @default ${app}-${stage}-${id}
+   */
+  name?: string;
+  /**
+   * Description for the ruleset.
+   */
+  description?: string;
+};
+
+export type RulesetKind =
+  | "managed"
+  | "custom"
+  | "root"
+  | "zone"
+  | (string & {});
+
+export type Ruleset = Resource<
+  "Cloudflare.Ruleset",
+  RulesetProps,
+  {
+    /** The unique ID of the ruleset (Cloudflare `id`). */
+    rulesetId: string;
+    /**
+     * Zone the ruleset phase entrypoint belongs to. Alchemy-flattened
+     * identifier — not part of Cloudflare's phase-entrypoint response.
+     */
+    zoneId: string;
+    /** The kind of the ruleset. */
+    kind: RulesetKind;
+    /** The human-readable name of the ruleset. */
+    name: string;
+    /** The phase of the ruleset. */
+    phase: RulesetPhase;
+    /** An informative description of the ruleset. */
+    description: string | undefined;
+    /** The list of rules in the ruleset. */
+    rules: RulesetOutputRule[];
+    /** The timestamp of when the ruleset was last modified. */
+    lastUpdated: string;
+    /** The version of the ruleset. */
+    version: string;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * A Cloudflare Ruleset phase entrypoint for a zone.
+ *
+ * This resource owns the entire ruleset for a phase entrypoint. Rules managed
+ * elsewhere in the same phase can be overwritten on deploy.
+ *
+ * @section WAF Rules
+ * @example Block probes in the custom firewall phase
+ * ```typescript
+ * const zone = yield* Cloudflare.Zone("MyZone", { name: "example.com" });
+ * const waf = yield* Cloudflare.Ruleset("WafRules", {
+ *   zone,
+ *   phase: "http_request_firewall_custom",
+ *   rules: [
+ *     {
+ *       description: "Block exploit probes",
+ *       expression: `lower(http.request.uri.path) contains "/.env"`,
+ *       action: "block",
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export const Ruleset = Resource<Ruleset>("Cloudflare.Ruleset")({});
+
+const isNotFoundError = (error: unknown): boolean =>
+  typeof error === "object" &&
+  error !== null &&
+  (("status" in error && (error as { status: unknown }).status === 404) ||
+    ("_tag" in error && (error as { _tag: unknown })._tag === "NotFound"));
+
+// A `Zone` prop is resolved to its attributes before a lifecycle op runs, so
+// `zone.zoneId` is normally a plain string even though the `Zone` resource
+// type statically exposes it as an `Output`. During `diff` (plan time) the
+// zone can still be unresolved — e.g. when it's being created in the same
+// deploy — in which case `zoneId` is not yet a string. Callers must treat a
+// non-string result as "not resolved yet".
+const zoneIdOf = (zone: Zone): string | undefined => {
+  const zoneId = (zone as unknown as Partial<ZoneAttributes>).zoneId;
+  return typeof zoneId === "string" ? zoneId : undefined;
+};
+
+export const RulesetProvider = () =>
+  Provider.effect(
+    Ruleset,
+    Effect.gen(function* () {
+      const getPhas = yield* rulesets.getPhasForZone;
+      const putPhas = yield* rulesets.putPhasForZone;
+
+      const createRulesetName = (id: string, name: string | undefined) =>
+        Effect.gen(function* () {
+          return name ?? (yield* createPhysicalName({ id }));
+        });
+
+      return {
+        stables: ["zoneId", "phase"],
+        diff: Effect.fn(function* ({ id, olds, news, output }) {
+          if (!isResolved(news)) return undefined;
+          const desiredZoneId = zoneIdOf(news.zone);
+
+          // The desired zone id may still be an unresolved Output (e.g. the
+          // zone is being created in the same deploy). Only make a zone-change
+          // replacement decision once we have a concrete id.
+          if (desiredZoneId !== undefined) {
+            if (output?.zoneId && desiredZoneId !== output.zoneId) {
+              return { action: "replace" } as const;
+            }
+            const oldZoneId = olds.zone ? zoneIdOf(olds.zone) : undefined;
+            if (oldZoneId !== undefined && oldZoneId !== desiredZoneId) {
+              return { action: "replace" } as const;
+            }
+          }
+          if (olds.phase !== news.phase) {
+            return { action: "replace" } as const;
+          }
+
+          const oldName =
+            output?.name ?? (yield* createRulesetName(id, olds.name));
+          const name = yield* createRulesetName(id, news.name);
+          if (
+            oldName !== name ||
+            olds.description !== news.description ||
+            !deepEqual(olds.rules, news.rules)
+          ) {
+            return { action: "update" } as const;
+          }
+        }),
+        reconcile: Effect.fn(function* ({ id, news, output }) {
+          const zoneId = output?.zoneId ?? zoneIdOf(news.zone);
+          if (zoneId === undefined) {
+            return yield* Effect.fail(
+              new Error("Cloudflare Ruleset: zone id is not resolved"),
+            );
+          }
+          const name = yield* createRulesetName(id, news.name ?? output?.name);
+          const ruleset = yield* putPhas({
+            zoneId,
+            rulesetPhase: news.phase,
+            name,
+            description: news.description,
+            rules: news.rules,
+          });
+          return toRulesetAttributes(zoneId, ruleset);
+        }),
+        delete: Effect.fn(function* ({ olds, output }) {
+          yield* putPhas({
+            zoneId: output.zoneId,
+            rulesetPhase: olds.phase,
+            name: output.name,
+            description: output.description,
+            rules: [],
+          }).pipe(Effect.catchIf(isNotFoundError, () => Effect.void));
+        }),
+        read: Effect.fn(function* ({ olds, output }) {
+          const zoneId = output?.zoneId ?? zoneIdOf(olds.zone);
+          if (zoneId === undefined) return undefined;
+          return yield* getPhas({
+            zoneId,
+            rulesetPhase: output?.phase ?? olds.phase,
+          }).pipe(
+            Effect.map((ruleset) => toRulesetAttributes(zoneId, ruleset)),
+            Effect.catchIf(isNotFoundError, () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );
+
+export const toRulesetAttributes = (
+  zoneId: string,
+  ruleset: rulesets.GetPhasResponse | rulesets.PutPhasResponse,
+): Ruleset["Attributes"] => ({
+  rulesetId: ruleset.id,
+  zoneId,
+  kind: ruleset.kind,
+  name: ruleset.name,
+  phase: ruleset.phase,
+  description: ruleset.description ?? undefined,
+  rules: (ruleset.rules ?? []).map(
+    ({ lastUpdated: _lastUpdated, version: _version, ...rule }) => rule,
+  ),
+  lastUpdated: ruleset.lastUpdated,
+  version: ruleset.version,
+});

package/src/Cloudflare/Ruleset/index.ts

@@ -0,0 +1 @@
+export * from "./Ruleset.ts";

package/src/Cloudflare/SecretsStore/Secret.ts

@@ -54,6 +54,10 @@ export type Secret = Resource<
   Providers
 >;
 
+export const isSecret = (value: unknown): value is Secret =>
+  typeof value === "object" &&
+  (value as any)?.Type === "Cloudflare.SecretsStore.Secret";
+
 export type SecretStatus = "pending" | "active" | "deleted";
 
 // Distilled widened generated string enums to open unions (`string & {}`); the

package/src/Cloudflare/Workers/DurableObjectChatPersistence.ts

@@ -0,0 +1,131 @@
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import {
+  BackingPersistence,
+  PersistenceError,
+  type BackingPersistenceStore,
+} from "effect/unstable/persistence/Persistence";
+import { DurableObjectState } from "./DurableObjectState.ts";
+
+/**
+ * A `BackingPersistence` layer (Effect AI persistence module) backed
+ * by the surrounding Durable Object's `state.storage`. Drop-in storage
+ * for `Persistence.layerResultPersisted({ storeId })` so chat history,
+ * cached AI responses, or any other persisted state lives in the DO
+ * SQLite store with `${storeId}:` key namespacing.
+ *
+ * Multiple `storeId`s can coexist within a single Durable Object —
+ * keys are namespaced with a `${storeId}:` prefix so they don't
+ * collide.
+ *
+ * :::caution
+ * TTL is currently ignored; Durable Object storage has no native TTL.
+ * If you need expiry, layer a TTL-aware backing store on top, or run
+ * a periodic `clear`.
+ * :::
+ *
+ * @binding
+ *
+ * @section Wiring it into a chat-backing DO
+ * @example Persisted chat history per DO instance
+ * `Persistence.layerResultPersisted({ storeId })` is the seam Effect
+ * AI exposes for cached/replayable AI calls. Layer
+ * `DurableObjectChatPersistence` underneath and every entry is stored
+ * in the DO's `state.storage` under the `alchemy.chat:` prefix.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import { Chat, LanguageModel } from "effect/unstable/ai";
+ * import { Persistence } from "effect/unstable/persistence";
+ *
+ * export default class ChatBackend extends Cloudflare.DurableObjectNamespace<ChatBackend>()(
+ *   "ChatBackend",
+ *   Effect.gen(function* () {
+ *     return Effect.gen(function* () {
+ *       const persistence = yield* Persistence.layerResultPersisted({
+ *         storeId: "alchemy.chat",
+ *       }).pipe(Layer.provide(Cloudflare.DurableObjectChatPersistence));
+ *
+ *       return {
+ *         send: (threadId: string, prompt: string) =>
+ *           LanguageModel.generateText({ prompt }).pipe(Effect.provide(persistence)),
+ *       };
+ *     });
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Multiple stores in the same DO
+ * @example Separate `storeId`s coexist
+ * Different `storeId`s namespace their keys with `${storeId}:`, so
+ * one DO can keep, say, chat history *and* an audit log in separate
+ * stores without colliding.
+ * ```typescript
+ * const aiPersistence = yield* Persistence.layerResultPersisted({
+ *   storeId: "alchemy.chat",
+ * }).pipe(Layer.provide(Cloudflare.DurableObjectChatPersistence));
+ *
+ * const auditPersistence = yield* Persistence.layerResultPersisted({
+ *   storeId: "alchemy.audit",
+ * }).pipe(Layer.provide(Cloudflare.DurableObjectChatPersistence));
+ * ```
+ */
+export const DurableObjectChatPersistence = Layer.effect(BackingPersistence)(
+  Effect.gen(function* () {
+    const state = yield* DurableObjectState;
+    const storage = state.storage;
+
+    const wrapErr = (op: string, key?: string) => (cause: unknown) =>
+      new PersistenceError({
+        message: `Failed to ${op}${key !== undefined ? ` key ${key}` : ""} in DurableObject storage`,
+        cause,
+      });
+
+    return BackingPersistence.of({
+      make: (storeId) =>
+        Effect.sync(() => {
+          const prefixed = (k: string) => `${storeId}:${k}`;
+          return {
+            get: (key) =>
+              storage
+                .get<object>(prefixed(key))
+                .pipe(Effect.mapError(wrapErr("get", key))),
+            getMany: (keys) =>
+              storage.get<object>(keys.map(prefixed)).pipe(
+                Effect.mapError(wrapErr("getMany")),
+                Effect.map(
+                  (map) =>
+                    keys.map((k) => map.get(prefixed(k))) as Arr.NonEmptyArray<
+                      object | undefined
+                    >,
+                ),
+              ),
+            set: (key, value, _ttl) =>
+              storage
+                .put(prefixed(key), value)
+                .pipe(Effect.mapError(wrapErr("set", key))),
+            setMany: (entries) =>
+              storage
+                .put(
+                  Object.fromEntries(entries.map(([k, v]) => [prefixed(k), v])),
+                )
+                .pipe(Effect.mapError(wrapErr("setMany"))),
+            remove: (key) =>
+              storage
+                .delete(prefixed(key))
+                .pipe(Effect.asVoid, Effect.mapError(wrapErr("remove", key))),
+            clear: storage.list({ prefix: `${storeId}:` }).pipe(
+              Effect.flatMap((map) => {
+                const ks = [...map.keys()];
+                if (ks.length === 0) return Effect.void;
+                return Effect.asVoid(storage.delete(ks));
+              }),
+              Effect.mapError(wrapErr("clear")),
+            ),
+          } satisfies BackingPersistenceStore;
+        }),
+    });
+  }),
+);

package/src/Cloudflare/Workers/Worker.ts

@@ -1,6 +1,7 @@
 import type * as cf from "@cloudflare/workers-types";
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as zones from "@distilled.cloud/cloudflare/zones";
+import type { ConfigError } from "effect/Config";
 import * as Config from "effect/Config";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
@@ -708,7 +709,11 @@ export const Worker: Platform<
     id: string,
     props:
       | InputProps<WorkerProps<Bindings, Assets>>
-      | Effect.Effect<InputProps<WorkerProps<Bindings, Assets>>, never, Req>,
+      | Effect.Effect<
+          InputProps<WorkerProps<Bindings, Assets>>,
+          ConfigError,
+          Req
+        >,
   ): Effect.Effect<
     Worker<{
       [binding in keyof NormalizedBindings<

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -20,6 +20,7 @@ import { isKVNamespace } from "../KV/KVNamespace.ts";
 import { isQueue } from "../Queue/Queue.ts";
 import { isR2Bucket } from "../R2/R2Bucket.ts";
 import { isRateLimit } from "../RateLimit/RateLimit.ts";
+import { isSecret } from "../SecretsStore/Secret.ts";
 import { isVectorizeIndex } from "../Vectorize/VectorizeIndex.ts";
 import { isAssets } from "./Assets.ts";
 import { isDurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
@@ -210,6 +211,13 @@ const toBinding = (
       name: bindingName,
       indexName: binding.indexName,
     };
+  } else if (isSecret(binding)) {
+    return {
+      type: "secrets_store_secret",
+      name: bindingName,
+      secretName: binding.secretName,
+      storeId: binding.storeId,
+    };
   } else if (isDynamicWorkerLoader(binding)) {
     return {
       type: "worker_loader",

package/src/Cloudflare/Workers/WorkerBinding.ts

@@ -18,6 +18,7 @@ import type { KVNamespace } from "../KV/KVNamespace.ts";
 import type { Queue } from "../Queue/Queue.ts";
 import type { R2Bucket } from "../R2/R2Bucket.ts";
 import type { RateLimit } from "../RateLimit/RateLimit.ts";
+import type { Secret } from "../SecretsStore/Secret.ts";
 import type { VectorizeIndex } from "../Vectorize/VectorizeIndex.ts";
 import type { Assets } from "./Assets.ts";
 import type { DurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
@@ -55,6 +56,7 @@ export type WorkerBindingResource =
   | Images
   | Hyperdrive
   | VectorizeIndex
+  | Secret
   | Worker
   | DynamicWorkerLoader
   | DurableObjectNamespaceLike<any>;

package/src/Cloudflare/Workers/index.ts

@@ -2,6 +2,7 @@ export * from "./Assets.ts";
 export * from "./ConfigProvider.ts";
 export * from "./CronEventSource.ts";
 export * from "./DurableObjectBridge.ts";
+export * from "./DurableObjectChatPersistence.ts";
 export * from "./DurableObjectNamespace.ts";
 export * from "./DurableObjectState.ts";
 export * from "./DurableObjectStorage.ts";

package/src/Cloudflare/index.ts

@@ -17,6 +17,7 @@ export * from "./Providers.ts";
 export * from "./Queue/index.ts";
 export * from "./R2/index.ts";
 export * from "./RateLimit/index.ts";
+export * from "./Ruleset/index.ts";
 export * from "./SecretsStore/index.ts";
 export * from "./StateStore/index.ts";
 export * from "./Tunnel/index.ts";

package/src/Deploy.ts

@@ -1,3 +1,4 @@
+import type { ConfigError } from "effect/Config";
 import * as Effect from "effect/Effect";
 import type * as Scope from "effect/Scope";
 import { AlchemyContext } from "./AlchemyContext.ts";
@@ -14,7 +15,7 @@ export const deploy = <A>({
   scope,
   force,
 }: {
-  stack: StackEffect<CompiledStack<A>, Stage | AlchemyContext>;
+  stack: StackEffect<CompiledStack<A>, ConfigError, Stage | AlchemyContext>;
   stage: string;
   dev?: boolean;
   /** See {@link evalStack} — when set, scoped resources outlive `deploy`. */