alchemy 2.0.0-beta.76 → 2.0.0-beta.77

package/src/Cloudflare/Vectorize/SearchIndexHttpClient.ts

@@ -61,7 +61,7 @@ export const makeHttpSearchIndexClient = (
     describe: () =>
       local((name) =>
         vectorize
-          .infoIndex({ accountId, indexName: name })
+          .getIndexInfo({ accountId, indexName: name })
           .pipe(Effect.map(toIndexInfo)),
       ),
     query: (vector, options) =>
@@ -161,7 +161,7 @@ const toMutation = (r: {
 }): runtime.VectorizeAsyncMutation => ({ mutationId: r.mutationId ?? "" });
 
 const toIndexInfo = (
-  r: vectorize.InfoIndexResponse,
+  r: vectorize.GetIndexInfoResponse,
 ): runtime.VectorizeIndexInfo =>
   ({
     vectorCount: r.vectorCount ?? 0,

package/src/Cloudflare/Website/Nextjs.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_COMPATIBILITY_DATE } from "@alchemy.run/cloudflare-runtime/core/internal/constants";
 import * as Effect from "effect/Effect";
 import type { MemoOptions } from "../../Command/Memo.ts";
 import type { InputProps } from "../../Input.ts";
@@ -21,13 +22,6 @@ import {
  */
 const NEXTJS_SOURCE_PROVIDER = "@alchemy.run/frontend-frameworks/nextjs/source";
 
-/**
- * The default compatibility date when none is provided. Matches the
- * `@alchemy.run/frontend-frameworks/nextjs` integration's own default so deploy and local
- * dev agree.
- */
-const DEFAULT_COMPATIBILITY_DATE = "2026-05-12";
-
 export interface NextjsProps<
   Bindings extends WorkerBindingProps = {},
 > extends Omit<
@@ -302,16 +296,11 @@ export const Nextjs: {
               WORKER_SELF_REFERENCE: Self,
               ...props?.env,
             },
-            // OpenNext requires nodejs_compat; the Worker here is external
-            // (no inline Effect entry), so the engine won't add it.
+            // OpenNext requires Node.js APIs. The 2026-08-31 default date
+            // enables both nodejs_compat modes, so no redundant flag is sent.
             compatibility: {
               date: props?.compatibility?.date ?? DEFAULT_COMPATIBILITY_DATE,
-              flags: Array.from(
-                new Set([
-                  "nodejs_compat",
-                  ...(props?.compatibility?.flags ?? []),
-                ]),
-              ),
+              flags: props?.compatibility?.flags,
             },
             // The OpenNext server owns routing: run the worker first and
             // leave asset-path rewriting off. Users can still override.

package/src/Cloudflare/Website/Vocs.ts

@@ -58,7 +58,7 @@ export interface VocsProps<
  *
  * Input files are content-hashed (respecting `.gitignore` by default), so an
  * unchanged project skips its build and deployment. Vocs' server runtime uses
- * Node APIs, so `nodejs_compat` is included in the Worker's compatibility
+ * Node APIs, enabled by the Worker's compatibility date
  * flags automatically.
  *
  * ### Deploying a Vocs Site
@@ -170,12 +170,8 @@ export const Vocs: {
           Effect.isEffect(propsEff) ? propsEff : Effect.succeed(propsEff),
           (props) => ({
             ...props,
-            compatibility: {
-              ...props?.compatibility,
-              flags: props?.compatibility?.flags?.includes("nodejs_compat")
-                ? props.compatibility.flags
-                : [...(props?.compatibility?.flags ?? []), "nodejs_compat"],
-            },
+            // The Worker compatibility resolver enables Node.js APIs from
+            // the date (or adds the flag when a caller pins an older date).
             assets: {
               htmlHandling: "drop-trailing-slash" as const,
               ...props?.assets,

package/src/Cloudflare/Workers/Assets.ts

@@ -1,12 +1,15 @@
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as wfp from "@distilled.cloud/cloudflare/workers-for-platforms";
+import { Retry } from "@distilled.cloud/cloudflare";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import * as Predicate from "effect/Predicate";
 import * as Schedule from "effect/Schedule";
+import * as Semaphore from "effect/Semaphore";
 import type { PlatformError } from "effect/PlatformError";
-import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
+import type { ScopedPlanStatusSession } from "../../Report.ts";
 import { sha256, sha256Object } from "../../Util/index.ts";
 import { initialCwd } from "../../Util/Node.ts";
 import createIgnore from "@alchemy.run/node-utils/ignore";
@@ -424,6 +427,36 @@ export const readAssets = Effect.fn(function* ({
   };
 });
 
+/**
+ * Bulk buckets (up to ~50 MiB of base64 each) go up this many at a time —
+ * the same number wrangler uses.
+ */
+const BULK_UPLOAD_CONCURRENCY = 3;
+/**
+ * Per-bucket retries after a gateway error (502/503/504), with concurrency
+ * already dropped to one. Mirrors wrangler's `MAX_UPLOAD_GATEWAY_ERRORS`.
+ */
+const MAX_UPLOAD_GATEWAY_RETRIES = 5;
+
+const isGatewayError = (error: unknown) =>
+  Predicate.isTagged(error, "BadGateway") ||
+  Predicate.isTagged(error, "ServiceUnavailable") ||
+  Predicate.isTagged(error, "GatewayTimeout");
+
+/**
+ * The SDK's default policy retries gateway errors internally (~20s of
+ * backoff) before the caller ever sees one, so the concurrency fallback
+ * below could never kick in. Let those surface to the bucket loop; every
+ * other transient error keeps the default handling.
+ */
+const surfaceGatewayErrors: Retry.Factory = (lastError) => {
+  const base = Retry.makeDefault(lastError);
+  return {
+    ...base,
+    while: (error) => !isGatewayError(error) && (base.while?.(error) ?? false),
+  };
+};
+
 export const uploadAssets = Effect.fn(function* (
   accountId: string,
   workerName: string,
@@ -453,6 +486,71 @@ export const uploadAssets = Effect.fn(function* (
   // concurrent tool's transient chdir (framework source builds).
   const directory = path.resolve(initialCwd, assets.directory);
 
+  // Bucket concurrency, wrangler-style: three in flight, and the first
+  // gateway error resizes it to one for the rest of the deploy. Hoisted out
+  // of the session so a JWT-expiry retry stays degraded instead of bursting
+  // back to three against a gateway that just told us to back off.
+  const semaphore = yield* Semaphore.make(BULK_UPLOAD_CONCURRENCY);
+
+  const uploadBucket = Effect.fn(function* (
+    bucket: readonly string[],
+    uploadJwt: string,
+  ) {
+    const body: Record<string, File> = {};
+    yield* Effect.forEach(
+      bucket,
+      Effect.fn(function* (hash) {
+        const name = assetsByHash.get(hash);
+        if (!name) {
+          return yield* new AssetNotFoundError({
+            message: `Asset ${hash} not found in manifest`,
+            hash,
+          });
+        }
+        const file = yield* fs.readFile(path.join(directory, name)).pipe(
+          Effect.mapError(
+            (error) =>
+              new FailedToReadAssetError({
+                message: `Failed to read asset ${name}: ${error.message}`,
+                name,
+                cause: error,
+              }),
+          ),
+        );
+        body[hash] = new File([Buffer.from(file).toString("base64")], hash, {
+          type: getContentType(name),
+        });
+      }),
+    );
+    return yield* createAssetUpload({
+      accountId,
+      base64: true,
+      body,
+      jwtToken: uploadJwt,
+    }).pipe(
+      Retry.policy(surfaceGatewayErrors),
+      Effect.tapError((error) =>
+        isGatewayError(error)
+          ? semaphore
+              .resize(1)
+              .pipe(
+                Effect.andThen(
+                  note(
+                    "Asset upload hit a gateway error, retrying one bucket at a time...",
+                    { kind: "status" },
+                  ),
+                ),
+              )
+          : Effect.void,
+      ),
+      Effect.retry({
+        while: isGatewayError,
+        schedule: Schedule.exponential("2 seconds"),
+        times: MAX_UPLOAD_GATEWAY_RETRIES,
+      }),
+    );
+  });
+
   // One full upload session: ask Cloudflare which assets are missing,
   // upload each bucket, and return the completion JWT that putWorker
   // must redeem. The session JWT can expire mid-upload on very large
@@ -463,7 +561,7 @@ export const uploadAssets = Effect.fn(function* (
   // stopped, and a fresh session with nothing left to upload returns
   // the completion JWT directly.
   const runSession = Effect.fn(function* () {
-    yield* note("Checking assets...");
+    yield* note("Checking assets...", { kind: "status" });
     const session = dispatchNamespace
       ? yield* wfp.createDispatchNamespaceScriptAssetUpload({
           accountId,
@@ -495,53 +593,23 @@ export const uploadAssets = Effect.fn(function* (
     let uploaded = 0;
     const total = session.buckets.flat().length;
     yield* note(`Uploaded ${uploaded} of ${total} assets...`);
+    // Cloudflare only returns the completion JWT on the last bucket it
+    // receives, which under concurrency is not necessarily the last one
+    // in the list — so every response is checked.
     let jwt: string | undefined | null;
     yield* Effect.forEach(
       session.buckets,
       Effect.fn(function* (bucket) {
-        const body: Record<string, File> = {};
-        yield* Effect.forEach(
-          bucket,
-          Effect.fn(function* (hash) {
-            const name = assetsByHash.get(hash);
-            if (!name) {
-              return yield* new AssetNotFoundError({
-                message: `Asset ${hash} not found in manifest`,
-                hash,
-              });
-            }
-            const file = yield* fs.readFile(path.join(directory, name)).pipe(
-              Effect.mapError(
-                (error) =>
-                  new FailedToReadAssetError({
-                    message: `Failed to read asset ${name}: ${error.message}`,
-                    name,
-                    cause: error,
-                  }),
-              ),
-            );
-            body[hash] = new File(
-              [Buffer.from(file).toString("base64")],
-              hash,
-              {
-                type: getContentType(name),
-              },
-            );
-          }),
+        const result = yield* uploadBucket(bucket, uploadJwt).pipe(
+          semaphore.withPermits(1),
         );
-        const result = yield* createAssetUpload({
-          accountId,
-          base64: true,
-          body,
-          jwtToken: uploadJwt,
-        });
-
         uploaded += bucket.length;
         yield* note(`Uploaded ${uploaded} of ${total} assets...`);
         if (result.jwt) {
           jwt = result.jwt;
         }
       }),
+      { concurrency: BULK_UPLOAD_CONCURRENCY },
     );
     if (!jwt) {
       return yield* new AssetUploadSessionError({

package/src/Cloudflare/Workers/BrowserHttpClient.ts

@@ -54,8 +54,8 @@ type BrowserByteStream = Stream.Stream<
  *   the distilled REST codec models as JSON status, not a byte stream.
  *
  * Because the REST data-plane only returns the action `result` (not the
- * runtime binding's `meta` envelope), `content`/`snapshot` populate `meta`
- * with a best-effort placeholder.
+ * runtime binding's `meta` envelope), JSON actions populate `meta` with a
+ * best-effort placeholder.
  */
 export const makeHttpBrowserClient = (auth: BrowserAuth): BrowserClient => {
   // Run a distilled Browser Rendering op with the injected auth and surface
@@ -94,6 +94,7 @@ export const makeHttpBrowserClient = (auth: BrowserAuth): BrowserClient => {
       Effect.map((result): BrowserMarkdownResult => ({
         success: true,
         result,
+        meta: { status: 200, title: "" },
       })),
     );
 
@@ -102,12 +103,17 @@ export const makeHttpBrowserClient = (auth: BrowserAuth): BrowserClient => {
       Effect.map((result): BrowserLinksResult => ({
         success: true,
         result: [...result],
+        meta: { status: 200, title: "" },
       })),
     );
 
   const json = (options: unknown) =>
     run(browser.createJson(req(options))).pipe(
-      Effect.map((result): BrowserJsonResult => ({ success: true, result })),
+      Effect.map((result): BrowserJsonResult => ({
+        success: true,
+        result,
+        meta: { status: 200, title: "" },
+      })),
     );
 
   const scrape = (options: unknown) =>
@@ -124,6 +130,7 @@ export const makeHttpBrowserClient = (auth: BrowserAuth): BrowserClient => {
                 item.results,
               ]) as BrowserScrapeResult["result"][number]["results"],
         })),
+        meta: { status: 200, title: "" },
       })),
     );
 

package/src/Cloudflare/Workers/CloudflareTracer.ts

@@ -0,0 +1,113 @@
+/**
+ * Effect Tracer that mirrors `Effect.withSpan` / `Effect.fn` spans into
+ * Cloudflare Workers Observability via `tracing.startActiveSpan`.
+ *
+ * Built once per event (see {@link Telemetry} + `buildEventTelemetry`).
+ * Captures the invocation's async context; do not cache the built Tracer
+ * across requests. Not exported from the Cloudflare barrel.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Tracer from "effect/Tracer";
+import cloudflare_workers from "./cloudflare_workers.ts";
+
+type SpanOptions = Parameters<Tracer.Tracer["span"]>[0];
+type RunInContext = ReturnType<typeof AsyncLocalStorage.snapshot>;
+type CloudflareSpan = ReturnType<
+  (typeof import("cloudflare:workers"))["tracing"]["startSpan"]
+>;
+
+class Span extends Tracer.NativeSpan {
+  constructor(
+    options: SpanOptions,
+    readonly runInContext: RunInContext,
+    readonly cloudflareSpan?: CloudflareSpan,
+  ) {
+    // Cascade Cloudflare's decision: an untraced invocation (`isTraced`
+    // false — e.g. traces disabled; head sampling is applied later, at
+    // ingestion) or a runtime without the API marks the Effect span
+    // unsampled, so descendants skip `startActiveSpan` entirely.
+    super({
+      ...options,
+      sampled: options.sampled && (cloudflareSpan?.isTraced ?? false),
+    });
+  }
+
+  override attribute(key: string, value: unknown): void {
+    super.attribute(key, value);
+    if (
+      Predicate.isString(value) ||
+      Predicate.isNumber(value) ||
+      Predicate.isBoolean(value)
+    ) {
+      this.cloudflareSpan?.setAttribute(key, value);
+    }
+  }
+
+  override end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void {
+    super.end(endTime, exit);
+    this.cloudflareSpan?.setAttribute(
+      "effect.exit",
+      Exit.isSuccess(exit)
+        ? "success"
+        : Cause.hasInterruptsOnly(exit.cause)
+          ? "interrupted"
+          : "failure",
+    );
+    this.cloudflareSpan?.end();
+  }
+}
+
+/**
+ * Per-event Tracer Layer. Cloudflare owns sampling and export; scalar
+ * attributes are forwarded; events, links, and non-scalars stay
+ * Effect-local. Completion is recorded as `effect.exit`. Effect trace/span
+ * IDs are independent of Cloudflare's opaque IDs.
+ */
+export const layer: Layer.Layer<never> = Layer.effect(
+  Tracer.Tracer,
+  Effect.gen(function* () {
+    // `tracing` only exists on compatibility dates >= 2026-07-28. Deploy
+    // already rejects older dates (`assertCloudflareTelemetryCompatibility`),
+    // so a missing API here (an old local workerd) just keeps spans
+    // Effect-local.
+    const { tracing } = yield* cloudflare_workers;
+    const invocationContext = AsyncLocalStorage.snapshot();
+    const contextFor = (span: Tracer.AnySpan | undefined): RunInContext => {
+      while (span?._tag === "Span") {
+        if (span instanceof Span) return span.runInContext;
+        span = Option.getOrUndefined(span.parent);
+      }
+      return invocationContext;
+    };
+
+    return Tracer.make({
+      span(options) {
+        const parentContext = options.root
+          ? invocationContext
+          : contextFor(Option.getOrUndefined(options.parent));
+
+        if (!options.sampled || tracing?.startActiveSpan === undefined) {
+          return new Span(options, parentContext);
+        }
+
+        return parentContext(() =>
+          tracing.startActiveSpan(
+            options.name,
+            (span) => new Span(options, AsyncLocalStorage.snapshot(), span),
+          ),
+        );
+      },
+      context(primitive, fiber) {
+        return contextFor(fiber.currentSpan)(() =>
+          primitive["~effect/Effect/evaluate"](fiber),
+        );
+      },
+    });
+  }),
+);

package/src/Cloudflare/Workers/Compatibility.ts

@@ -1,9 +1,7 @@
+import { DEFAULT_COMPATIBILITY_DATE } from "@alchemy.run/cloudflare-runtime/core/internal/constants";
 import { isPythonMain } from "./Sources/Python.ts";
 import type { WorkerProps } from "./Worker.ts";
 
-// TODO: figure out why the later one from workerd breaks
-const DEFAULT_COMPATIBILITY_DATE = "2026-03-17";
-
 /**
  * The Effect worker bridge builds its layer stack once per isolate and shares
  * the in-flight build promise across concurrent events. Awaiting a promise
@@ -31,6 +29,34 @@ const CROSS_REQUEST_PROMISE_RESOLUTION_DEFAULT_ON = "2024-10-14";
 // startup, so the default flag is only applied from this date onward.
 const NODEJS_COMPAT_V2_DATE = "2024-09-23";
 
+// Cloudflare enables both nodejs_compat modes from this date. Do not emit a
+// redundant positive flag for newer Workers; the compatibility date supplies
+// identical runtime behavior. Older user-pinned dates still need the flag.
+const NODEJS_COMPAT_DEFAULT_ON = "2026-08-04";
+
+/**
+ * Compatibility settings passed to build tools and framework adapters.
+ * Cloudflare rejects a redundant `nodejs_compat` flag after its default-on
+ * date, but downstream tools may still detect Node support from the explicit
+ * flag only, so internal build configuration materializes the effective flag.
+ */
+export const getToolingCompatibility = (
+  compatibility: { date: string; flags: string[] },
+  main: unknown,
+) => ({
+  date: compatibility.date,
+  // TODO: Stop materializing `nodejs_compat` once supported downstream tools
+  // consistently derive the default from the compatibility date.
+  flags:
+    isPythonMain(main) ||
+    compatibility.date < NODEJS_COMPAT_DEFAULT_ON ||
+    compatibility.flags.includes("nodejs_compat") ||
+    compatibility.flags.includes("nodejs_compat_v2") ||
+    compatibility.flags.includes("no_nodejs_compat")
+      ? compatibility.flags
+      : [...compatibility.flags, "nodejs_compat"],
+});
+
 export const getCompatibility = (props: WorkerProps) => {
   const userFlags = props.compatibility?.flags ?? [];
   const python = isPythonMain(props.main);
@@ -61,16 +87,20 @@ export const getCompatibility = (props: WorkerProps) => {
       // Required while Python Workers are in open beta — the upload API
       // rejects Python modules without it.
       ...(python ? ["python_workers"] : []),
-      // Every JS Worker gets `nodejs_compat` by default — Effect-native
+      // Every JS Worker gets Node.js compatibility by default — Effect-native
       // Workers need it for the bundled Effect runtime, and external Workers
       // (plain `export default { fetch }` entrypoints, vite builds) routinely
       // import `node:*` built-ins. Without it the bundle uploads fine but
       // Cloudflare rejects the script with `No such module "node:crypto"`
-      // (#796). Python Workers don't go through the JS bundler, so they get
-      // no default. An explicit `no_nodejs_compat` opts out — appending
+      // (#796). For dates before Cloudflare's default-on cutoff we still emit
+      // the flag; newer dates supply the behavior themselves. Python Workers
+      // don't go through the JS bundler, so they get no default. An explicit
+      // `no_nodejs_compat` opts out — appending
       // `nodejs_compat` alongside it would send Cloudflare a contradictory
       // flag pair.
-      ...(python || userFlags.includes("no_nodejs_compat")
+      ...(python ||
+      userFlags.includes("no_nodejs_compat") ||
+      date >= NODEJS_COMPAT_DEFAULT_ON
         ? []
         : props.isExternal
           ? // ISO dates compare lexically.

package/src/Cloudflare/Workers/DurableObject.ts

@@ -104,7 +104,7 @@ export interface DurableObjectShape {
   fetch?: HttpEffect<DurableObjectState | RuntimeContext>;
   alarm?: (
     alarmInfo?: AlarmInvocationInfo,
-  ) => Effect.Effect<void, never, never>;
+  ) => Effect.Effect<void, never, RuntimeContext>;
   webSocketMessage?: (
     socket: WebSocket,
     message: string | ArrayBuffer,
@@ -115,6 +115,11 @@ export interface DurableObjectShape {
     reason: string,
     wasClean: boolean,
   ) => Effect.Effect<void>;
+  /**
+   * Called when a hibernatable WebSocket errors. The runtime closes the
+   * socket after this handler; use it to drop the peer's session state.
+   */
+  webSocketError?: (socket: WebSocket, error: unknown) => Effect.Effect<void>;
 }
 
 export type DurableObjectServices =
@@ -364,7 +369,7 @@ export class DurableObjectScope extends Context.Service<
  * ```
  *
  * There are two ways to define a Durable Object. See the
- * [Functions & Servers](/infrastructure-as-effects/functions-and-servers) page
+ * [Runtime](/infrastructure-as-effects/runtime) page
  * for the full explanation.
  *
  * - **Inline** — Effect implementation passed directly, single file.
@@ -719,8 +724,8 @@ export class DurableObjectScope extends Context.Service<
  * Durable Objects support WebSocket hibernation — the runtime can
  * evict the object from memory while keeping connections open. Use
  * `Cloudflare.upgrade()` to accept a connection, and return
- * `webSocketMessage` / `webSocketClose` handlers to process events
- * when the object wakes back up.
+ * `webSocketMessage` / `webSocketClose` / `webSocketError` handlers to
+ * process events when the object wakes back up.
  *
  * **Example:** Accepting a WebSocket connection
  * ```typescript
@@ -752,6 +757,13 @@ export class DurableObjectScope extends Context.Service<
  *   ) {
  *     yield* ws.close(code, reason);
  *   }),
+ *   webSocketError: Effect.fn(function* (
+ *     ws: Cloudflare.WebSocket,
+ *     error: unknown,
+ *   ) {
+ *     // the runtime closes the socket afterwards; clear its session here
+ *     ws.serializeAttachment(null);
+ *   }),
  * };
  * ```
  *
@@ -823,6 +835,40 @@ export class DurableObjectScope extends Context.Service<
  * };
  * ```
  *
+ * ### Aborting a Durable Object
+ * `state.abort(reason?, options?)` forcibly resets the isolate. By
+ * default an in-progress alarm retries after the reset. Pass
+ * `{ retryAlarm: false }` when the alarm should stop instead — for
+ * example an alarm that deletes storage so the constructor does not
+ * recreate it.
+ *
+ * **Example:** Stop alarm retries after cleanup
+ * ```typescript
+ * export class CleanupTask extends Cloudflare.DurableObject<CleanupTask>()(
+ *   "CleanupTask",
+ *   Effect.gen(function* () {
+ *     const state = yield* Cloudflare.DurableObjectState;
+ *
+ *     return Effect.gen(function* () {
+ *       // This won't be re-run after the alarm is aborted
+ *       yield* state.storage.sql.exec(`
+ *         CREATE TABLE IF NOT EXISTS foo (
+ *           id INTEGER PRIMARY KEY
+ *         )
+ *       `);
+ *
+ *       return {
+ *         alarm: () =>
+ *           Effect.gen(function* () {
+ *             yield* state.storage.sql.exec("DROP TABLE foo");
+ *             yield* state.abort("Cleanup complete", { retryAlarm: false });
+ *           }),
+ *       };
+ *     });
+ *   }),
+ * ) {}
+ * ```
+ *
  * ### Using from a Worker
  * Yield the DO class in your Worker's init phase to get a namespace
  * handle. Call `getByName` or `getById` to get a typed stub, then

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -216,5 +216,13 @@ export const makeDurableObjectBridge =
             ) ?? Effect.void,
         );
       }
+
+      async webSocketError(ws: WebSocket, error: unknown) {
+        return this.#execute(
+          (instance) =>
+            instance.webSocketError?.(fromWebSocket(ws as any), error) ??
+            Effect.void,
+        );
+      }
     } as any;
   };