alchemy

name	alchemy
description	Use this skill when working directly with any of the following - Cloudflare Workers, Durable Objects, R2, D1, SecretsStore, Queues, Hyperdrive, EmailRouting, EmailSending, Containers; Drizzle; Axiom
lastUpdated	"2026-06-07T00:00:00.000Z"

Alchemy

Alchemy Effect is an Infrastructure-as-Effects (IaE) framework that combines cloud infrastructure and application logic into a single, type-safe program powered by Effect. Resources are declared as Effects; bindings wire IAM, env vars, and typed SDKs in one call; deploys and runtime share the same code.

This file is a navigation index for the documentation site at https://v2.alchemy.run. Every page under /src/content/docs/ is listed below with its URL and a one-line summary, so an agent can pick the right page in one hop.

Start here

• What is Alchemy? — Alchemy is an Infrastructure-as-Effects framework that combines cloud infrastructure and application logic into a single type-safe program powered by Effect.
• Getting Started — Install Alchemy and create your first Stack in under two minutes.

Tutorial — main path (Cloudflare)

A linear five-part walkthrough from zero to a tested, locally-developed, CI-deployed Cloudflare project. Each part builds on the previous one.

• Part 1: Your First Stack — Install Alchemy, create a Stack with a Cloudflare R2 Bucket, and deploy it.
• Part 2: Add a Worker — Create a Cloudflare Worker, bind the R2 Bucket, and implement GET/PUT routes.
• Part 3: Testing — Write integration tests that deploy your stack and make HTTP requests against your live Worker.
• Part 4: Local Dev — Run your stack locally with alchemy dev for hot reloading and instant feedback.
• Part 5: CI/CD — Set up GitHub Actions for automated deployments, PR previews, and remote state — with Cloudflare credentials managed as code.

Tutorial — Cloudflare add-ons

Standalone tutorials that extend the main tutorial's Worker with a specific Cloudflare feature. Pick the ones that match your use case.

• Add a Durable Object — Add a Durable Object to your Worker — persist state per key, expose RPC methods, and stream values back to the client.
• Bind to another Worker's Durable Object — Share a Durable Object across multiple Workers — one Worker hosts the runtime, others bind to it by scriptName for a typed RPC stub.
• Accept WebSockets — Accept WebSocket connections in a Durable Object, broadcast between peers, and survive Cloudflare's hibernation.
• Add a Vite SPA — Ship a Vite single-page app from the same Stack as your Worker — built, bundled, and deployed to Cloudflare in one command.
• Run a Container — Run a long-lived container alongside a Durable Object, expose RPC methods, and proxy HTTP requests to ports inside the container.
• Add a Workflow — Orchestrate durable, multi-step work with Cloudflare Workflows — automatic retries, replayable steps, and at-least-once delivery.
• Add an AI Gateway — Wire an AI Gateway into your Worker, turn it into a typed Effect LanguageModel, and run generations and streams through Workers AI with caching, rate limiting, and logs.
• Build a Git Repo API — Build a mini-GitHub on Cloudflare — Artifacts for Git storage, a Durable Object per repo for metadata, fronted by a schema-typed HttpApi.
• Connect to a Database with Hyperdrive — Provision a Postgres or MySQL database (Neon, PlanetScale Postgres, or PlanetScale MySQL) and front it with Cloudflare Hyperdrive so your Worker reaches the database with edge-pooled, low-latency connections.
• Add Drizzle ORM — Replace raw pg with Drizzle's effect-postgres integration, manage your schema as a resource, and have alchemy generate and apply migrations on every deploy.
• Branch from a shared database — Have ephemeral PR-preview stages reference a long-lived Neon project from the staging stage instead of provisioning their own — fast previews, copy-on-write branches, no extra Postgres clusters.
• Consume from a Queue — Receive messages from a Cloudflare Queue with Cloudflare.messages(queue).subscribe(...) — Effect-style stream handler with automatic ack/retry.
• Define an RPC Worker — Define a typed Effect RPC group, serve it from Cloudflare.RpcWorker, drive it from an integration test, and (later) bind a typed client from another Worker.
• Add a typed RPC Durable Object — Replace alchemy's built-in DO method bridge with Cloudflare.RpcDurableObjectNamespace — a typed RPC group served on the DO's fetch, with a class-instance-preserving wire format. Walk through a single DO, drive it from a test, then layer in a Worker.

