alchemy 2.0.0-beta.55 → 2.0.0-beta.56

package/src/Cloudflare/Workers/Worker.ts

@@ -10,6 +10,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 +35,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 +51,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;
@@ -234,7 +242,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 +285,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.
@@ -517,6 +563,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`
@@ -867,8 +928,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)),
                 ),
@@ -1020,8 +1080,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)),
                   ),
@@ -1144,23 +1203,27 @@ 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(() =>
@@ -1169,6 +1232,10 @@ export const LiveWorkerProvider = () =>
 
       const viteBuild = Effect.fnUntraced(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(
@@ -1701,10 +1768,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)),
               ),
@@ -1811,6 +1878,56 @@ export const LiveWorkerProvider = () =>
 
       return Worker.Provider.of({
         stables: ["workerId", "workerName"],
+        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.fnUntraced(function* ({
           id,
           news,
@@ -1854,22 +1971,80 @@ 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))
           ) {
+            const stables: string[] = [];
+            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 }) {
           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) => ({

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -11,6 +11,7 @@ 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 +119,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",

package/src/Cloudflare/Workers/WorkerBinding.ts

@@ -12,6 +12,7 @@ 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";
@@ -54,6 +55,7 @@ export type WorkerBindingResource =
   | Artifacts
   | RateLimit
   | Browser
+  | FlagshipApp
   | Images
   | Hyperdrive
   | VectorizeIndex

package/src/Cloudflare/Workers/WorkerBundle.ts

@@ -4,11 +4,13 @@ import * as FileSystem from "effect/FileSystem";
 import { flow } from "effect/Function";
 import type * as Path from "effect/Path";
 import * as Stream from "effect/Stream";
+import fg from "fast-glob";
 import { fileURLToPath } from "node:url";
 import path from "pathe";
 import type * as rolldown from "rolldown";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
+import { sha256 } from "../../Util/sha256.ts";
 import {
   isDurableObjectExport,
   type DurableObjectExport,
@@ -191,3 +193,124 @@ ${[
 ].join("\n")}
 `;
 };
+
+/**
+ * A rule selecting additional module files to upload alongside the entry
+ * of a prebuilt Worker (`bundle: false`). Globs are matched against
+ * POSIX-style paths relative to the directory containing the Worker's
+ * entry module, mirroring Wrangler's `rules` configuration.
+ */
+export interface ModuleRule {
+  readonly globs: readonly string[];
+}
+
+/**
+ * The default {@link ModuleRule | module rules} applied when
+ * `bundle: false` is set without explicit rules — the same set Wrangler
+ * applies to `no_bundle` Workers: ESModule (`**\/*.js`, `**\/*.mjs`),
+ * CompiledWasm (`**\/*.wasm`), Text (`**\/*.txt`, `**\/*.html`,
+ * `**\/*.sql`), and Data (`**\/*.bin`). Source maps (`.js.map`) are
+ * deliberately not uploaded.
+ */
+export const defaultModuleRules: ModuleRule[] = [
+  { globs: ["**/*.js", "**/*.mjs"] },
+  { globs: ["**/*.wasm"] },
+  { globs: ["**/*.txt", "**/*.html", "**/*.sql"] },
+  { globs: ["**/*.bin"] },
+];
+
+export interface PrebuiltWorkerBundleOptions {
+  /**
+   * Path (or `file://` URL) to the prebuilt, runtime-ready entry module.
+   */
+  main: string;
+  /**
+   * Module rules selecting additional files to upload alongside the
+   * entry. Defaults to {@link defaultModuleRules}.
+   */
+  rules?: readonly ModuleRule[] | undefined;
+}
+
+/**
+ * Read a prebuilt Worker bundle from disk without bundling.
+ *
+ * The entry's directory is walked recursively and every file matching the
+ * rule globs is uploaded byte-for-byte as an additional module, named by
+ * its POSIX path relative to that directory — the same contract as
+ * Wrangler's `find_additional_modules` and Alchemy v1's `noBundle`. The
+ * entry file is always first and never duplicated as an additional
+ * module.
+ */
+export const readPrebuiltWorkerBundle = Effect.fnUntraced(function* (
+  options: PrebuiltWorkerBundleOptions,
+) {
+  const fs = yield* FileSystem.FileSystem;
+
+  const main = yield* Effect.sync(() => {
+    try {
+      return fileURLToPath(options.main);
+    } catch {
+      return options.main;
+    }
+  }).pipe(
+    // Resolve without following symlinks (Alchemy v1 parity): the module
+    // walk happens in the directory the user pointed at, not the entry's
+    // canonical location.
+    Effect.map((p) => path.resolve(p)),
+  );
+  const root = path.dirname(main);
+  const entryName = path.basename(main);
+
+  const readModuleFile = Effect.fnUntraced(function* (name: string) {
+    const file = path.join(root, name);
+    const content = yield* fs.readFile(file).pipe(
+      Effect.mapError(
+        (cause) =>
+          new Bundle.BundleError({
+            message: `Failed to read prebuilt worker bundle module "${file}"`,
+            cause,
+          }),
+      ),
+    );
+    const hash = yield* sha256(content);
+    return { path: name, content, hash } satisfies Bundle.BundleFile;
+  });
+
+  return yield* readModuleFile(entryName).pipe(
+    Effect.zipWith(
+      Effect.tryPromise({
+        try: () =>
+          fg.glob(
+            (options.rules ?? defaultModuleRules).flatMap((rule) => rule.globs),
+            {
+              cwd: root,
+              onlyFiles: true,
+              dot: true,
+            },
+          ),
+        catch: (error) =>
+          new Bundle.BundleError({
+            message: `Failed to read additional modules in directory "${root}"`,
+            cause: error,
+          }),
+      }).pipe(
+        Effect.map((names) =>
+          names
+            .map((name) => name.replaceAll("\\", "/"))
+            .filter((name) => name !== entryName)
+            .sort(),
+        ),
+        Effect.flatMap(
+          Effect.forEach(readModuleFile, { concurrency: "unbounded" }),
+        ),
+      ),
+      (entryModule, additionalModules) =>
+        [entryModule, ...additionalModules] as [
+          Bundle.BundleFile,
+          ...Bundle.BundleFile[],
+        ],
+      { concurrent: true },
+    ),
+    Effect.flatMap(Bundle.bundleOutputFromFiles),
+  );
+});

