alchemy 2.0.0-beta.55 → 2.0.0-beta.57

package/src/Cloudflare/Workers/Worker.ts

@@ -1,4 +1,5 @@
 import type * as cf from "@cloudflare/workers-types";
+import type { ContainerImage } from "@distilled.cloud/cloudflare-runtime/Docker";
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as zones from "@distilled.cloud/cloudflare/zones";
 import type * as Config from "effect/Config";
@@ -10,6 +11,7 @@ import * as Path from "effect/Path";
 import * as Predicate from "effect/Predicate";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
 import * as crypto from "node:crypto";
 import { Unowned } from "../../AdoptPolicy.ts";
 import * as Artifacts from "../../Artifacts.ts";
@@ -34,10 +36,12 @@ import {
   type AssetsProps,
 } from "./Assets.ts";
 import { getCompatibility } from "./Compatibility.ts";
-import { isDurableObjectExport } from "./DurableObjectNamespace.ts";
+import {
+  isDurableObjectExport,
+  type DurableObjectExport,
+} from "./DurableObjectNamespace.ts";
 import { LocalWorkerProvider } from "./LocalWorkerProvider.ts";
 import { Request } from "./Request.ts";
-import * as Vite from "./Vite.ts";
 import {
   bindWorkerAsyncBindings,
   getCronBindings,
@@ -48,12 +52,17 @@ import type {
   WorkerBindings,
   WorkerSettingsBinding,
 } from "./WorkerBinding.ts";
-import { WorkerBundle } from "./WorkerBundle.ts";
+import {
+  readPrebuiltWorkerBundle,
+  WorkerBundle,
+  type ModuleRule,
+} from "./WorkerBundle.ts";
 import { createWorkerName } from "./WorkerName.ts";
 import {
   makeWorkerRuntimeContext,
   type WorkerRuntimeContext,
 } from "./WorkerRuntimeContext.ts";
+import type { WorkflowExport } from "./Workflow.ts";
 
 export const WorkerTypeId = "Cloudflare.Worker";
 export type WorkerTypeId = typeof WorkerTypeId;
@@ -133,7 +142,8 @@ export type WorkerServices =
   | Worker
   | Request
   | WorkerExecutionContext
-  | WorkerEnvironment;
+  | WorkerEnvironment
+  | CloudflareEnvironment;
 
 export type WorkerShape = Main<WorkerServices>;
 
@@ -234,7 +244,12 @@ export interface WorkerProps<
   };
   limits?: WorkerLimits;
   placement?: WorkerPlacement;
-  exports?: string[];
+  /**
+   * Tracks Durable Object and Workflow exports for Effect-native Workers only.
+   * Populated automatically from bindings; do not set manually.
+   * @internal
+   */
+  exports?: Record<string, DurableObjectExport | WorkflowExport>;
   /**
    * Environment variables and native Cloudflare Bindings to bind to
    * the Worker. Accepts:
@@ -272,6 +287,39 @@ export interface WorkerProps<
    * options used to build this Worker. See {@link Bundle.BundleExtraOptions}.
    */
   build?: Bundle.BundleExtraOptions;