Tutorial — AWS

End-to-end AWS tutorials. Read the Lambda page first; the others bind storage and event sources to that Lambda.

• Deploy a Lambda Function — Stand up an AWS Lambda Function from a single Effect, expose it over a Function URL, and call it from a test.
• Read & Write S3 — Add an S3 Bucket to your Stack, bind PutObject and GetObject as runtime capabilities, and let Alchemy mint the IAM policy for you.
• React to S3 Events — Subscribe a Lambda Function to S3 bucket notifications, process them as an Effect Stream, and let Alchemy wire up the IAM and event-source plumbing.
• Store Records in DynamoDB — Add a DynamoDB Table, bind GetItem and PutItem to your Lambda, and serve a typed key/value HTTP API backed by DynamoDB.
• Process DynamoDB Streams — Enable a DynamoDB Stream on your table and consume change records as a typed Effect Stream from the same Lambda.
• Send & Consume SQS Messages — Add an SQS Queue, publish messages from your Lambda, and consume them from a second consumer Lambda — all wired through Alchemy bindings.
• Stream Records with Kinesis — Add a Kinesis Data Stream, publish records from one Lambda, and consume them in order from another — wired through the same Stream-shaped event source.
• REST API (API Gateway v1) — Expose a Lambda with a regional Amazon API Gateway REST API using RestApi, Resource, Method, Deployment, and Stage primitives.

Concepts — the mental model

Reference pages explaining what each primitive means and how they fit together. Read these when something in a tutorial feels magical, or before designing a new Stack.

• Stack — A Stack is a collection of Resources deployed together as a unit.
• Resource — Resources are named cloud entities with input properties and output attributes.
• Action — A node in the dependency graph that runs an Effect during apply when its inputs change.
• Inputs and Outputs — Output is alchemy's lazy reference type — the lazy values that flow between resources, get composed with .pipe, mapped, interpolated, and resolved during deploy.
• References — Read values out of another stack or stage at plan time — typed, lazy, and resolved from persisted state.
• Resource Lifecycle — How alchemy plans, applies, replaces, and destroys resources — and how to think about idempotency and recovery.
• Provider — Providers implement the lifecycle operations for a resource type — reconcile, delete, diff, read, and more.
• Platform — A Platform bundles infrastructure with the runtime code that runs on it — Workers, Lambda Functions, Containers — so your handler ships with its bindings.
• Phases — Alchemy programs run in two phases — plantime/init drives the deploy, runtime handles requests. Knowing which is which is the key to using Platforms.
• Binding — A binding connects a resource to a Worker or Lambda. It generates IAM policies, env vars, and a typed SDK in one call.
• Secrets and Config — Use effect/Config to read env vars at init time and have Alchemy automatically bind them onto the deploy target.
• Layers — A Layer encapsulates a slice of infrastructure (resources, bindings, runtime logic) behind a typed service interface. Code that depends on the interface stays cloud-agnostic; swapping the implementation swaps the underlying infrastructure.
• State Store — How Alchemy persists resource state between deploys to compute diffs and track infrastructure.
• Testing — Reference for alchemy/Test — every helper, hook, and option exposed by Test.make for Bun and Vitest.
• Local Development — How alchemy dev provides hot reloading, local workerd execution, and cloud-backed resources for fast iteration.
• Observability — Effect emits OpenTelemetry — ship traces, metrics, and logs to Axiom, Datadog, CloudWatch, or any OTLP endpoint. Declare dashboards and alarms in code.
• Profiles — Profiles store cloud credentials per environment in ~/.alchemy/profiles.json — switch between work and personal accounts, or between staging and prod credentials.
• Stages — Stages are isolated instances of a Stack — dev_sam, staging, prod, pr-42 — each with their own state and physical names.