package/src/Cloudflare/Workers/WorkerRuntimeContext.ts

@@ -6,6 +6,7 @@ import * as Redacted from "effect/Redacted";
 import type { HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
 import type * as Serverless from "../../Serverless/index.ts";
+import type { DurableObjectExport } from "./DurableObjectNamespace.ts";
 import { makeRequestHandler } from "./HttpServer.ts";
 import {
   ExportedHandlerMethods,
@@ -13,6 +14,7 @@ import {
   WorkerTypeId,
   type WorkerEvent,
 } from "./Worker.ts";
+import type { WorkflowExport } from "./Workflow.ts";
 
 export interface WorkerRuntimeContext extends Serverless.FunctionContext {
   export(name: string, value: any): Effect.Effect<void>;
@@ -21,7 +23,7 @@ export interface WorkerRuntimeContext extends Serverless.FunctionContext {
 
 export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
   const listeners: Effect.Effect<Serverless.FunctionListener>[] = [];
-  const exports: Record<string, any> = {};
+  const exports: Record<string, DurableObjectExport | WorkflowExport> = {};
   const env: Record<string, any> = {};
   let userShape: Record<string, unknown> | undefined;
 

package/src/Cloudflare/Workers/Workflow.ts

@@ -2,6 +2,7 @@ import * as workflows from "@distilled.cloud/cloudflare/workflows";
 import type { ConfigError } from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { AlchemyContext } from "../../AlchemyContext.ts";
 import { ExecutionContext } from "../../ExecutionContext.ts";
 import { ALCHEMY_PHASE } from "../../Phase.ts";
@@ -495,6 +496,30 @@ export const WorkflowProvider = () =>
       return WorkflowResource.Provider.of({
         // The `workflowId` is no longer marked as stable because if you start in dev mode, the ID will change on first deploy.
         stables: ["accountId"],
+        // Workflows are account-scoped. Enumerate every workflow in the account
+        // via the paginated list API and hydrate each into the same Attributes
+        // shape `reconcile` returns (id/name/className/scriptName are all on the
+        // list item, so no per-item get is needed).
+        list: () =>
+          Effect.gen(function* () {
+            const { accountId } = yield* yield* CloudflareEnvironment;
+            return yield* workflows.listWorkflows.pages({ accountId }).pipe(
+              Stream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap((page) =>
+                  (page.result ?? []).map((wf) => ({
+                    workflowId: wf.id,
+                    workflowName: wf.name,
+                    // `className`/`scriptName` can be null/absent in the list
+                    // payload on some accounts — fall back so listing succeeds.
+                    className: wf.className ?? "",
+                    scriptName: wf.scriptName ?? "",
+                    accountId,
+                  })),
+                ),
+              ),
+            );
+          }),
         diff: Effect.fnUntraced(function* ({ output }) {
           // If the workflowId starts with "dev:", and we're not in dev mode, trigger an update so the workflow is created.
           if (output?.workflowId.startsWith("dev:") && !ctx.dev) {

package/src/Cloudflare/Workers/index.ts

@@ -1,3 +1,4 @@
+export * from "./AccountSetting.ts";
 export * from "./Assets.ts";
 export * from "./ConfigProvider.ts";
 export * from "./CronEventSource.ts";
@@ -8,14 +9,18 @@ export * from "./DurableObjectState.ts";
 export * from "./DurableObjectStorage.ts";
 export * from "./DynamicWorkerLoader.ts";
 export * from "./Fetch.ts";
+export * from "./GitHubRepositoryEventSource.ts";
 export * from "./HttpServer.ts";
 export * from "./InferEnv.ts";
 export * from "./LocalWorkerProvider.ts";
+export * from "./ObservabilityDestination.ts";
 export * from "./Request.ts";
+export * from "./Route.ts";
 export * from "./Rpc.ts";
 export * from "./RpcDurableObjectNamespace.ts";
 export * from "./RpcWorker.ts";
 export * from "./ScheduledEvents.ts";
+export * from "./Subdomain.ts";
 export * from "./VersionMetadata.ts";
 export * from "./VersionMetadataBinding.ts";
 export * from "./WebSocket.ts";