+  /**
+   * Whether to bundle {@link main} with rolldown before upload.
+   *
+   * Set to `false` when `main` already points at a complete,
+   * runtime-ready ESM Worker produced by an external tool (OpenNext,
+   * a separate rolldown/esbuild pipeline, etc.). The entry and every
+   * file around it matching {@link rules} are uploaded byte-for-byte —
+   * no bundling, no minification, no transformation. Module names are
+   * the files' POSIX paths relative to the entry's directory, matching
+   * Wrangler's `no_bundle` contract.
+   *
+   * Re-bundling such artifacts is unsafe: dynamic `import()` calls the
+   * upstream tool relies on can be rewritten in ways that break runtime
+   * behavior.
+   *
+   * Durable Object and Workflow classes must be exported by the prebuilt
+   * entry itself — {@link exports} is not applied when `bundle` is
+   * `false`.
+   *
+   * @default true
+   */
+  bundle?: boolean;
+  /**
+   * Module rules selecting which files in the directory containing
+   * {@link main} are uploaded as additional modules when {@link bundle}
+   * is `false`. Each rule's globs are matched against POSIX-style paths
+   * relative to that directory, mirroring Wrangler's `rules`
+   * configuration. When provided, these rules replace
+   * {@link defaultModuleRules}.
+   *
+   * @default defaultModuleRules — ESModule (`**\/*.js`, `**\/*.mjs`), CompiledWasm (`**\/*.wasm`), Text (`**\/*.txt`, `**\/*.html`, `**\/*.sql`), Data (`**\/*.bin`)
+   */
+  rules?: ModuleRule[];
   /**
    * Options for the local dev server that runs this Worker under `alchemy dev`.
    * Each Worker is served on its own port.
@@ -325,7 +373,7 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
   },
   {
     bindings?: WorkerBinding[];
-    containers?: { className: string }[];
+    containers?: { className: string; dev: ContainerImage | undefined }[];
     crons?: string[];
     hyperdrives?: Record<string, Required<HyperdriveDevOrigin>>;
   },
@@ -363,7 +411,9 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * - **Async** — plain `async fetch` handler, no Effect runtime in the bundle.
  * - **Effect** — Effect implementation passed directly, single file.
  * - **Layer** — class and `.make()` in a single file; Rolldown tree-shakes `.make()` from consumers.
- *
+ * @resource
+ * @product Workers
+ * @category Workers & Compute
  * @section Async Workers
  * You don't have to use Effect for your runtime code. If you create
  * a Worker resource with `main` pointing at a file but provide no
@@ -517,6 +567,21 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * }
  * ```
  *
+ * @example Deploying a prebuilt Worker without bundling
+ * When `main` already points at a complete, runtime-ready ESM bundle
+ * produced by an external tool (e.g. OpenNext), set `bundle: false` to
+ * upload it byte-for-byte. The entry's directory is walked recursively
+ * and every file matching the module rules (by default `.js`, `.mjs`,
+ * `.wasm`, `.txt`, `.html`, `.sql`, and `.bin`) is uploaded as an
+ * additional module named by its path relative to that directory.
+ * ```typescript
+ * {
+ *   main: "./.open-next/worker.js",
+ *   bundle: false,
+ *   assets: "./.open-next/assets",
+ * }
+ * ```
+ *
  * @section Observability
  * Cloudflare Workers Observability is on by default — `logs.enabled` and
  * `logs.invocationLogs` are turned on if you don't pass an `observability`
@@ -781,7 +846,7 @@ export const LiveWorkerProvider = () =>
       // When enabling we also set `previewsEnabled: true` so the
       // script is reachable both at its stable workers.dev URL and at
       // version-preview URLs; on disable we send just `enabled: false`.
-      const setWorkerSubdomain = Effect.fnUntraced(function* (
+      const setWorkerSubdomain = Effect.fn(function* (
         name: string,
         enabled: boolean,
       ) {
@@ -819,7 +884,7 @@ export const LiveWorkerProvider = () =>
       const normalizeCrons = (crons: string[] | undefined): string[] =>
         Array.from(new Set(crons ?? []));
 
-      const getWorkerCrons = Effect.fnUntraced(function* (scriptName: string) {
+      const getWorkerCrons = Effect.fn(function* (scriptName: string) {
         const { accountId } = yield* yield* CloudflareEnvironment;
         return yield* workers
           .getScriptSchedule({
@@ -867,8 +932,7 @@ export const LiveWorkerProvider = () =>
             })
             .pipe(
               Effect.retry({
-                while: (error: { _tag?: string }) =>
-                  error?._tag === "WorkerNotFound",
+                while: (error) => error._tag === "WorkerNotFound",
                 schedule: Schedule.exponential(200).pipe(
                   Schedule.both(Schedule.recurs(15)),
                 ),
@@ -970,7 +1034,7 @@ export const LiveWorkerProvider = () =>
           // no-op for Cloudflare and avoids the "already in use" 409.
           // If it's attached to a *different* Worker, refuse with a
           // clear message rather than silently re-routing traffic.
-          const attachDomain = Effect.fnUntraced(function* (hostname: string) {
+          const attachDomain = Effect.fn(function* (hostname: string) {
             const live = liveByHostname.get(hostname);
             if (live) {
               return {
@@ -1020,8 +1084,7 @@ export const LiveWorkerProvider = () =>
               })
               .pipe(
                 Effect.retry({
-                  while: (error: { _tag?: string }) =>
-                    error?._tag === "WorkerNotFound",
+                  while: (error) => error._tag === "WorkerNotFound",
                   schedule: Schedule.exponential(200).pipe(
                     Schedule.both(Schedule.recurs(15)),
                   ),
@@ -1086,7 +1149,7 @@ export const LiveWorkerProvider = () =>
           ),
         );
 
-      const getWorkerSettingsWithDurableObjects = Effect.fnUntraced(function* (
+      const getWorkerSettingsWithDurableObjects = Effect.fn(function* (
         scriptName: string,
         expectedClassNames: readonly string[],
       ) {
@@ -1125,7 +1188,7 @@ export const LiveWorkerProvider = () =>
           );
       });
 
-      const prepareAssets = Effect.fnUntraced(function* (
+      const prepareAssets = Effect.fn(function* (
         assets: WorkerProps["assets"],
       ) {
         if (!assets) {
@@ -1144,37 +1207,45 @@ export const LiveWorkerProvider = () =>
       });
 
       const prepareBundle = (id: string, props: WorkerProps) =>
-        bundler
-          .build({
-            id,
-            main: props.main!,
-            compatibility: getCompatibility(props),
-            entry: props.isExternal
-              ? {
-                  kind: "external",
-                }
-              : {
-                  kind: "effect",
-                  exports: (props.exports ?? {}) as any,
-                },
-            stack: { name: stack.name, stage: stack.stage },
-            extraOptions: props.build,
-          })
-          .pipe(Artifacts.cached("build"));
+        (props.bundle === false
+          ? readPrebuiltWorkerBundle({
+              main: props.main!,
+              rules: props.rules,
+            })
+          : bundler.build({
+              id,
+              main: props.main!,
+              compatibility: getCompatibility(props),
+              entry: props.isExternal
+                ? {
+                    kind: "external",
+                  }
+                : {
+                    kind: "effect",
+                    exports: props.exports ?? {},
+                  },
+              stack: { name: stack.name, stage: stack.stage },
+              extraOptions: props.build,
+            })
+        ).pipe(Artifacts.cached("build"));
 
       const hashScript = (script: string) =>
         Effect.sync(() =>
           crypto.createHash("sha256").update(script).digest("hex"),
         );
 
-      const viteBuild = Effect.fnUntraced(function* (props: WorkerProps) {
+      const viteBuild = Effect.fn(function* (props: WorkerProps) {
         const compatibility = getCompatibility(props);
+        // Loaded lazily: `./Vite.ts` pulls in `@distilled.cloud/cloudflare-vite-plugin`
+        // (~0.5s), which is only needed for vite-based workers at build time —
+        // not for every Worker definition at module-load time.
+        const Vite = yield* Effect.promise(() => import("./Vite.ts"));
         const { assetsDirectory, serverBundle } = yield* Vite.viteBuild(
           props.vite?.rootDir,
           Object.fromEntries(
             (yield* Effect.all(
               Object.entries(props.env ?? {}).map(
-                Effect.fnUntraced(function* ([key, value]) {
+                Effect.fn(function* ([key, value]) {
                   return [
                     key,
                     typeof value === "string"
@@ -1303,7 +1374,7 @@ export const LiveWorkerProvider = () =>
         return { config, hash, skip: hash === output?.hash?.assets };
       };
 
-      const putWorker = Effect.fnUntraced(function* (
+      const putWorker = Effect.fn(function* (
         id: string,
         news: WorkerProps,
         bindings: ResourceBinding<Worker["Binding"]>[],
@@ -1409,6 +1480,11 @@ export const LiveWorkerProvider = () =>
             name: "ALCHEMY_STAGE",
             text: stack.stage,
           },
+          {
+            type: "plain_text",
+            name: "ALCHEMY_CLOUDFLARE_ACCOUNT_ID",
+            text: accountId,
+          },
         );
         // Add environment variables as metadata bindings
         if (news.env) {
@@ -1701,10 +1777,10 @@ export const LiveWorkerProvider = () =>
           // provider for DO-namespace propagation and for `putScript` itself.
           yield* setWorkerSubdomain(name, desiredSubdomainEnabled).pipe(
             Effect.retry({
-              while: (error: { _tag?: string }) =>
-                error?._tag === "WorkerNotFound" ||
-                error?._tag === "InternalServerError" ||
-                error?._tag === "UnknownCloudflareError",
+              while: (error) =>
+                error._tag === "WorkerNotFound" ||
+                error._tag === "InternalServerError" ||
+                error._tag === "UnknownCloudflareError",
               schedule: Schedule.exponential(200).pipe(
                 Schedule.both(Schedule.recurs(15)),
               ),
@@ -1747,7 +1823,7 @@ export const LiveWorkerProvider = () =>
         } satisfies Worker["Attributes"];
       });
 
-      const hasChanged = Effect.fnUntraced(function* (
+      const hasChanged = Effect.fn(function* (
         id: string,
         props: WorkerProps,
         output: Worker["Attributes"],
@@ -1811,13 +1887,57 @@ export const LiveWorkerProvider = () =>
 
       return Worker.Provider.of({
         stables: ["workerId", "workerName"],
-        diff: Effect.fnUntraced(function* ({
-          id,
-          news,
-          olds,
-          output,
-          newBindings,
-        }) {
+        list: () =>
+          Effect.gen(function* () {
+            const { accountId } = yield* yield* CloudflareEnvironment;
+            // Account-scoped enumeration of every Worker script. The
+            // per-script `read` makes several extra calls (subdomain,
+            // settings, domains, schedule) to fully hydrate
+            // url/durableObjectNamespaces/domains/crons. Doing that for
+            // every script on the account is both expensive (4 calls × N)
+            // and fragile — a single script with a binding shape the
+            // settings schema doesn't know about would break the whole
+            // listing (the same reason `read` deliberately avoids
+            // `listScripts`). For `list()` we hydrate the core identifying
+            // and settings fields that come straight from the script
+            // metadata and leave the binding-derived fields at the same
+            // defaults `read` returns when those sub-resources are absent
+            // (`url: undefined`, `durableObjectNamespaces: {}`,
+            // `domains: []`, `crons: []`). `accountId` + `workerName` are
+            // sufficient for `delete`.
+            return yield* workers.listScripts.pages({ accountId }).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  // Annotate the element type as the full `Attributes` shape
+                  // (incl. the optional `hash`) so it matches `read` exactly.
+                  // `list()` is an inference source for the provider's resource
+                  // type; a narrower element (e.g. via `satisfies`, which omits
+                  // `hash`) would derail `Res` inference and cascade every
+                  // lifecycle method's requirement channel to `never`.
+                  (page.result ?? []).flatMap(
+                    (script): Worker["Attributes"][] =>
+                      script.id
+                        ? [
+                            {
+                              accountId,
+                              workerId: script.id,
+                              workerName: script.id,
+                              logpush: script.logpush ?? undefined,
+                              url: undefined,
+                              tags: script.tags ?? undefined,
+                              durableObjectNamespaces: {},
+                              domains: [],
+                              crons: [],
+                            },
+                          ]
+                        : [],
+                  ),
+                ),
+              ),
+            );
+          }),
+        diff: Effect.fn(function* ({ id, news, olds, output, newBindings }) {
           const { accountId } = yield* yield* CloudflareEnvironment;
           if (!isResolved(news)) return undefined;
           if ((output?.accountId ?? accountId) !== accountId) {
@@ -1854,22 +1974,83 @@ export const LiveWorkerProvider = () =>
           const cronsChanged =
             newCrons.length !== oldCrons.length ||
             newCrons.some((cron, index) => cron !== oldCrons[index]);
+          // `url` is `domains[0]`: the first custom domain in user order if
+          // any, otherwise the workers.dev URL (derived from the stable
+          // worker name + account subdomain). It's stable across this update
+          // exactly when that first domain is unchanged — which is NOT the
+          // same as "the domain set is unchanged": adding a second custom
+          // domain leaves `url` put, while reordering changes it even though
+          // the set is equal. Compute the resulting `url` and carry it
+          // forward as a stable only when it matches the old one, so
+          // downstream resources that reference `worker.url` (e.g. a GitHub
+          // Webhook delivery URL built via `Output.interpolate`) resolve it
+          // to a concrete value during planning instead of an unresolved
+          // Output — otherwise every worker update spuriously re-updates them.
+          const newCustomDomains = normalizeDomains(news.domain);
+          const newUrl =
+            newCustomDomains.length > 0
+              ? `https://${newCustomDomains[0]}`
+              : news.url !== false
+                ? (output.domains ?? []).find((u) => u.endsWith(".workers.dev"))
+                : undefined;
+          const urlStable = newUrl !== undefined && newUrl === output.url;
+          // `durableObjectNamespaces` maps each hosted DO class name to the
+          // namespace id Cloudflare assigned it. Those ids are permanent for
+          // the lifetime of a (worker, class) pair, so the map only changes
+          // when a class is added or removed — never on a plain code/config
+          // update. Carry it forward as a stable whenever the set of local DO
+          // class names is unchanged, for the same reason as `url` above:
+          // downstream resources that bind a DO namespace via
+          // `worker.durableObjectNamespaces[name]` (e.g. a Container attached
+          // to a DO) must resolve it to a concrete value during planning.
+          // Otherwise the binding holds an unresolved Output, which
+          // `diffBindings` treats as "changed", spuriously re-updating the
+          // bound resource on every deploy. Class names are structural (not the
+          // namespace id), so this comparison holds even when `newBindings` is
+          // otherwise unresolved.
+          const newDoClassNames = Array.isArray(newBindings)
+            ? getExpectedDurableObjectClassNames(
+                (newBindings as ResourceBinding<Worker["Binding"]>[]).flatMap(
+                  (b) => b.data.bindings ?? [],
+                ),
+                workerName,
+              ).sort()
+            : [];
+          const oldDoClassNames = Object.keys(
+            output.durableObjectNamespaces ?? {},
+          ).sort();
+          const doNamespacesStable =
+            oldWorkerName === workerName &&
+            newDoClassNames.length === oldDoClassNames.length &&
+            newDoClassNames.every((name, i) => name === oldDoClassNames[i]);
           if (
             domainsChanged ||
             cronsChanged ||
             (yield* hasChanged(id, news, output))
           ) {
+            // `workerId` is always stable across an update; seed it so it
+            // survives now that `diff.stables` overrides `provider.stables`
+            // rather than being merged with it.
+            const stables: string[] = ["workerId"];
+            if (oldWorkerName === workerName) {
+              stables.push("workerName");
+            }
+            if (urlStable) {
+              stables.push("url");
+            }
+            if (doNamespacesStable) {
+              stables.push("durableObjectNamespaces");
+            }
             return {
               action: "update",
-              stables:
-                oldWorkerName === workerName ? ["workerName"] : undefined,
+              stables: stables.length > 0 ? stables : undefined,
             };
           }
         }),
-        precreate: Effect.fnUntraced(function* ({ id, news, session }) {
+        precreate: Effect.fn(function* ({ id, news, session }) {
           const { accountId } = yield* yield* CloudflareEnvironment;
           const name = yield* createWorkerName(id, news.name);
-          const exportMap = (news.exports ?? {}) as Record<string, unknown>;
+          const exportMap = news.exports ?? {};
           const durableObjects = Object.keys(exportMap)
             .filter((logicalId) => isDurableObjectExport(exportMap[logicalId]))
             .map((logicalId) => ({
@@ -2010,7 +2191,7 @@ export const LiveWorkerProvider = () =>
             crons: [],
           } satisfies Worker["Attributes"];
         }),
-        read: Effect.fnUntraced(
+        read: Effect.fn(
           function* ({ id, output, olds }) {
             const { accountId } = yield* yield* CloudflareEnvironment;
             const workerName =
@@ -2101,7 +2282,7 @@ export const LiveWorkerProvider = () =>
               ),
             ),
         ),
-        reconcile: Effect.fnUntraced(function* ({
+        reconcile: Effect.fn(function* ({
           id,
           news,
           olds,
@@ -2166,7 +2347,7 @@ export const LiveWorkerProvider = () =>
             existingSettings,
           );
         }),
-        delete: Effect.fnUntraced(function* ({ output }) {
+        delete: Effect.fn(function* ({ output }) {
           yield* Effect.logInfo(
             `Cloudflare Worker delete: deleting ${output.workerName}`,
           );

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -6,11 +6,14 @@ import * as Output from "../../Output.ts";
 import type { ResourceBinding } from "../../Resource.ts";
 import { isYieldableEffectLike } from "../../Util/effect.ts";
 import { isAiGateway } from "../AiGateway/AiGateway.ts";
+import { isAiSearchInstance } from "../AiSearch/AiSearchInstance.ts";
+import { isAiSearchNamespace } from "../AiSearch/AiSearchNamespace.ts";
 import { isAnalyticsEngineDataset } from "../AnalyticsEngine/AnalyticsEngineDataset.ts";
 import { isArtifacts } from "../Artifacts/Artifacts.ts";
 import { isBrowser } from "../Browser/Browser.ts";
 import { isD1Database } from "../D1/D1Database.ts";
 import { isSendEmail } from "../Email/SendEmail.ts";
+import { isFlagshipApp } from "../Flagship/App.ts";
 import { isHyperdrive } from "../Hyperdrive/Hyperdrive.ts";
 import { getHyperdriveDevOrigin } from "../Hyperdrive/HyperdriveBinding.ts";
 import { isImages } from "../Images/Images.ts";
@@ -118,6 +121,12 @@ const toBinding = (
       type: "browser",
       name: bindingName,
     };
+  } else if (isFlagshipApp(binding)) {
+    return {
+      type: "flagship",
+      name: bindingName,
+      appId: binding.appId,
+    };
   } else if (isAnalyticsEngineDataset(binding)) {
     return {
       type: "analytics_engine",
@@ -180,6 +189,24 @@ const toBinding = (
       type: "ai",
       name: bindingName,
     };
+  } else if (isAiSearchInstance(binding)) {
+    // Single-instance binding: `env.NAME` is the instance itself. The
+    // `namespace` qualifies which namespace the instance lives in (the
+    // account-provided `default` when unspecified).
+    return {
+      type: "ai_search",
+      name: bindingName,
+      instanceName: binding.instanceId,
+      namespace: binding.namespace,
+    };
+  } else if (isAiSearchNamespace(binding)) {
+    // Namespace binding: `env.NAME.get(instanceName)` selects an instance
+    // within the namespace at runtime.
+    return {
+      type: "ai_search_namespace",
+      name: bindingName,
+      namespace: binding.name,
+    };
   } else if (isHyperdrive(binding)) {
     return {
       type: "hyperdrive",

package/src/Cloudflare/Workers/WorkerBinding.ts

@@ -7,11 +7,14 @@ import * as Binding from "../../Binding.ts";
 import type { Rpc } from "../../Rpc.ts";
 import { isYieldableEffectLike } from "../../Util/effect.ts";
 import type { AiGateway } from "../AiGateway/AiGateway.ts";
+import type { AiSearchInstance } from "../AiSearch/AiSearchInstance.ts";
+import type { AiSearchNamespace } from "../AiSearch/AiSearchNamespace.ts";
 import { AnalyticsEngineDataset } from "../AnalyticsEngine/AnalyticsEngineDataset.ts";
 import { Artifacts } from "../Artifacts/Artifacts.ts";
 import { Browser } from "../Browser/Browser.ts";
 import type { D1Database } from "../D1/D1Database.ts";
 import { SendEmail } from "../Email/SendEmail.ts";
+import type { FlagshipApp } from "../Flagship/App.ts";
 import { Hyperdrive } from "../Hyperdrive/Hyperdrive.ts";
 import { Images } from "../Images/Images.ts";
 import type { KVNamespace } from "../KV/KVNamespace.ts";
@@ -23,8 +26,8 @@ import type { VectorizeIndex } from "../Vectorize/VectorizeIndex.ts";
 import type { Assets } from "./Assets.ts";
 import type { DurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
 import type { DynamicWorkerLoader } from "./DynamicWorkerLoader.ts";
-import type { VersionMetadata } from "./VersionMetadata.ts";
 import { makeRpcStub } from "./Rpc.ts";
+import type { VersionMetadata } from "./VersionMetadata.ts";
 import { isWorker, Worker, WorkerEnvironment } from "./Worker.ts";
 
 export type WorkerBinding = Exclude<
@@ -49,11 +52,14 @@ export type WorkerBindingResource =
   | KVNamespace
   | Queue
   | AiGateway
+  | AiSearchInstance
+  | AiSearchNamespace
   | AnalyticsEngineDataset
   | SendEmail
   | Artifacts
   | RateLimit
   | Browser
+  | FlagshipApp
   | Images
   | Hyperdrive
   | VectorizeIndex
@@ -97,6 +103,11 @@ export const bindWorker = Effect.fnUntraced(function* <Shape, Req = never>(
   return makeRpcStub<Shape>(stubEff);
 });
 
+/**
+ * @binding
+ * @product Workers
+ * @category Workers & Compute
+ */
 export class BindWorkerPolicy extends Binding.Policy<
   BindWorkerPolicy,
   (worker: Worker) => Effect.Effect<void>

package/src/Cloudflare/Workers/WorkerBridge.ts

@@ -17,6 +17,7 @@ import { ExecutionContext } from "../../ExecutionContext.ts";
 import { makeEntrypointLayer } from "../../Runtime.ts";
 import { Self } from "../../Self.ts";
 import { Stack } from "../../Stack.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import cloudflare_workers from "./cloudflare_workers.ts";
 import { isScopeEjected } from "./HttpServer.ts";
 import {
@@ -241,6 +242,16 @@ export const getWorkerExport = <Export = any>({
             ),
           ),
           Layer.provideMerge(Layer.succeed(WorkerEnvironment, env)),
+          Layer.provideMerge(
+            Layer.succeed(
+              CloudflareEnvironment,
+              // TODO(sam): fix this with maybe a CloudflareAccountId Effect service
+              // @ts-expect-error - this is hacky, but we only need and have this property
+              Effect.succeed({
+                account: (env as any).ALCHEMY_CLOUDFLARE_ACCOUNT_ID,
+              }),
+            ),
+          ),
           Layer.provideMerge(
             Layer.succeed(
               MinimumLogLevel,