Guides — task-oriented

Standalone how-to pages. Each solves a specific problem; read in any order.

• Migrating from v1 — Migrate your Alchemy v1 (async/await) project to Alchemy v2.
• CLI Reference — All Alchemy CLI commands — deploy, destroy, plan, dev, tail, logs, aws, cloudflare, login, profile, and state.
• Continuous Integration — Set up CI/CD pipelines for alchemy projects with GitHub Actions, automated deployments, and PR previews — with provider credentials managed as code.
• Monorepos — Two patterns for organizing an Alchemy monorepo with a backend API and a frontend website — one shared stack (recommended) or one stack per package — with the trade-offs and a working example for each.
• Secrets and env vars — Wire OPENAI_API_KEY from .env into a Cloudflare Worker as a secret_text binding.
• Effect HTTP API — Build a schema-validated HTTP API with Effect's HttpApi module and deploy it as a Cloudflare Worker.
• Shared database across stages — Have ephemeral PR-preview stages reference a long-lived Neon Postgres project from staging instead of provisioning their own — fast previews, copy-on-write branches, no extra Postgres clusters.
• Effect RPC — Build a typed RPC API with Effect's Rpc module and deploy it as a Cloudflare Worker.
• Frontend frameworks — Deploy Vite-based frameworks (TanStack Start, Astro, SolidStart, Nuxt, React) and any custom-built static site (Hugo, Eleventy) to Cloudflare with one declaration.
• Circular Bindings — How to model two services that reference each other (Worker A ↔ Worker B, Lambda ↔ Lambda) using tagged classes and Layers.
• Effect AI — Wire Effect's LanguageModel and Chat services into a Cloudflare Worker — read API keys with effect/Config, provide the model layer to your handler, plug in persistence.
• Building Infrastructure Layers — Package resources + bindings + runtime glue into a typed Effect Layer, then swap a KV-backed implementation for an R2-backed one without touching the consumer.
• Writing a Custom State Store — Build a Postgres-backed Alchemy state store step by step — implement the StateService interface, plug it into a stack, and test it end-to-end.
• Writing a Custom Resource Provider — Add support for a new cloud or third-party API by declaring a Resource type and implementing its lifecycle as an Effect Layer.

Providers

Per-resource API reference, generated from JSDoc on the source .ts files via bun generate:api-reference. Each page documents the resource's input properties (with types, defaults, and constraints), output attributes, and Quick Reference / Examples sections derived from @section / @example JSDoc tags. Grouped by cloud below.

AWS

