alchemy 2.0.0-beta.56 → 2.0.0-beta.58

package/src/AWS/Lambda/Function.ts

@@ -16,6 +16,14 @@ import * as Stream from "effect/Stream";
 import type * as rolldown from "rolldown";
 import { Unowned } from "../../AdoptPolicy.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
+import {
+  hashPackageInstallIdentity,
+  installResolvedPackages,
+  matchesPackageRoot,
+  normalizeInstallTargets,
+  type PackageInstall,
+  resolvePackageInstallIdentity,
+} from "../../Bundle/InstalledPackages.ts";
 import * as TempRoot from "../../Bundle/TempRoot.ts";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import type { HttpEffect } from "../../Http.ts";
@@ -60,11 +68,27 @@ export const isFunction = (value: any): value is Function => {
   );
 };
 
-export interface FunctionBuildOptions {
-  readonly input?: Partial<rolldown.InputOptions>;
+export interface FunctionBuildOptions extends Partial<rolldown.InputOptions> {
+  /**
+   * Native or Node-only packages to install into the Lambda artifact with npm,
+   * targeting Linux and the function's architecture.
+   *
+   * @example
+   * ```typescript
+   * build: { install: ["sharp"] }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * build: { install: { sharp: "^0.33.5" } }
+   * ```
+   */
+  readonly install?: PackageInstall;
   readonly output?: Partial<rolldown.OutputOptions>;
 }
 
+export type FunctionArchitecture = "x86_64" | "arm64";
+
 export interface FunctionUrlConfig {
   /**
    * Authentication type for the Lambda function URL.
@@ -103,6 +127,13 @@ export interface FunctionProps extends PlatformProps {
   functionName?: string;
   // TODO(sam): use a Layer instead so we can manage Effect platform?
   runtime?: "nodejs22.x" | "nodejs24.x";
+  /**
+   * Instruction set architecture for the Lambda function.
+   *
+   * @default "x86_64"
+   */
+  architecture?: FunctionArchitecture;
+  memorySize?: number;
   build?: FunctionBuildOptions;
   uploadSourceMap?: boolean;
   env?: Record<string, any>;
@@ -121,6 +152,11 @@ export interface FunctionProps extends PlatformProps {
    * @default 3 seconds (AWS Lambda default)
    */
   timeout?: Duration.Duration;
+  /**
+   * Maximum number of concurrent executions reserved for this function.
+   * Omit to remove the function-level reserved concurrency limit.
+   */
+  reservedConcurrentExecutions?: number;
 }
 
 /**
@@ -165,6 +201,7 @@ export interface Function extends Resource<
     code: {
       hash: string;
     };
+    reservedConcurrentExecutions?: number;
   },
   {
     env?: Record<string, any>;
@@ -202,6 +239,26 @@ const normalizeFunctionUrl = (
   };
 };
 
+/**
+ * Evaluates a user-supplied Rolldown `external` option (string, RegExp, array,
+ * or predicate) for a single module id, preserving its original semantics.
+ */
+const matchesConfiguredExternal = (
+  external: rolldown.InputOptions["external"],
+  moduleId: string,
+  parentId: string | undefined,
+  isResolved: boolean,
+): boolean => {
+  if (external === undefined) return false;
+  if (typeof external === "function") {
+    return external(moduleId, parentId, isResolved) === true;
+  }
+  const matchers = Array.isArray(external) ? external : [external];
+  return matchers.some((matcher) =>
+    typeof matcher === "string" ? matcher === moduleId : matcher.test(moduleId),
+  );
+};
+
 /**
  * An AWS Lambda host resource that combines code bundling, IAM role
  * provisioning, and runtime binding collection.
@@ -220,7 +277,7 @@ const normalizeFunctionUrl = (
  * for plain handler patterns, or the
  * {@link https://alchemy.run/guides/lambda | Effect Lambda Guide}
  * for the full Effect-based approach with bindings, event sources, and sinks.
- *
+ * @resource
  * @section Async Functions
  * Point `main` at a file that exports a standard Lambda handler. No
  * Effect runtime is included in the bundle. Useful when migrating
@@ -237,6 +294,25 @@ const normalizeFunctionUrl = (
  * });
  * ```
  *
+ * @example Function using ARM64
+ * ```typescript
+ * const func = yield* AWS.Lambda.Function("ArmFunction", {
+ *   main: "./src/handler.ts",
+ *   architecture: "arm64",
+ * });
+ * ```
+ *
+ * @example Function with a native package (Sharp)
+ * ```typescript
+ * const func = yield* AWS.Lambda.Function("ImageProcessor", {
+ *   main: "./src/handler.ts",
+ *   architecture: "arm64",
+ *   build: {
+ *     install: ["sharp"],
+ *   },
+ * });
+ * ```
+ *
  * @example Writing the async handler
  * ```typescript
  * // src/handler.ts
@@ -598,7 +674,7 @@ export const FunctionProvider = () =>
           };
         });
 
-      const attachBindings = Effect.fnUntraced(function* ({
+      const attachBindings = Effect.fn(function* ({
         roleName,
         policyName,
         // functionArn,
@@ -650,7 +726,7 @@ export const FunctionProvider = () =>
         return env;
       });
 
-      const createRoleIfNotExists = Effect.fnUntraced(function* ({
+      const createRoleIfNotExists = Effect.fn(function* ({
         id,
         roleName,
         vpc,
@@ -715,41 +791,67 @@ export const FunctionProvider = () =>
         return role;
       });
 
-      const bundleCode = Effect.fnUntraced(function* (
+      const bundleCode = Effect.fn(function* (
         id: string,
         props: FunctionProps,
       ) {
-        const sourcemap = props.build?.output?.sourcemap ?? true;
+        const {
+          output: buildOutput,
+          install,
+          ...inputOptions
+        } = props.build ?? {};
+        const sourcemap = buildOutput?.sourcemap ?? true;
         const uploadSourceMap = props.uploadSourceMap ?? true;
 
         const realMain = yield* fs.realPath(props.main);
         const cwd = yield* TempRoot.findCwdForBundle(realMain);
 
         const rolldownSourcemap = sourcemap;
+        const architecture = props.architecture ?? "x86_64";
+
+        // Explicit install roots are excluded from the bundle and installed
+        // into the deployment artifact. build.external stays a pure Rolldown
+        // escape hatch and is not installed by Alchemy.
+        const requested = yield* normalizeInstallTargets(install);
+        const installRoots = new Set(Object.keys(requested));
+        const configuredExternal = inputOptions.external;
+        const externalOption = (
+          moduleId: string,
+          parentId: string | undefined,
+          isResolved: boolean,
+        ): boolean => {
+          if (moduleId.startsWith("@aws-sdk/")) return true;
+          for (const root of installRoots) {
+            if (matchesPackageRoot(moduleId, root)) return true;
+          }
+          return matchesConfiguredExternal(
+            configuredExternal,
+            moduleId,
+            parentId,
+            isResolved,
+          );
+        };
 
-        const buildBundle = Effect.fnUntraced(function* (
+        const buildBundle = Effect.fn(function* (
           entry: string,
           plugins?: rolldown.RolldownPluginOption,
         ) {
           return yield* Bundle.build(
             {
-              ...props.build?.input,
+              ...inputOptions,
               input: entry,
               cwd,
-              external: [
-                /^@aws-sdk\//,
-                ...((props.build?.input?.external as string[]) ?? []),
-              ],
+              external: externalOption,
               platform: "node",
-              plugins: [props.build?.input?.plugins, plugins],
+              plugins: [inputOptions.plugins, plugins],
             },
             {
-              ...props.build?.output,
+              ...buildOutput,
               format: "esm",
               sourcemap: rolldownSourcemap,
-              minify: props.build?.output?.minify ?? false,
+              minify: buildOutput?.minify ?? false,
               entryFileNames: "index.js",
-              codeSplitting: props.build?.output?.codeSplitting ?? false,
+              codeSplitting: buildOutput?.codeSplitting ?? false,
             },
           );
         });
@@ -852,15 +954,46 @@ export default await Effect.runPromise(handlerEffect)
             content: f.content,
           }));
 
-        const archive = yield* zipCode(
-          code,
-          extraFiles.length > 0 ? extraFiles : undefined,
-        );
-        return {
-          archive,
-          code,
-          hash: bundleOutput.hash,
-        };
+        // Resolve install versions without running npm so `diff` can compare a
+        // stable identity hash. The archive build performs the install.
+        const installIdentity = yield* resolvePackageInstallIdentity({
+          cwd,
+          requested,
+        });
+        const resolved = installIdentity.resolved;
+        const hasInstalledPackages = Object.keys(resolved).length > 0;
+
+        // Identity hash drives change detection in `diff`. With native packages,
+        // the installed bytes are not captured by the bundle hash, so fold the
+        // resolved versions, package-manager lockfile, and architecture in
+        // instead of installing.
+        const identityHash = hasInstalledPackages
+          ? yield* hashPackageInstallIdentity({
+              bundleHash: bundleOutput.hash,
+              identity: installIdentity,
+              architecture,
+            })
+          : bundleOutput.hash;
+
+        const buildArchive = Effect.gen(function* () {
+          const installedPackageFiles = hasInstalledPackages
+            ? yield* installResolvedPackages({ resolved, architecture })
+            : [];
+          const archiveFiles = [...extraFiles, ...installedPackageFiles];
+          const archive = yield* zipCode(
+            code,
+            archiveFiles.length > 0 ? archiveFiles : undefined,
+          );
+          // The S3 asset key is content-addressed, so the archive hash must be a
+          // true hash of the bytes when native packages are present.
+          const archiveHash =
+            installedPackageFiles.length > 0
+              ? yield* sha256(archive)
+              : bundleOutput.hash;
+          return { archive, archiveHash };
+        });
+
+        return { identityHash, buildArchive };
       });
 
       const withNodeSourceMaps = (
@@ -890,7 +1023,62 @@ export default await Effect.runPromise(handlerEffect)
         };
       };
 
-      const createOrUpdateFunction = Effect.fnUntraced(function* ({
+      const retryFunctionMutation = Effect.retry({
+        while: (e: any) =>
+          e._tag === "ResourceConflictException" ||
+          e._tag === "TooManyRequestsException",
+        schedule: Schedule.exponential(100).pipe(
+          Schedule.both(Schedule.recurs(30)),
+        ),
+      }) as <A, R, Err>(
+        self: Effect.Effect<A, Err, R>,
+      ) => Effect.Effect<A, Err, R>;
+
+      const getReservedConcurrentExecutions = Effect.fn(function* (
+        functionName: string,
+      ) {
+        return yield* Lambda.getFunctionConcurrency({
+          FunctionName: functionName,
+        }).pipe(
+          Effect.map((config) => config.ReservedConcurrentExecutions),
+          Effect.catchTag("ResourceNotFoundException", () =>
+            Effect.succeed(undefined),
+          ),
+        );
+      });
+
+      const syncReservedConcurrentExecutions = Effect.fn(function* ({
+        functionName,
+        reservedConcurrentExecutions,
+      }: {
+        functionName: string;
+        reservedConcurrentExecutions: number | undefined;
+      }) {
+        const current = yield* getReservedConcurrentExecutions(functionName);
+        if (current === reservedConcurrentExecutions) {
+          return current;
+        }
+
+        if (reservedConcurrentExecutions === undefined) {
+          yield* Lambda.deleteFunctionConcurrency({
+            FunctionName: functionName,
+          }).pipe(
+            retryFunctionMutation,
+            Effect.catchTag("ResourceNotFoundException", () => Effect.void),
+          );
+          return undefined;
+        }
+
+        const updated = yield* Lambda.putFunctionConcurrency({
+          FunctionName: functionName,
+          ReservedConcurrentExecutions: reservedConcurrentExecutions,
+        }).pipe(retryFunctionMutation);
+        return (
+          updated.ReservedConcurrentExecutions ?? reservedConcurrentExecutions
+        );
+      });
+
+      const createOrUpdateFunction = Effect.fn(function* ({
         id,
         news,
         roleArn,
@@ -958,6 +1146,8 @@ export default await Effect.runPromise(handlerEffect)
           Role: roleArn,
           Code: codeLocation,
           Runtime: news.runtime ?? "nodejs22.x",
+          Architectures: [news.architecture ?? "x86_64"],
+          MemorySize: news.memorySize,
           Environment: runtimeEnv
             ? {
                 Variables: {
@@ -1083,7 +1273,7 @@ export default await Effect.runPromise(handlerEffect)
       const publicUrlAccessStatementId = "FunctionURLAllowPublicAccess";
       const publicUrlInvokeStatementId = "FunctionURLAllowPublicInvoke";
 
-      const removePublicFunctionUrlPermissions = Effect.fnUntraced(function* (
+      const removePublicFunctionUrlPermissions = Effect.fn(function* (
         functionName: string,
       ) {
         yield* Effect.all(
@@ -1118,9 +1308,10 @@ export default await Effect.runPromise(handlerEffect)
               yield* Lambda.addPermission(permission);
             }),
           ),
+          retryFunctionMutation,
         );
 
-      const upsertPublicFunctionUrlPermissions = Effect.fnUntraced(function* (
+      const upsertPublicFunctionUrlPermissions = Effect.fn(function* (
         functionName: string,
       ) {
         yield* Effect.all(
@@ -1144,7 +1335,7 @@ export default await Effect.runPromise(handlerEffect)
         );
       });
 
-      const createOrUpdateFunctionUrl = Effect.fnUntraced(function* ({
+      const createOrUpdateFunctionUrl = Effect.fn(function* ({
         functionName,
         url,
         oldUrl,
@@ -1179,6 +1370,7 @@ export default await Effect.runPromise(handlerEffect)
             Effect.catchTag("ResourceConflictException", () =>
               Lambda.updateFunctionUrlConfig(config),
             ),
+            retryFunctionMutation,
           );
 
           if (desired.authType === "NONE") {
@@ -1197,6 +1389,7 @@ export default await Effect.runPromise(handlerEffect)
             Lambda.deleteFunctionUrlConfig({
               FunctionName: functionName,
             }).pipe(
+              retryFunctionMutation,
               Effect.catchTag("ResourceNotFoundException", () => Effect.void),
             ),
             removePublicFunctionUrlPermissions(functionName),
@@ -1206,18 +1399,18 @@ export default await Effect.runPromise(handlerEffect)
         return undefined;
       });
 
-      const summary = ({ code }: { code: Uint8Array<ArrayBufferLike> }) =>
+      const summary = ({ archive }: { archive: Uint8Array<ArrayBufferLike> }) =>
         `${
-          code.length >= 1024 * 1024
-            ? `${(code.length / (1024 * 1024)).toFixed(2)}MB`
-            : code.length >= 1024
-              ? `${(code.length / 1024).toFixed(2)}KB`
-              : `${code.length}B`
+          archive.length >= 1024 * 1024
+            ? `${(archive.length / (1024 * 1024)).toFixed(2)}MB`
+            : archive.length >= 1024
+              ? `${(archive.length / 1024).toFixed(2)}KB`
+              : `${archive.length}B`
         }`;
 
       return {
         stables: ["functionArn", "functionName", "roleName"],
-        diff: Effect.fnUntraced(function* ({ id, olds, news, output }) {
+        diff: Effect.fn(function* ({ id, olds, news, output }) {
           if (!isResolved(news)) return;
           // If output is undefined (resource in creating state), defer to default diff
           if (!output) {
@@ -1238,15 +1431,7 @@ export default await Effect.runPromise(handlerEffect)
           ) {
             return { action: "update" };
           }
-          if (
-            output.code.hash !==
-            (yield* bundleCode(id, {
-              main: news.main,
-              handler: news.handler,
-              build: news.build,
-              uploadSourceMap: news.uploadSourceMap,
-            })).hash
-          ) {
+          if (output.code.hash !== (yield* bundleCode(id, news)).identityHash) {
             // code changed
             return { action: "update" };
           }
@@ -1255,8 +1440,19 @@ export default await Effect.runPromise(handlerEffect)
           ) {
             return { action: "update" };
           }
+          if (
+            (olds.architecture ?? "x86_64") !== (news.architecture ?? "x86_64")
+          ) {
+            return { action: "update" };
+          }
+          if (
+            olds.reservedConcurrentExecutions !==
+            news.reservedConcurrentExecutions
+          ) {
+            return { action: "update" };
+          }
         }),
-        read: Effect.fnUntraced(function* ({ id, olds, output }) {
+        read: Effect.fn(function* ({ id, olds, output }) {
           const functionName =
             output?.functionName ??
             (yield* createFunctionName(id, olds?.functionName));
@@ -1292,6 +1488,8 @@ export default await Effect.runPromise(handlerEffect)
               Effect.succeed(undefined),
             ),
           );
+          const reservedConcurrentExecutions =
+            yield* getReservedConcurrentExecutions(fn.FunctionName);
           // Reuse the persisted output where we have it (e.g. code hash) so
           // diff doesn't see drift it can't reconstruct from the API.
           const attrs = {
@@ -1301,6 +1499,7 @@ export default await Effect.runPromise(handlerEffect)
             functionUrl,
             roleArn: fn.Role,
             roleName: output?.roleName ?? fn.Role.split("/").pop()!,
+            reservedConcurrentExecutions,
           } as any;
           return (yield* hasAlchemyTags(id, tagsResult))
             ? attrs
@@ -1337,6 +1536,8 @@ export default await Effect.runPromise(handlerEffect)
                       Effect.succeed(undefined),
                     ),
                   );
+                  const reservedConcurrentExecutions =
+                    yield* getReservedConcurrentExecutions(fn.FunctionName);
                   return {
                     functionArn: fn.FunctionArn,
                     functionName: fn.FunctionName,
@@ -1344,6 +1545,9 @@ export default await Effect.runPromise(handlerEffect)
                     roleArn: fn.Role,
                     roleName: fn.Role.split("/").pop()!,
                     code: { hash: "" },
+                    ...(reservedConcurrentExecutions === undefined
+                      ? {}
+                      : { reservedConcurrentExecutions }),
                   } satisfies Function["Attributes"];
                 }),
               { concurrency: 10 },
@@ -1353,7 +1557,7 @@ export default await Effect.runPromise(handlerEffect)
             );
           }),
 
-        precreate: Effect.fnUntraced(function* ({ id, news, session }) {
+        precreate: Effect.fn(function* ({ id, news, session }) {
           const { accountId, region } = yield* AWSEnvironment.current;
           const { roleName, functionName, roleArn } = yield* createNames(
             id,
@@ -1399,7 +1603,7 @@ export default await Effect.runPromise(handlerEffect)
             roleArn,
           };
         }),
-        reconcile: Effect.fnUntraced(function* ({
+        reconcile: Effect.fn(function* ({
           id,
           news,
           olds,
@@ -1423,14 +1627,15 @@ export default await Effect.runPromise(handlerEffect)
             bindings,
           });
 
-          const { archive, code, hash } = yield* bundleCode(id, news);
+          const { identityHash, buildArchive } = yield* bundleCode(id, news);
+          const { archive, archiveHash } = yield* buildArchive;
 
           yield* createOrUpdateFunction({
             id,
             news,
             roleArn,
             archive,
-            hash,
+            hash: archiveHash,
             env: {
               ...env,
               ...news.env,
@@ -1440,6 +1645,12 @@ export default await Effect.runPromise(handlerEffect)
             session,
           });
 
+          const reservedConcurrentExecutions =
+            yield* syncReservedConcurrentExecutions({
+              functionName,
+              reservedConcurrentExecutions: news.reservedConcurrentExecutions,
+            });
+
           const functionUrl = yield* createOrUpdateFunctionUrl({
             functionName,
             url: news.url,
@@ -1447,7 +1658,7 @@ export default await Effect.runPromise(handlerEffect)
             currentFunctionUrl: output?.functionUrl,
           });
 
-          yield* session.note(summary({ code }));
+          yield* session.note(summary({ archive }));
 
           return {
             ...output,
@@ -1457,11 +1668,12 @@ export default await Effect.runPromise(handlerEffect)
             roleName,
             roleArn,
             code: {
-              hash,
+              hash: identityHash,
             },
+            reservedConcurrentExecutions,
           };
         }),
-        delete: Effect.fnUntraced(function* ({ output }) {
+        delete: Effect.fn(function* ({ output }) {
           yield* iam
             .listRolePolicies({
               RoleName: output.roleName,

package/src/AWS/Lambda/InvokeFunction.ts

@@ -5,12 +5,14 @@ import * as Binding from "../../Binding.ts";
 import * as Output from "../../Output.ts";
 import type { Function } from "./Function.ts";
 import { isFunction } from "./Function.ts";
+import type { Providers } from "../Providers.ts";
 
 export interface InvokeFunctionRequest extends Omit<
   Lambda.InvocationRequest,
   "FunctionName"
 > {}
 
+/** @binding */
 export class InvokeFunction extends Binding.Service<
   InvokeFunction,
   (
@@ -43,7 +45,8 @@ export const InvokeFunctionLive = Layer.effect(
 
 export class InvokeFunctionPolicy extends Binding.Policy<
   InvokeFunctionPolicy,
-  (func: Function) => Effect.Effect<void>
+  (func: Function) => Effect.Effect<void>,
+  Providers
 >()("AWS.Lambda.InvokeFunction") {}
 
 export const InvokeFunctionPolicyLive = InvokeFunctionPolicy.layer.succeed(

package/src/AWS/Lambda/Permission.ts

@@ -82,7 +82,7 @@ export interface Permission extends Resource<
 /**
  * A Lambda permission that grants an AWS service or another account permission to
  * invoke a function.
- *
+ * @resource
  * @section Granting Permissions
  * @example S3 Notification Permission
  * ```typescript

package/src/AWS/Lambda/QueueEventSource.ts

@@ -12,12 +12,14 @@ import {
 } from "../SQS/QueueEventSource.ts";
 import { EventSourceMapping } from "./EventSourceMapping.ts";
 import * as Lambda from "./Function.ts";
+import type { Providers } from "../Providers.ts";
 
 export const isSQSEvent = (event: any): event is lambda.SQSEvent =>
   Array.isArray(event?.Records) &&
   event.Records.length > 0 &&
   event.Records[0].eventSource === "aws:sqs";
 
+/** @binding */
 export const QueueEventSource = Layer.effect(
   SQSQueueEventSource,
   // @ts-expect-error
@@ -52,7 +54,8 @@ export const QueueEventSource = Layer.effect(
 
 export class QueueEventSourcePolicy extends Binding.Policy<
   QueueEventSourcePolicy,
-  (queue: Queue, props: QueueEventSourceProps) => Effect.Effect<void>
+  (queue: Queue, props: QueueEventSourceProps) => Effect.Effect<void>,
+  Providers
 >()("AWS.SQS.QueueEventSourcePolicy") {}
 
 export const QueueEventSourcePolicyLive = QueueEventSourcePolicy.layer.effect(

package/src/AWS/Lambda/StreamEventSource.ts

@@ -12,6 +12,7 @@ import {
 } from "../Kinesis/StreamEventSource.ts";
 import { EventSourceMapping } from "./EventSourceMapping.ts";
 import * as Lambda from "./Function.ts";
+import type { Providers } from "../Providers.ts";
 
 export const isKinesisStreamEvent = (
   event: any,
@@ -20,6 +21,7 @@ export const isKinesisStreamEvent = (
   event.Records.length > 0 &&
   event.Records[0].eventSource === "aws:kinesis";
 
+/** @binding */
 export const StreamEventSource = Layer.effect(
   KinesisStreamEventSource,
   Effect.gen(function* () {
@@ -62,7 +64,8 @@ export const StreamEventSource = Layer.effect(
 
 export class StreamEventSourcePolicy extends Binding.Policy<
   StreamEventSourcePolicy,
-  (stream: KinesisStream, props: StreamEventSourceProps) => Effect.Effect<void>
+  (stream: KinesisStream, props: StreamEventSourceProps) => Effect.Effect<void>,
+  Providers
 >()("AWS.Kinesis.StreamEventSource") {}
 
 export const StreamEventSourcePolicyLive = StreamEventSourcePolicy.layer.effect(

package/src/AWS/Lambda/TableEventSource.ts

@@ -14,6 +14,7 @@ import {
 import type { Table } from "../DynamoDB/Table.ts";
 import { EventSourceMapping } from "./EventSourceMapping.ts";
 import * as Lambda from "./Function.ts";
+import type { Providers } from "../Providers.ts";
 
 export const isDynamoDBStreamEvent = (
   event: any,
@@ -22,6 +23,7 @@ export const isDynamoDBStreamEvent = (
   event.Records.length > 0 &&
   event.Records[0].eventSource === "aws:dynamodb";
 
+/** @binding */
 export const TableEventSource = Layer.effect(
   DynamoDBTableEventSource,
   Effect.gen(function* () {
@@ -65,7 +67,8 @@ export const TableEventSource = Layer.effect(
 
 export class TableEventSourcePolicy extends Binding.Policy<
   TableEventSourcePolicy,
-  (table: Table, props: StreamsProps) => Effect.Effect<void>
+  (table: Table, props: StreamsProps) => Effect.Effect<void>,
+  Providers
 >()("AWS.DynamoDB.TableEventSource") {}
 
 export const TableEventSourcePolicyLive = TableEventSourcePolicy.layer.effect(