alchemy 2.0.0-beta.59 → 2.0.0-beta.60

package/src/AWS/Lambda/CreateShellAuthToken.ts

@@ -0,0 +1,42 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface CreateShellAuthTokenRequest
+  extends microvms.CreateMicrovmShellAuthTokenRequest {}
+
+/**
+ * Runtime binding for `CreateMicrovmShellAuthToken`.
+ *
+ * Bind it to a {@link MicrovmImage} to get a callable that mints a short-lived
+ * token for interactive shell access to a running MicroVM (the MicroVM must
+ * have been run with the shell ingress connector attached).
+ * @binding
+ * @section Auth Tokens
+ * @example Mint a shell auth token
+ * ```typescript
+ * const createShellAuthToken = yield* AWS.Lambda.CreateShellAuthToken(Sandbox);
+ * const { authToken } = yield* createShellAuthToken({
+ *   microvmIdentifier: vm.microvmId,
+ *   expirationInMinutes: 5,
+ * });
+ * ```
+ */
+export interface CreateShellAuthToken extends Binding.Service<
+  CreateShellAuthToken,
+  "AWS.Lambda.CreateShellAuthToken",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: CreateShellAuthTokenRequest,
+    ) => Effect.Effect<
+      microvms.CreateMicrovmShellAuthTokenResponse,
+      microvms.CreateMicrovmShellAuthTokenError
+    >
+  >
+> {}
+export const CreateShellAuthToken = Binding.Service<CreateShellAuthToken>(
+  "AWS.Lambda.CreateShellAuthToken",
+);

package/src/AWS/Lambda/CreateShellAuthTokenHttp.ts

@@ -0,0 +1,11 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { CreateShellAuthToken } from "./CreateShellAuthToken.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const CreateShellAuthTokenHttp = makeImageBinding({
+  binding: CreateShellAuthToken,
+  name: "CreateShellAuthToken",
+  actions: ["lambda:CreateMicrovmShellAuthToken"],
+  operation: microvms.createMicrovmShellAuthToken,
+  scope: "microvm",
+});

package/src/AWS/Lambda/DeleteMicrovmImageVersion.ts

@@ -0,0 +1,36 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface DeleteMicrovmImageVersionRequest extends Omit<
+  microvms.DeleteMicrovmImageVersionInput,
+  "imageIdentifier"
+> {}
+
+/**
+ * Runtime binding for `DeleteMicrovmImageVersion`.
+ *
+ * Bind it to a {@link MicrovmImage} to delete a specific image version (the
+ * `imageIdentifier` is injected). Idempotent.
+ * @binding
+ * @section Image Versions
+ */
+export interface DeleteMicrovmImageVersion extends Binding.Service<
+  DeleteMicrovmImageVersion,
+  "AWS.Lambda.DeleteMicrovmImageVersion",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: DeleteMicrovmImageVersionRequest,
+    ) => Effect.Effect<
+      microvms.DeleteMicrovmImageVersionOutput,
+      microvms.DeleteMicrovmImageVersionError
+    >
+  >
+> {}
+export const DeleteMicrovmImageVersion =
+  Binding.Service<DeleteMicrovmImageVersion>(
+    "AWS.Lambda.DeleteMicrovmImageVersion",
+  );

package/src/AWS/Lambda/DeleteMicrovmImageVersionHttp.ts

@@ -0,0 +1,12 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { DeleteMicrovmImageVersion } from "./DeleteMicrovmImageVersion.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const DeleteMicrovmImageVersionHttp = makeImageBinding({
+  binding: DeleteMicrovmImageVersion,
+  name: "DeleteMicrovmImageVersion",
+  actions: ["lambda:DeleteMicrovmImageVersion"],
+  operation: microvms.deleteMicrovmImageVersion,
+  scope: "image",
+  injectImageIdentifier: true,
+});

package/src/AWS/Lambda/Function.ts

@@ -13,6 +13,7 @@ import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
 import * as Stream from "effect/Stream";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type * as rolldown from "rolldown";
 import { Unowned } from "../../AdoptPolicy.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