• AccessEntry — An Amazon EKS access entry that grants an IAM principal access to a cluster.
• AccessKey — An IAM access key for a user.
• Account — Account-level settings for Amazon API Gateway in the current region (CloudWatch logging role, etc.).
• Account — A member account created and managed by AWS Organizations.
• AccountAlias — The singleton IAM account alias for an AWS account.
• AccountAssignment — Assigns an IAM Identity Center permission set to a user or group in an AWS account.
• AccountPasswordPolicy — The singleton IAM account password policy.
• Addon — An Amazon EKS managed add-on installed on a cluster.
• Alarm — A CloudWatch metric alarm.
• AlarmMuteRule — A CloudWatch alarm mute rule.
• AnomalyDetector — A CloudWatch anomaly detector.
• ApiKey — API Gateway API key for usage plans and apiKeyRequired methods.
• AssetDeployment — Upload a local directory into S3 with website-friendly defaults.
• Authorizer — REST API Lambda, Cognito, or gateway authorizer.
• AutoScalingGroup — An EC2 Auto Scaling Group that manages a fleet of instances from a launch template and can register that fleet with one or more load balancer target groups.
• BasePathMapping — Maps a custom domain name path to a REST API stage.
• Bucket — An S3 bucket for storing objects in AWS.
• CachePolicy — A CloudFront cache policy.
• CapacityProvider — An Amazon ECS capacity provider backed by an EC2 Auto Scaling Group.
• Certificate — An ACM certificate for CloudFront and other AWS endpoints.
• Cluster — An Amazon ECS cluster for running tasks and services.
• Cluster — An Amazon EKS cluster with support for EKS Auto Mode settings.
• CompositeAlarm — A CloudWatch composite alarm.
• Dashboard — An Amazon CloudWatch dashboard.
• DBCluster — An Aurora DB cluster.
• DBClusterEndpoint — A custom Aurora cluster endpoint.
• DBClusterParameterGroup — An Aurora cluster parameter group.
• DBInstance — An Aurora cluster instance.
• DBParameterGroup — An RDS DB parameter group, useful for Aurora cluster instances.
• DBProxy — An RDS Proxy for pooled Lambda-to-Aurora connectivity.
• DBProxyEndpoint — An additional RDS Proxy endpoint.
• DBProxyTargetGroup — The proxy target group that registers Aurora clusters or instances behind an RDS Proxy.
• DBSubnetGroup — An RDS DB subnet group for Aurora clusters, instances, and proxies.
• DelegatedAdministrator — Registers a delegated administrator account for a trusted AWS service.
• Deployment — A point-in-time snapshot of a REST API, ready to be served through a Stage.
• Distribution — A CloudFront distribution.
• DomainName — Custom domain name for an Amazon API Gateway REST API.
• EgressOnlyInternetGateway — API reference for EgressOnlyInternetGateway
• EIP — API reference for EIP
• EventBus — An Amazon EventBridge event bus for receiving and routing events.
• EventSourceMapping — API reference for EventSourceMapping
• Function — A CloudFront Function for viewer request and response customization.
• Function — An AWS Lambda host resource that combines code bundling, IAM role provisioning, and runtime binding collection.
• GatewayResponse — Gateway response mapping for a REST API (e.g. DEFAULT_4XX, DEFAULT_5XX).
• Group — An IAM group that can own managed and inline policies.
• Group — A group in the IAM Identity Center identity store.
• GroupMembership — An explicit IAM group membership resource that owns a group's managed users.
• InsightRule — A CloudWatch Contributor Insights rule.
• Instance — An EC2 instance that can either act as a low-level compute primitive or run a bundled long-lived Effect program directly on the machine.
• Instance — An IAM Identity Center instance visible to the current account.
• InstanceProfile — An IAM instance profile that can present a role to EC2 instances.
• InternetGateway — API reference for InternetGateway
• Invalidation — A CloudFront cache invalidation request.
• KeyGroup — A CloudFront key group.
• KeyValueStore — A CloudFront KeyValueStore for edge metadata.
• KvEntries — Manages namespaced key-value entries in a CloudFront KeyValueStore.
• KvRoutesUpdate — Manages a single route entry in a JSON array stored in a CloudFront KeyValueStore.
• LaunchTemplate — A launch template that preserves the Host authoring model used by AWS.EC2.Instance, but packages that host configuration for use with an Auto Scaling Group.
• Listener — API reference for Listener
• LoadBalancer — API reference for LoadBalancer
• LogGroup — A CloudWatch Logs log group.
• LoginProfile — An IAM console login profile for a user.
• Method — An HTTP method on an API Gateway Resource.
• MetricStream — A CloudWatch metric stream.
• NatGateway — API reference for NatGateway
• NetworkAcl — API reference for NetworkAcl
• NetworkAclAssociation — API reference for NetworkAclAssociation
• NetworkAclEntry — API reference for NetworkAclEntry
• OpenIDConnectProvider — An IAM OpenID Connect provider for web identity federation.
• Organization — The AWS Organization for the current management account.
• OrganizationalUnit — An AWS Organizations organizational unit.
• OrganizationResourcePolicy — The singleton AWS Organizations resource policy.
• OriginAccessControl — A CloudFront Origin Access Control for private origins.
• OriginRequestPolicy — A CloudFront origin request policy.
• Permission — An EventBridge event bus permission statement.
• Permission — A Lambda permission that grants an AWS service or another account permission to invoke a function.
• PermissionSet — An IAM Identity Center permission set.
• PodIdentityAssociation — An Amazon EKS pod identity association that binds a service account to an IAM role.
• Policy — A customer-managed IAM policy.
• Policy — An AWS Organizations policy such as an SCP or tag policy.
• PolicyAttachment — Attaches an Organizations policy to a root, OU, or account.
• PublicKey — A CloudFront public key.
• Queue — An Amazon SQS queue for reliable, decoupled message processing.
• Record — A Route 53 DNS record set.
• Repository — An Amazon ECR repository for container images.
• ResponseHeadersPolicy — A CloudFront response headers policy.
• RestApi — An Amazon API Gateway REST API (v1).
• Role — An IAM role for AWS services and runtimes.
• Root — The organization root.
• RootPolicyType — Enables a policy type on an organization root.
• Route — API reference for Route
• RouteTable — API reference for RouteTable
• RouteTableAssociation — API reference for RouteTableAssociation
• Rule — An Amazon EventBridge rule that matches events and routes them to targets.
• SAMLProvider — An IAM SAML identity provider.
• ScalingPolicy — A target-tracking scaling policy for an Auto Scaling Group.
• Schedule — An EventBridge Scheduler schedule.
• ScheduleGroup — An EventBridge Scheduler schedule group.
• Secret — An AWS Secrets Manager secret.
• SecurityGroup — Ingress or egress rule for a security group.
• SecurityGroupRule — API reference for SecurityGroupRule
• ServerCertificate — An IAM server certificate.
• Service — An ECS Fargate service for running long-lived tasks.
• ServiceSpecificCredential — A service-specific IAM credential.
• SigningCertificate — An IAM signing certificate for a user.
• SSHPublicKey — An IAM SSH public key for CodeCommit-compatible workflows.
• Stage — A stage for a REST API deployment.
• Stream — An Amazon Kinesis Data Stream.
• StreamConsumer — A registered Kinesis enhanced fan-out consumer.
• Subnet — API reference for Subnet
• Subscription — An Amazon SNS subscription that attaches an endpoint to a topic.
• Table — An Amazon DynamoDB table with optional indexes, PITR, TTL, and stream-aware binding support.
• TargetGroup — API reference for TargetGroup
• Task — API reference for Task
• Topic — An Amazon SNS topic for fan-out messaging and notifications.
• TrustedServiceAccess — Enables trusted access for an AWS service principal.
• UsagePlan — Usage plan for API stages, throttling, and quotas.
• UsagePlanKey — Associates an API key with a usage plan.
• User — An IAM user with optional inline policies, managed policies, and tags.
• VirtualMFADevice — An IAM virtual MFA device.
• Vpc — API reference for Vpc
• VpcEndpoint — API reference for VpcEndpoint
• VpcLink — VPC link for private integrations (connectionType: \"VPC_LINK\" on a method integration).

Axiom

• Annotation — An Axiom annotation — a vertical marker overlaid on charts to flag a deploy, incident, feature flag flip, or any other point/range event you want correlated with telemetry.
• ApiToken — An Axiom API token — a scoped bearer token used to authenticate API requests (ingest, query, admin). Capabilities are pinned at creation time; changing any field triggers a replacement because Axiom does not expose an update endpoint.
• Dashboard — An Axiom dashboard — a named, layout-driven collection of charts. Each dashboard takes a full document (charts + layout array of grid cells + timeWindow + refreshTime) at version schemaVersion: 2.
• Dataset — An Axiom dataset — the top-level container that stores events, logs, traces, or metrics. Pick a kind up-front: it determines schema and how the data is shown in the UI, and cannot be changed after creation (changing it triggers a replacement, which deletes the data).
• Monitor — An Axiom monitor — a scheduled APL/MPL query that evaluates on a fixed cadence and fires alerts via {@link Notifier notifiers} when its condition is met.
• Notifier — An Axiom notifier — an alert destination (Slack, email, PagerDuty, Opsgenie, Discord, Microsoft Teams, generic webhook, or a fully custom webhook with templated body/headers) that {@link Monitor monitors} target via notifierIds. Exactly one channel under properties should be set.
• View — An Axiom saved view — a named, shareable APL query. Useful for building starter dashboards, providing canned "open in Axiom" links from your app, or pinning common investigations the team revisits.
• VirtualField — An Axiom virtual field — a saved APL expression that appears as a derived column on a dataset at query time. Use these to standardise common computations (status classes, latency buckets, parsed JSON paths) so dashboards and monitors don't have to redefine them.

Build

• Command — A Build resource that runs a shell command and produces an output asset. Input files are hashed using globs to avoid redundant rebuilds.
• DevServer — A long-lived shell process scoped to a stack instance, started during alchemy dev and restarted when inputs change. During deploy this is a no-op — DevServer resources only run in dev mode.

Cloudflare

• AccountApiToken — A Cloudflare account-owned API token (POST /accounts/{account_id}/tokens).
• AiGateway — A Cloudflare AI Gateway for observability, caching, rate limiting, and governance across AI provider requests.
• AiGatewayBinding — Binding service that turns an {@link AiGatewayResource} resource into a typed {@link AiGatewayClient} for Worker runtime code. Wraps the Cloudflare AI Gateway runtime binding so each operation returns an Effect tagged with {@link AiGatewayError}, exposes the raw Workers AI handle for ai.run(...), and provides a model(options) factory that produces an effect/unstable/ai LanguageModel Layer.
• AnalyticsEngineDataset — A Cloudflare Workers Analytics Engine dataset binding.
• Browser — A Cloudflare Browser Rendering binding for launching headless browser sessions from Workers via @cloudflare/puppeteer.
• Container — A Cloudflare Container that runs a long-lived process alongside a Durable Object.
• D1Database — A Cloudflare D1 serverless SQL database built on SQLite.
• DnsRead — Binding that lets a Worker read Cloudflare DNS records at runtime.
• DnsReadWrite — Binding that lets a Worker perform the full Cloudflare DNS record CRUD surface at runtime.
• DnsWrite — Binding that lets a Worker create, update, and delete Cloudflare DNS records at runtime.
• DurableObjectChatPersistence — 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.
• DurableObjectNamespace — A Cloudflare Durable Object namespace that manages globally unique, stateful instances with WebSocket hibernation support.
• DynamicWorkerLoader — Load and run ephemeral Workers at runtime from inline JavaScript modules.
• EmailAddress — A verified destination email address on the account.
• EmailRouting — Enables Cloudflare Email Routing on a zone. This is the prerequisite for receiving mail at any address on the domain and for sending email from a Worker via send_email bindings.
• EmailRule — A Cloudflare Email Routing rule.
• Hyperdrive — A Cloudflare Hyperdrive configuration.
• HyperdriveBinding — A typed accessor for a Cloudflare Hyperdrive runtime binding inside a Worker. Provides the same shape as the raw Hyperdrive runtime object (connection string, host, port, user, password, database) plus a raw escape hatch for libraries that want direct access.
• KVNamespace — A Cloudflare Workers KV namespace for key-value storage at the edge.
• Queue — A Cloudflare Queue for reliable message passing between Workers.
• QueueConsumer — A Cloudflare Queue Consumer that processes messages from a Queue.
• R2Bucket — A Cloudflare R2 object storage bucket with S3-compatible API.
• RpcDurableObjectNamespace — RpcDurableObjectNamespace is sugar over {@link DurableObjectNamespace} for Durable Objects whose surface is a typed Effect RpcGroup. The DO serves an RpcServer.toHttpEffect(group) on its own fetch, and consumers see namespace.getByName(id) as a typed RpcClient directly — no manual client wiring.
• RpcWorker — RpcWorker is a thin sugar over {@link Worker} for the common case where a worker's entire fetch surface is a typed Effect RpcGroup. It takes the rpc schema directly in props alongside main, and accepts an init Effect that returns the already-piped RpcServer.toHttpEffect(...)-producing Effect (no { fetch } wrapper) — the wrapper plugs it into the worker's fetch for you.
• Ruleset — A Cloudflare Ruleset phase entrypoint for a zone.
• Secret — A single secret stored inside a Cloudflare Secrets Store.
• SecretsStore — A Cloudflare Secrets Store, a per-account container for secrets that can be bound into Workers with full redaction and audit support.
• SendEmail — A Cloudflare Workers send_email binding descriptor.
• SendEmailBinding — A typed runtime accessor for a Cloudflare send_email Worker binding.
• StaticSite — A Cloudflare Worker that serves static assets built by a shell command.
• Tunnel — A Cloudflare Tunnel that establishes a secure connection from your origin to Cloudflare's edge.
• TunnelRead — Binding that lets a Worker read Cloudflare Tunnels at runtime.
• TunnelReadWrite — Binding that lets a Worker perform the full Cloudflare Tunnel CRUD surface at runtime.
• TunnelWrite — Binding that lets a Worker create, update, and delete Cloudflare Tunnels at runtime.
• UserApiToken — A Cloudflare user-owned API token (POST /user/tokens).
• VectorizeIndex — A Cloudflare Vectorize index for storing and querying vector embeddings.
• VectorizeMetadataIndex — A metadata index on a Cloudflare Vectorize index.
• VersionMetadata — A Cloudflare Workers Version Metadata binding.
• Vite — A Cloudflare Worker deployed from a Vite project.
• VpcService — A Cloudflare VPC service that exposes a private host (IP or hostname) reachable through a Cloudflare Tunnel for Workers VPC.
• Worker — A Cloudflare Worker host with deploy-time binding support and runtime export collection.
• Workflow — Service that carries the current workflow event payload. yield* WorkflowEvent inside a workflow body to access it.
• WorkflowBridge — Create a WorkflowBridge class that extends WorkflowEntrypoint and delegates the run(event, step) call to the Effect-native workflow body registered via worker.export(...).
• ZarazConfig — A Cloudflare Zaraz zone configuration.
• Zone — A Cloudflare Zone (DNS domain) managed by Alchemy.

Drizzle

• Postgres — Open a Drizzle/Postgres database from a connection URL using the drizzle-orm/effect-postgres integration.
• Schema — A Drizzle schema managed as an Alchemy resource.

GitHub

• Comment — A GitHub issue or pull request comment.
• Secret — A GitHub Actions repository or environment secret.
• Variable — A GitHub Actions repository variable.

Neon

• Branch — A branch of a Neon project.
• Project — A Neon serverless Postgres project.

Planetscale

• MySQLBranch — A PlanetScale branch of a {@link MySQLDatabase}. For PostgreSQL branches use {@link PostgresBranch} instead.
• MySQLDatabase — A MySQL PlanetScale database (powered by Vitess). For PostgreSQL use {@link PostgresDatabase} instead.
• MySQLPassword — A PlanetScale password for accessing a MySQL database branch.
• PostgresBranch — A PlanetScale branch of a {@link PostgresDatabase}. For MySQL branches use {@link MySQLBranch} instead.
• PostgresDatabase — A PostgreSQL PlanetScale database. For MySQL, use {@link MySQLDatabase} instead.
• PostgresDefaultRole — The default PlanetScale PostgreSQL role for a database branch.
• PostgresRole — A PlanetScale role for accessing a PostgreSQL database branch.