@@ -36,6 +37,7 @@ import { Resource, type ResourceBinding } from "../../Resource.ts";
 import { Self } from "../../Self.ts";
 import * as Serverless from "../../Serverless/index.ts";
 import { Stack } from "../../Stack.ts";
+import { Stage } from "../../Stage.ts";
 import {
   createInternalTags,
   createTagsList,
@@ -333,7 +335,7 @@ const matchesConfiguredExternal = (
  * ```typescript
  * export default class ApiFunction extends AWS.Lambda.Function<ApiFunction>()(
  *   "ApiFunction",
- *   { main: import.meta.filename, url: true },
+ *   { main: import.meta.url, url: true },
  *   Effect.gen(function* () {
  *     // init: bind resources
  *     const getItem = yield* AWS.DynamoDB.GetItem(table);
@@ -803,7 +805,7 @@ export const FunctionProvider = () =>
         const sourcemap = buildOutput?.sourcemap ?? true;
         const uploadSourceMap = props.uploadSourceMap ?? true;
 
-        const realMain = yield* fs.realPath(props.main);
+        const realMain = yield* TempRoot.resolveMainPath(props.main);
         const cwd = yield* TempRoot.findCwdForBundle(realMain);
 
         const rolldownSourcemap = sourcemap;
@@ -1078,7 +1080,21 @@ export default await Effect.runPromise(handlerEffect)
         );
       });
 
-      const createOrUpdateFunction = Effect.fn(function* ({
+      const createOrUpdateFunction: (input: {
+        id: string;
+        news: FunctionProps;
+        roleArn: string;
+        archive: Uint8Array<ArrayBufferLike>;
+        hash: string;
+        env: Record<string, string> | undefined;
+        functionName: string;
+        preferUpdate?: boolean;
+        session: { note: (note: string) => Effect.Effect<void> };
+      }) => Effect.Effect<
+        void,
+        any,
+        Credentials | Region | HttpClient | Stack | Stage | AWSEnvironment
+      > = Effect.fn(function* ({
         id,
         news,
         roleArn,
@@ -1240,7 +1256,7 @@ export default await Effect.runPromise(handlerEffect)
               yield* Effect.logDebug(`updated function configuration ${id}`);
             }),
           ),
-        );
+        ) as Effect.Effect<any, any, Credentials | Region | HttpClient>;
 
         const create = Lambda.createFunction(createFunctionRequest).pipe(
           Effect.tapError((e) =>
@@ -1257,7 +1273,7 @@ export default await Effect.runPromise(handlerEffect)
           Effect.catchTags({
             ResourceConflictException: () => getAndUpdate,
           }),
-        );
+        ) as Effect.Effect<any, any, Credentials | Region | HttpClient>;
 
         if (preferUpdate) {
           yield* getAndUpdate.pipe(
@@ -1674,6 +1690,8 @@ export default await Effect.runPromise(handlerEffect)
           };
         }),
         delete: Effect.fn(function* ({ output }) {
+          // The role may already be gone (e.g. deleted out-of-band or by a
+          // previous partial delete) — treat every step as idempotent.
           yield* iam
             .listRolePolicies({
               RoleName: output.roleName,
@@ -1682,13 +1700,21 @@ export default await Effect.runPromise(handlerEffect)
               Effect.flatMap((policies) =>
                 Effect.all(
                   (policies.PolicyNames ?? []).map((policyName) =>
-                    iam.deleteRolePolicy({
-                      RoleName: output.roleName,
-                      PolicyName: policyName,
-                    }),
+                    iam
+                      .deleteRolePolicy({
+                        RoleName: output.roleName,
+                        PolicyName: policyName,
+                      })
+                      .pipe(
+                        Effect.catchTag(
+                          "NoSuchEntityException",
+                          () => Effect.void,
+                        ),
+                      ),
                   ),
                 ),
               ),
+              Effect.catchTag("NoSuchEntityException", () => Effect.void),
             );
 
           yield* iam
@@ -1713,6 +1739,7 @@ export default await Effect.runPromise(handlerEffect)
                   ),
                 ),
               ),
+              Effect.catchTag("NoSuchEntityException", () => Effect.void),
             );
 
           yield* Lambda.deleteFunction({

package/src/AWS/Lambda/GetMicrovm.ts

@@ -0,0 +1,32 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface GetMicrovmRequest extends microvms.GetMicrovmRequest {}
+
+/**
+ * Runtime binding for `GetMicrovm`.
+ *
+ * Bind it to a {@link MicrovmImage} to get a callable that reads the state,
+ * endpoint, and configuration of a running MicroVM by `microvmIdentifier`.
+ * @binding
+ * @section Inspecting MicroVMs
+ * @example Get a MicroVM
+ * ```typescript
+ * const getMicrovm = yield* AWS.Lambda.GetMicrovm(Sandbox);
+ * const vm = yield* getMicrovm({ microvmIdentifier: id });
+ * ```
+ */
+export interface GetMicrovm extends Binding.Service<
+  GetMicrovm,
+  "AWS.Lambda.GetMicrovm",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: GetMicrovmRequest,
+    ) => Effect.Effect<microvms.GetMicrovmResponse, microvms.GetMicrovmError>
+  >
+> {}
+export const GetMicrovm = Binding.Service<GetMicrovm>("AWS.Lambda.GetMicrovm");

package/src/AWS/Lambda/GetMicrovmHttp.ts

@@ -0,0 +1,13 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { GetMicrovm } from "./GetMicrovm.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const GetMicrovmHttp = makeImageBinding({
+  binding: GetMicrovm,
+  name: "GetMicrovm",
+  actions: ["lambda:GetMicrovm"],
+  operation: microvms.getMicrovm,
+  // MicroVM instance ARNs are minted at runtime; scope to the image's
+  // `microvm:*` glob (this account/region) rather than `["*"]`.
+  scope: "microvm",
+});

package/src/AWS/Lambda/GetMicrovmImage.ts

@@ -0,0 +1,40 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface GetMicrovmImageRequest extends Omit<
+  microvms.GetMicrovmImageInput,
+  "imageIdentifier"
+> {}
+
+/**
+ * Runtime binding for `GetMicrovmImage`.
+ *
+ * Bind it to a {@link MicrovmImage} to read the image's state and versions at
+ * runtime (the `imageIdentifier` is injected).
+ * @binding
+ * @section Image Reads
+ * @example Get the image
+ * ```typescript
+ * const getMicrovmImage = yield* AWS.Lambda.GetMicrovmImage(Sandbox);
+ * const image = yield* getMicrovmImage({});
+ * ```
+ */
+export interface GetMicrovmImage extends Binding.Service<
+  GetMicrovmImage,
+  "AWS.Lambda.GetMicrovmImage",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: GetMicrovmImageRequest,
+    ) => Effect.Effect<
+      microvms.GetMicrovmImageOutput,
+      microvms.GetMicrovmImageError
+    >
+  >
+> {}
+export const GetMicrovmImage = Binding.Service<GetMicrovmImage>(
+  "AWS.Lambda.GetMicrovmImage",
+);

package/src/AWS/Lambda/GetMicrovmImageBuild.ts

@@ -0,0 +1,35 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface GetMicrovmImageBuildRequest extends Omit<
+  microvms.GetMicrovmImageBuildInput,
+  "imageIdentifier"
+> {}
+
+/**
+ * Runtime binding for `GetMicrovmImageBuild`.
+ *
+ * Bind it to a {@link MicrovmImage} to read a per-architecture build's state and
+ * snapshot info (the `imageIdentifier` is injected).
+ * @binding
+ * @section Image Builds
+ */
+export interface GetMicrovmImageBuild extends Binding.Service<
+  GetMicrovmImageBuild,
+  "AWS.Lambda.GetMicrovmImageBuild",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: GetMicrovmImageBuildRequest,
+    ) => Effect.Effect<
+      microvms.GetMicrovmImageBuildOutput,
+      microvms.GetMicrovmImageBuildError
+    >
+  >
+> {}
+export const GetMicrovmImageBuild = Binding.Service<GetMicrovmImageBuild>(
+  "AWS.Lambda.GetMicrovmImageBuild",
+);

package/src/AWS/Lambda/GetMicrovmImageBuildHttp.ts

@@ -0,0 +1,12 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { GetMicrovmImageBuild } from "./GetMicrovmImageBuild.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const GetMicrovmImageBuildHttp = makeImageBinding({
+  binding: GetMicrovmImageBuild,
+  name: "GetMicrovmImageBuild",
+  actions: ["lambda:GetMicrovmImageBuild"],
+  operation: microvms.getMicrovmImageBuild,
+  scope: "image",
+  injectImageIdentifier: true,
+});

package/src/AWS/Lambda/GetMicrovmImageHttp.ts

@@ -0,0 +1,12 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { GetMicrovmImage } from "./GetMicrovmImage.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const GetMicrovmImageHttp = makeImageBinding({
+  binding: GetMicrovmImage,
+  name: "GetMicrovmImage",
+  actions: ["lambda:GetMicrovmImage"],
+  operation: microvms.getMicrovmImage,
+  scope: "image",
+  injectImageIdentifier: true,
+});

package/src/AWS/Lambda/GetMicrovmImageVersion.ts

@@ -0,0 +1,35 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface GetMicrovmImageVersionRequest extends Omit<
+  microvms.GetMicrovmImageVersionInput,
+  "imageIdentifier"
+> {}
+
+/**
+ * Runtime binding for `GetMicrovmImageVersion`.
+ *
+ * Bind it to a {@link MicrovmImage} to read the configuration and state of a
+ * specific image version (the `imageIdentifier` is injected).
+ * @binding
+ * @section Image Reads
+ */
+export interface GetMicrovmImageVersion extends Binding.Service<
+  GetMicrovmImageVersion,
+  "AWS.Lambda.GetMicrovmImageVersion",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: GetMicrovmImageVersionRequest,
+    ) => Effect.Effect<
+      microvms.GetMicrovmImageVersionOutput,
+      microvms.GetMicrovmImageVersionError
+    >
+  >
+> {}
+export const GetMicrovmImageVersion = Binding.Service<GetMicrovmImageVersion>(
+  "AWS.Lambda.GetMicrovmImageVersion",
+);

package/src/AWS/Lambda/GetMicrovmImageVersionHttp.ts

@@ -0,0 +1,12 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { GetMicrovmImageVersion } from "./GetMicrovmImageVersion.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const GetMicrovmImageVersionHttp = makeImageBinding({
+  binding: GetMicrovmImageVersion,
+  name: "GetMicrovmImageVersion",
+  actions: ["lambda:GetMicrovmImageVersion"],
+  operation: microvms.getMicrovmImageVersion,
+  scope: "image",
+  injectImageIdentifier: true,
+});

package/src/AWS/Lambda/ListManagedMicrovmImageVersions.ts

@@ -0,0 +1,31 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+
+export interface ListManagedMicrovmImageVersionsRequest
+  extends microvms.ListManagedMicrovmImageVersionsInput {}
+
+/**
+ * Runtime binding for `ListManagedMicrovmImageVersions` (account-scoped).
+ *
+ * Lists versions of an AWS-managed base MicroVM image. Bind with no resource:
+ * `yield* AWS.Lambda.ListManagedMicrovmImageVersions()`.
+ * @binding
+ * @section Managed Base Images
+ */
+export interface ListManagedMicrovmImageVersions extends Binding.Service<
+  ListManagedMicrovmImageVersions,
+  "AWS.Lambda.ListManagedMicrovmImageVersions",
+  () => Effect.Effect<
+    (
+      request: ListManagedMicrovmImageVersionsRequest,
+    ) => Effect.Effect<
+      microvms.ListManagedMicrovmImageVersionsOutput,
+      microvms.ListManagedMicrovmImageVersionsError
+    >
+  >
+> {}
+export const ListManagedMicrovmImageVersions =
+  Binding.Service<ListManagedMicrovmImageVersions>(
+    "AWS.Lambda.ListManagedMicrovmImageVersions",
+  );

package/src/AWS/Lambda/ListManagedMicrovmImageVersionsHttp.ts

@@ -0,0 +1,10 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { ListManagedMicrovmImageVersions } from "./ListManagedMicrovmImageVersions.ts";
+import { makeAccountBinding } from "./MicrovmBinding.ts";
+
+export const ListManagedMicrovmImageVersionsHttp = makeAccountBinding({
+  binding: ListManagedMicrovmImageVersions,
+  name: "ListManagedMicrovmImageVersions",
+  actions: ["lambda:ListManagedMicrovmImageVersions"],
+  operation: microvms.listManagedMicrovmImageVersions,
+});

package/src/AWS/Lambda/ListManagedMicrovmImages.ts

@@ -0,0 +1,31 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+
+export interface ListManagedMicrovmImagesRequest
+  extends microvms.ListManagedMicrovmImagesInput {}
+
+/**
+ * Runtime binding for `ListManagedMicrovmImages` (account-scoped).
+ *
+ * Lists the AWS-managed base MicroVM images available for use as
+ * `baseImage`. Bind with no resource: `yield* AWS.Lambda.ListManagedMicrovmImages()`.
+ * @binding
+ * @section Managed Base Images
+ */
+export interface ListManagedMicrovmImages extends Binding.Service<
+  ListManagedMicrovmImages,
+  "AWS.Lambda.ListManagedMicrovmImages",
+  () => Effect.Effect<
+    (
+      request: ListManagedMicrovmImagesRequest,
+    ) => Effect.Effect<
+      microvms.ListManagedMicrovmImagesOutput,
+      microvms.ListManagedMicrovmImagesError
+    >
+  >
+> {}
+export const ListManagedMicrovmImages =
+  Binding.Service<ListManagedMicrovmImages>(
+    "AWS.Lambda.ListManagedMicrovmImages",
+  );

package/src/AWS/Lambda/ListManagedMicrovmImagesHttp.ts

@@ -0,0 +1,10 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { ListManagedMicrovmImages } from "./ListManagedMicrovmImages.ts";
+import { makeAccountBinding } from "./MicrovmBinding.ts";
+
+export const ListManagedMicrovmImagesHttp = makeAccountBinding({
+  binding: ListManagedMicrovmImages,
+  name: "ListManagedMicrovmImages",
+  actions: ["lambda:ListManagedMicrovmImages"],
+  operation: microvms.listManagedMicrovmImages,
+});

package/src/AWS/Lambda/ListMicrovmImageBuilds.ts

@@ -0,0 +1,36 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface ListMicrovmImageBuildsRequest extends Omit<
+  microvms.ListMicrovmImageBuildsInput,
+  "imageIdentifier"
+> {}
+
+/**
+ * Runtime binding for `ListMicrovmImageBuilds`.
+ *
+ * Bind it to a {@link MicrovmImage} to list builds for an image version,
+ * optionally filtered by architecture/chipset (the `imageIdentifier` is
+ * injected).
+ * @binding
+ * @section Image Builds
+ */
+export interface ListMicrovmImageBuilds extends Binding.Service<
+  ListMicrovmImageBuilds,
+  "AWS.Lambda.ListMicrovmImageBuilds",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: ListMicrovmImageBuildsRequest,
+    ) => Effect.Effect<
+      microvms.ListMicrovmImageBuildsOutput,
+      microvms.ListMicrovmImageBuildsError
+    >
+  >
+> {}
+export const ListMicrovmImageBuilds = Binding.Service<ListMicrovmImageBuilds>(
+  "AWS.Lambda.ListMicrovmImageBuilds",
+);

package/src/AWS/Lambda/ListMicrovmImageBuildsHttp.ts

@@ -0,0 +1,12 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { ListMicrovmImageBuilds } from "./ListMicrovmImageBuilds.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const ListMicrovmImageBuildsHttp = makeImageBinding({
+  binding: ListMicrovmImageBuilds,
+  name: "ListMicrovmImageBuilds",
+  actions: ["lambda:ListMicrovmImageBuilds"],
+  operation: microvms.listMicrovmImageBuilds,
+  scope: "image",
+  injectImageIdentifier: true,
+});

package/src/AWS/Lambda/ListMicrovmImageVersions.ts

@@ -0,0 +1,36 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface ListMicrovmImageVersionsRequest extends Omit<
+  microvms.ListMicrovmImageVersionsInput,
+  "imageIdentifier"
+> {}
+
+/**
+ * Runtime binding for `ListMicrovmImageVersions`.
+ *
+ * Bind it to a {@link MicrovmImage} to list the image's versions (the
+ * `imageIdentifier` is injected).
+ * @binding
+ * @section Image Reads
+ */
+export interface ListMicrovmImageVersions extends Binding.Service<
+  ListMicrovmImageVersions,
+  "AWS.Lambda.ListMicrovmImageVersions",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: ListMicrovmImageVersionsRequest,
+    ) => Effect.Effect<
+      microvms.ListMicrovmImageVersionsOutput,
+      microvms.ListMicrovmImageVersionsError
+    >
+  >
+> {}
+export const ListMicrovmImageVersions =
+  Binding.Service<ListMicrovmImageVersions>(
+    "AWS.Lambda.ListMicrovmImageVersions",
+  );

package/src/AWS/Lambda/ListMicrovmImageVersionsHttp.ts

@@ -0,0 +1,12 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { ListMicrovmImageVersions } from "./ListMicrovmImageVersions.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const ListMicrovmImageVersionsHttp = makeImageBinding({
+  binding: ListMicrovmImageVersions,
+  name: "ListMicrovmImageVersions",
+  actions: ["lambda:ListMicrovmImageVersions"],
+  operation: microvms.listMicrovmImageVersions,
+  scope: "image",
+  injectImageIdentifier: true,
+});

package/src/AWS/Lambda/ListMicrovms.ts

@@ -0,0 +1,40 @@
+import type * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import type * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { MicrovmImage } from "./MicrovmImage.ts";
+
+export interface ListMicrovmsRequest extends Omit<
+  microvms.ListMicrovmsRequest,
+  "imageIdentifier"
+> {}
+
+/**
+ * Runtime binding for `ListMicrovms`.
+ *
+ * Bind it to a {@link MicrovmImage} to get a callable that lists the MicroVMs
+ * launched from that image (the `imageIdentifier` filter is injected).
+ * @binding
+ * @section Inspecting MicroVMs
+ * @example List MicroVMs
+ * ```typescript
+ * const listMicrovms = yield* AWS.Lambda.ListMicrovms(Sandbox);
+ * const { items } = yield* listMicrovms({});
+ * ```
+ */
+export interface ListMicrovms extends Binding.Service<
+  ListMicrovms,
+  "AWS.Lambda.ListMicrovms",
+  (
+    image: MicrovmImage,
+  ) => Effect.Effect<
+    (
+      request: ListMicrovmsRequest,
+    ) => Effect.Effect<
+      microvms.ListMicrovmsResponse,
+      microvms.ListMicrovmsError
+    >
+  >
+> {}
+export const ListMicrovms = Binding.Service<ListMicrovms>(
+  "AWS.Lambda.ListMicrovms",
+);

package/src/AWS/Lambda/ListMicrovmsHttp.ts

@@ -0,0 +1,12 @@
+import * as microvms from "@distilled.cloud/aws/lambda-microvms";
+import { ListMicrovms } from "./ListMicrovms.ts";
+import { makeImageBinding } from "./MicrovmBinding.ts";
+
+export const ListMicrovmsHttp = makeImageBinding({
+  binding: ListMicrovms,
+  name: "ListMicrovms",
+  actions: ["lambda:ListMicrovms"],
+  operation: microvms.listMicrovms,
+  scope: "account",
+  injectImageIdentifier: true,
+});