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

package/src/Cloudflare/StateStore/State.ts

@@ -10,8 +10,10 @@ import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
 import crypto from "node:crypto";
 
 import * as Config from "effect/Config";
+import * as Option from "effect/Option";
 import { isHttpClientError } from "effect/unstable/http/HttpClientError";
 import { adopt } from "../../AdoptPolicy.ts";
+import { AlchemyContext } from "../../AlchemyContext.ts";
 import { AuthError } from "../../Auth/AuthProvider.ts";
 import {
   CredentialsStore,
@@ -42,7 +44,12 @@ import * as CloudflareEnvironment from "../CloudflareEnvironment.ts";
 import * as Credentials from "../Credentials.ts";
 import { EdgeSessionError, createEdgeSession } from "../EdgeSession.ts";
 import Api, { STATE_STORE_SCRIPT_NAME, STATE_STORE_VERSION } from "./Api.ts";
-import { AuthToken, AuthTokenSecretName, TokenValue } from "./Token.ts";
+import {
+  AuthToken,
+  AuthTokenSecretName,
+  EncryptionKeySecretName,
+  TokenValue,
+} from "./Token.ts";
 
 const CI = Config.boolean("CI").pipe(Config.withDefault(false));
 
@@ -58,6 +65,12 @@ export const state = () =>
       const profileName = yield* ALCHEMY_PROFILE;
       const localStage = `${profileName}_${scriptName}`;
       const credStore = yield* CredentialsStore;
+      // `deploy --yes` flows in here (via AlchemyContext.updateStateStore) to
+      // auto-accept an out-of-date state store upgrade instead of prompting.
+      // Optional so callers that don't provide AlchemyContext keep the prompt.
+      const autoUpdateStateStore =
+        Option.getOrUndefined(yield* Effect.serviceOption(AlchemyContext))
+          ?.updateStateStore ?? false;
       const context = yield* Effect.context<Effect.Services<typeof init>>();
 
       const init = Effect.gen(function* () {
@@ -84,9 +97,11 @@ export const state = () =>
               yield* checkStateStoreVersion(url);
 
             if (observed === undefined) {
-              const shouldDeploy = yield* Clank.confirm({
-                message: `Cloudflare State Store '${scriptName}' is not available. Do you want to deploy it?`,
-              });
+              const shouldDeploy =
+                autoUpdateStateStore ||
+                (yield* Clank.confirm({
+                  message: `Cloudflare State Store '${scriptName}' is not available. Do you want to deploy it?`,
+                }));
               if (shouldDeploy) {
                 return yield* bootstrap({
                   workerName: scriptName,
@@ -100,10 +115,32 @@ export const state = () =>
             const httpState = yield* ensureAccess({ url, authToken });
             if (matches) {
               return httpState;
+            }
+
+            // The store is out of date. Upgrade it in place.
+            const upgrade = Effect.gen(function* () {
+              yield* Clank.info(
+                `Cloudflare State Store '${scriptName}' is out of date ` +
+                  `(expected v${expected}, observed v${observed ?? "unknown"}); upgrading...`,
+              );
+              const stateStoreOptions = yield* deployStateStore({
+                stage: scriptName,
+                state: httpState,
+                force: false,
+              });
+              return yield* makeCloudflareStateStore(stateStoreOptions);
+            });
+
+            if (autoUpdateStateStore) {
+              // `--yes`: upgrade automatically (also unblocks CI).
+              return yield* upgrade;
             } else if (isCI) {
               return yield* Effect.die(
                 new AuthError({
-                  message: `Cloudflare State store not found. Run 'alchemy bootstrap cloudflare --profile <your-ci-profile>' to deploy it first.`,
+                  message:
+                    `Cloudflare State store is out of date ` +
+                    `(expected v${expected}, observed v${observed ?? "unknown"}). ` +
+                    `Run 'alchemy bootstrap cloudflare --profile <your-ci-profile>' to upgrade it first, or pass --yes.`,
                 }),
               );
             } else {
@@ -113,12 +150,7 @@ export const state = () =>
                   `(expected v${expected}, observed v${observed ?? "unknown"})`,
               });
               if (shouldDeploy) {
-                const stateStoreOptions = yield* deployStateStore({
-                  stage: scriptName,
-                  state: httpState,
-                  force: false,
-                });
-                return yield* makeCloudflareStateStore(stateStoreOptions);
+                return yield* upgrade;
               } else {
                 return yield* Effect.die(new Clank.PromptCancelled());
               }
@@ -153,17 +185,19 @@ export const state = () =>
         if (credentials) {
           return yield* ensureLatest(credentials);
         }
-        const workerExists = yield* isStateStoreAvailable(scriptName);
-        if (workerExists) {
+        const { accountId } =
+          yield* yield* CloudflareEnvironment.CloudflareEnvironment;
+        if (yield* isStateStoreServing(accountId)) {
           return yield* ensureLatest(
             yield* loginWithCloudflare(profileName, false),
           );
+        } else if (autoUpdateStateStore) {
+          // `--yes`: deploy the missing state store automatically (also in CI).
+          return yield* bootstrap();
         } else if (isCI) {
-          // TODO(sam): do we want to support bootstrapping the state store from CI?
-          // for now - just die here
           return yield* Effect.die(
             new AuthError({
-              message: `Cloudflare State store not found. Run 'alchemy bootstrap cloudflare --profile <your-ci-profile>' to deploy it first.`,
+              message: `Cloudflare State store not found. Run 'alchemy bootstrap cloudflare --profile <your-ci-profile>' to deploy it first, or pass --yes.`,
             }),
           );
         } else {
@@ -233,9 +267,9 @@ export const bootstrap = (options: BootstrapOptions = {}) =>
         ),
       );
     }
-
-    const workerExists = yield* isStateStoreAvailable(scriptName);
-    if (workerExists) {
+    const { accountId } =
+      yield* yield* CloudflareEnvironment.CloudflareEnvironment;
+    if (yield* isStateStoreServing(accountId)) {
       // this is a regular update, let's check if it needs an update and refresh credentials
       if (!force) {
         yield* Clank.info(
@@ -283,7 +317,6 @@ export const bootstrap = (options: BootstrapOptions = {}) =>
         return httpState;
       }
     } else {
-      // fresh deploy - deploy from local for the first time
       yield* Clank.info(`Deploying Cloudflare State Store '${scriptName}'...`);
       return yield* deployWithLocalState({
         scriptName,
@@ -306,6 +339,125 @@ export const bootstrap = (options: BootstrapOptions = {}) =>
     }),
   );
 
+export interface TeardownOptions {
+  /** @default "alchemy-state-store" */
+  workerName?: string;
+  /** @default "default" */
+  profile?: string;
+  /**
+   * Delete the account Secrets Store too, but only once the state-store
+   * secrets have been removed and no other secrets remain in it. A store that
+   * still holds foreign secrets is left in place.
+   * @default true
+   */
+  deleteEmptySecretsStore?: boolean;
+}
+
+/**
+ * The inverse of {@link bootstrap}: tear down the Cloudflare-deployed state
+ * store. Deletes the state-store Worker and the secrets it created in the
+ * account Secrets Store (the bearer token + the encryption key), then deletes
+ * the Secrets Store itself if it is left empty, and drops the locally cached
+ * state-store credentials for the profile.
+ *
+ * Idempotent — missing resources are treated as already-gone, so it is safe to
+ * re-run. Intended for reclaiming a throwaway account after testing; on a
+ * shared account it only removes resources alchemy created.
+ */
+export const teardownStateStore = (options: TeardownOptions = {}) =>
+  Effect.gen(function* () {
+    const profileName = options.profile ?? (yield* ALCHEMY_PROFILE);
+    const scriptName = options.workerName ?? STATE_STORE_SCRIPT_NAME;
+    const deleteEmptyStore = options.deleteEmptySecretsStore ?? true;
+    const { accountId } =
+      yield* yield* CloudflareEnvironment.CloudflareEnvironment;
+
+    yield* annotateAccountHash();
+    yield* Effect.annotateCurrentSpan({
+      "alchemy.state_store.script_name": scriptName,
+      "alchemy.state_store.profile": profileName,
+    });
+
+    // 1. Delete the state-store Worker.
+    yield* Clank.info(`Deleting state store worker '${scriptName}'...`);
+    yield* workers.deleteScript({ accountId, scriptName, force: true }).pipe(
+      Effect.asVoid,
+      Effect.catchTag("WorkerNotFound", () =>
+        Clank.info(`  Worker '${scriptName}' not found (already gone).`),
+      ),
+    );
+
+    // 2. Delete the secrets the state store created, plus any now-empty store.
+    const ourSecretNames = new Set<string>([
+      AuthTokenSecretName,
+      EncryptionKeySecretName,
+    ]);
+    const stores = yield* SecretsStore.listStores({ accountId }).pipe(
+      Effect.map((r) => r.result),
+      Effect.catchTag("InvalidAccountId", () => Effect.succeed([])),
+    );
+    for (const store of stores) {
+      const secrets = yield* SecretsStore.listStoreSecrets({
+        accountId,
+        storeId: store.id,
+      }).pipe(
+        Effect.map((r) => r.result),
+        Effect.catchTag(["StoreNotFound", "InvalidAccountId"], () =>
+          Effect.succeed([]),
+        ),
+      );
+      const ours = secrets.filter((s) => ourSecretNames.has(s.name));
+      for (const secret of ours) {
+        yield* Clank.info(`Deleting secret '${secret.name}'...`);
+        yield* SecretsStore.deleteStoreSecret({
+          accountId,
+          storeId: store.id,
+          secretId: secret.id,
+        }).pipe(
+          Effect.asVoid,
+          Effect.catchTag(
+            ["SecretNotFound", "StoreNotFound", "NotFound", "InvalidAccountId"],
+            () => Effect.void,
+          ),
+        );
+      }
+      const remaining = secrets.length - ours.length;
+      if (deleteEmptyStore && remaining === 0) {
+        yield* Clank.info(`Deleting empty secrets store '${store.id}'...`);
+        yield* SecretsStore.deleteStore({
+          accountId,
+          storeId: store.id,
+          force: true,
+        }).pipe(
+          Effect.asVoid,
+          Effect.catchTag(
+            ["StoreNotFound", "NotFound", "InvalidAccountId"],
+            () => Effect.void,
+          ),
+        );
+      } else if (remaining > 0) {
+        yield* Clank.info(
+          `Secrets store '${store.id}' still has ${remaining} other ` +
+            `secret(s); leaving it in place.`,
+        );
+      }
+    }
+
+    // 3. Drop the locally cached state-store credentials for this profile.
+    const credStore = yield* CredentialsStore;
+    yield* credStore.delete(profileName, CREDENTIALS_FILE).pipe(Effect.ignore);
+
+    yield* Clank.success(`Cloudflare State Store '${scriptName}' torn down.`);
+  }).pipe(
+    Effect.withSpan("state_store.teardown", {
+      attributes: {
+        "alchemy.state_store.op": "teardown",
+        "alchemy.state_store.script_name":
+          options.workerName ?? STATE_STORE_SCRIPT_NAME,
+      },
+    }),
+  );
+
 const deployStateStore = ({
   stage,
   state,
@@ -619,6 +771,26 @@ const isStateStoreAvailable = (scriptName: string = "alchemy-state-store") =>
     );
   });
 
+/**
+ * Does this account have a *functioning* state-store worker,
+ * verified by checking the /version endpoint
+ *
+ */
+const isStateStoreServing = (accountId: string) =>
+  Effect.gen(function* () {
+    const url = yield* workers.getSubdomain({ accountId }).pipe(
+      Effect.map(({ subdomain }) =>
+        subdomain
+          ? `https://${STATE_STORE_SCRIPT_NAME}.${subdomain}.workers.dev`
+          : undefined,
+      ),
+      Effect.catch(() => Effect.succeed(undefined)),
+    );
+    if (url === undefined) return false;
+    const { observed } = yield* checkStateStoreVersion(url);
+    return observed !== undefined;
+  });
+
 const makeCloudflareStateStore = Effect.fn(function* ({
   url,
   authToken,

package/src/Cloudflare/Website/Vite.ts

@@ -1,5 +1,4 @@
 import * as Effect from "effect/Effect";
-import type { MemoOptions } from "../../Command/Memo.ts";
 import type { InputProps } from "../../Input.ts";
 import { effectClass } from "../../Util/effect.ts";
 import type { Providers } from "../Providers.ts";
@@ -7,26 +6,14 @@ import type { AssetsConfig } from "../Workers/Assets.ts";
 import {
   Worker,
   type NormalizedBindings,
+  type ViteOptions,
   type WorkerAssetsConfig,
   type WorkerBindingProps,
   type WorkerProps,
 } from "../Workers/Worker.ts";
-export interface ViteProps<
-  Bindings extends WorkerBindingProps = {},
-> extends Omit<WorkerProps<Bindings>, "vite" | "main" | "assets"> {
-  /**
-   * Root directory passed to Vite's `root` option.
-   * Defaults to the current working directory (`process.cwd()`).
-   */
-  rootDir?: string;
-  /**
-   * Controls which files are hashed to decide whether a rebuild is needed.
-   * By default every non-gitignored file in `cwd` is hashed, plus the nearest
-   * lockfile. Provide explicit globs to narrow the scope.
-   *
-   * @see {@link MemoOptions}
-   */
-  memo?: MemoOptions;
+
+export interface ViteProps<Bindings extends WorkerBindingProps = {}>
+  extends Omit<WorkerProps<Bindings>, "vite" | "main" | "assets">, ViteOptions {
   /**
    * Optional configuration for static asset routing behavior.
    * Supports `runWorkerFirst`, `htmlHandling`, `notFoundHandling`, etc.
@@ -60,7 +47,7 @@ export interface ViteProps<
  * ```
  *
  * @section SSR Frameworks
- * For SSR frameworks like TanStack Start, SolidStart, or Nuxt, enable
+ * For SSR frameworks like TanStack Start or SolidStart, enable
  * `nodejs_compat` so the server bundle can use Node.js APIs.
  *
  * @example TanStack Start
@@ -78,8 +65,27 @@ export interface ViteProps<
  *   compatibility: {
  *     flags: ["nodejs_compat"],
  *   },
- *   assets: {
- *     config: { runWorkerFirst: true },
+ *   assets: { runWorkerFirst: true },
+ * });
+ * ```
+ *
+ * @section React Server Components
+ * Frameworks that emit more than one server environment (e.g. React
+ * Server Components, which split into an `rsc` environment and an `ssr`
+ * environment) need `viteEnvironments` to declare which environment
+ * produces the deployed Worker entry and which additional server
+ * environments to bundle alongside it. The `client` environment is
+ * always deployed as static assets.
+ *
+ * @example React Router with RSC
+ * ```typescript
+ * const app = yield* Cloudflare.Website.Vite("ReactRouterRSC", {
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *   },
+ *   viteEnvironments: {
+ *     entry: "rsc",
+ *     children: ["ssr"],
  *   },
  * });
  * ```
@@ -95,10 +101,8 @@ export interface ViteProps<
  *     flags: ["nodejs_compat"],
  *   },
  *   assets: {
- *     config: {
- *       htmlHandling: "auto-trailing-slash",
- *       notFoundHandling: "single-page-application",
- *     },
+ *     htmlHandling: "auto-trailing-slash",
+ *     notFoundHandling: "single-page-application",
  *   },
  * });
  * ```
@@ -176,6 +180,7 @@ export const Vite: {
             vite: {
               rootDir: props?.rootDir,
               memo: props?.memo,
+              viteEnvironments: props?.viteEnvironments,
             },
           }),
         ),

package/src/Cloudflare/Workers/Binding.ts

@@ -6,7 +6,7 @@ import type { WorkerBinding } from "./WorkerBinding.ts";
 
 /**
  * A Cloudflare **Worker-only binding** — the plain data value produced by
- * calling a {@link Service} (e.g. `Cloudflare.Images.Images({ name })`).
+ * calling a {@link Service} (e.g. `Cloudflare.Images.Images(name)`).
  *
  * These bindings (`Browser`, `Images`, `VersionMetadata`, `RateLimit`,
  * `Artifacts.Namespace`, …) have **no backing cloud resource**; they are only

package/src/Cloudflare/Workers/Browser.ts

@@ -136,7 +136,7 @@ export interface BrowserClient {
  *
  * Cloudflare.Worker(
  *   "BrowserWorker",
- *   { main: import.meta.filename },
+ *   { main: import.meta.url },
  *   Effect.gen(function* () {
  *     const browser = yield* Cloudflare.Browser("BROWSER");
  *

package/src/Cloudflare/Workers/DurableObject.ts

@@ -354,7 +354,7 @@ export class DurableObjectScope extends Context.Service<
  * //                                       ^^^^^^^ declared as part of WorkerA's public contract
  * export class WorkerA extends Cloudflare.Worker<WorkerA, {}, Counter>()(
  *   "WorkerA",
- *   { main: import.meta.filename },
+ *   { main: import.meta.url },
  * ) {}
  *
  * // WorkerA's Layer also provides the DO's Live implementation.
@@ -374,7 +374,7 @@ export class DurableObjectScope extends Context.Service<
  *
  * export default class WorkerB extends Cloudflare.Worker<WorkerB>()(
  *   "WorkerB",
- *   { main: import.meta.filename },
+ *   { main: import.meta.url },
  *   Effect.gen(function* () {
  *     //              ^^^^^^^^^^^^ scriptName-bound stub of WorkerA's Counter
  *     const counter = yield* Counter.from(WorkerA);
@@ -430,7 +430,7 @@ export class DurableObjectScope extends Context.Service<
  * // workerC.ts — another host of Counter, isolated from WorkerA
  * export class WorkerC extends Cloudflare.Worker<WorkerC, {}, Counter>()(
  *   "WorkerC",
- *   { main: import.meta.filename },
+ *   { main: import.meta.url },
  * ) {}
  *
  * export default WorkerC.make(
@@ -751,6 +751,57 @@ export class DurableObjectScope extends Context.Service<
  *   },
  * });
  * ```
+ *
+ * @section Adopting an Existing Durable Object
+ * When you adopt a Worker that already exists on Cloudflare — created
+ * outside Alchemy via Wrangler, the dashboard, or the raw API — its
+ * Durable Object classes are adopted along with it. You opt in to the
+ * takeover the same way you adopt any foreign resource: with
+ * `adopt(true)` (or the `--adopt` CLI flag), since `Worker.read` reports
+ * a worker with no Alchemy ownership tags as `Unowned`.
+ *
+ * Alchemy normally tracks which class backs each binding through an
+ * `alchemy:do:<logicalId>:<className>` tag it writes on the script. A
+ * foreign worker has no such tag, so on the **adopting deploy** Alchemy
+ * falls back to matching your binding to the live class **by binding
+ * name**. The class is then reused in place — not recreated — so
+ * Cloudflare's migration engine doesn't reject the upload for creating a
+ * class that already exists.
+ *
+ * The consequence is a one-time constraint: **on the adopting deploy the
+ * binding's `className` must match the class that already exists on the
+ * worker.** You cannot rename the class in the same deploy that adopts
+ * it. Once the deploy completes, Alchemy owns the worker and has written
+ * the `alchemy:do:` tag, so subsequent renames are driven by logical id
+ * and work normally.
+ *
+ * @example Adopting a worker whose `Counter` class already exists
+ * ```typescript
+ * // The worker + `Counter` class were created outside Alchemy.
+ * // `className` must match the existing class on this first deploy.
+ * const worker = yield* Cloudflare.Worker("Worker", {
+ *   name: "existing-worker",
+ *   main: "./src/worker.ts",
+ *   bindings: {
+ *     Counter: Cloudflare.DurableObject<Counter>("Counter"),
+ *   },
+ * }).pipe(adopt(true));
+ * ```
+ *
+ * @example Renaming the class — only after adoption
+ * ```typescript
+ * // A SECOND deploy, after the one above. Alchemy now owns the worker
+ * // and maps the binding by logical id, so the class can be renamed.
+ * const worker = yield* Cloudflare.Worker("Worker", {
+ *   name: "existing-worker",
+ *   main: "./src/worker.ts",
+ *   bindings: {
+ *     Counter: Cloudflare.DurableObject<Counter>("Counter", {
+ *       className: "CounterV2",
+ *     }),
+ *   },
+ * });
+ * ```
  */
 export const DurableObject: DurableObjectClass = taggedFunction(
   DurableObjectScope,

package/src/Cloudflare/Workers/InferEnv.ts

@@ -4,6 +4,7 @@ import type * as Effect from "effect/Effect";
 import type { Redacted } from "effect/Redacted";
 import type * as Stream from "effect/Stream";
 import type { Rpc } from "../../Rpc.ts";
+import type { WorkflowLike } from "../Workflows/Workflow.ts";
 // NOTE: import the service modules directly rather than `import * as Cloudflare
 // from "../index.ts"`. Importing the whole Cloudflare barrel here creates a
 // circular re-export when the barrel does `export * from "./Workers/index.ts"`
@@ -20,6 +21,7 @@ import type * as ImagesNs from "../Images/index.ts";
 import type * as KV from "../KV/index.ts";
 import type * as Queues from "../Queues/index.ts";
 import type * as R2 from "../R2/index.ts";
+import type { DispatchNamespace as DispatchNamespaceResource } from "../WorkersForPlatforms/DispatchNamespace.ts";
 import type { Assets } from "./Assets.ts";
 import type { BrowserBinding } from "./BrowserBinding.ts";
 import type { DurableObjectLike } from "./DurableObject.ts";
@@ -53,41 +55,50 @@ export type GetBindingType<T> =
               ? R2Bucket
               : T extends KV.Namespace
                 ? KVNamespace
-                : T extends Queues.Queue
-                  ? Queue<unknown>
-                  : T extends AI.Gateway
-                    ? Ai
-                    : T extends AI.Search
-                      ? AiSearchInstance
-                      : T extends AI.SearchNamespace
-                        ? AiSearchNamespace
-                        : T extends Email.SendEmail
-                          ? SendEmail
-                          : T extends AnalyticsEngine.Dataset
-                            ? AnalyticsEngineDataset
-                            : T extends ArtifactsNs.Namespace
-                              ? Artifacts
-                              : T extends RateLimitBinding
-                                ? RateLimit
-                                : T extends ImagesNs.ImagesBinding
-                                  ? ImagesBinding
-                                  : T extends BrowserBinding
-                                    ? BrowserRun
-                                    : T extends HyperdriveNs.Connection
-                                      ? Hyperdrive
-                                      : T extends VersionMetadataBinding
-                                        ? WorkerVersionMetadata
-                                        : T extends WorkerLoaderResource
-                                          ? WorkerLoader
-                                          : T extends DurableObjectLike
-                                            ? DurableObjectNamespace<
-                                                Exclude<T["Shape"], undefined>
-                                              >
-                                            : T extends Redacted<any>
-                                              ? // redacteds are always stored as secret_text, so are always string
-                                                // we JSON.stringify when not a Redacted<string>
-                                                string
-                                              : T;
+                : T extends DispatchNamespaceResource
+                  ? DispatchNamespace
+                  : T extends Queues.Queue
+                    ? Queue<unknown>
+                    : T extends AI.Gateway
+                      ? Ai
+                      : T extends AI.Search
+                        ? AiSearchInstance
+                        : T extends AI.SearchNamespace
+                          ? AiSearchNamespace
+                          : T extends Email.SendEmail
+                            ? SendEmail
+                            : T extends AnalyticsEngine.Dataset
+                              ? AnalyticsEngineDataset
+                              : T extends ArtifactsNs.Namespace
+                                ? Artifacts
+                                : T extends RateLimitBinding
+                                  ? RateLimit
+                                  : T extends ImagesNs.ImagesBinding
+                                    ? ImagesBinding
+                                    : T extends BrowserBinding
+                                      ? BrowserRun
+                                      : T extends HyperdriveNs.Connection
+                                        ? Hyperdrive
+                                        : T extends VersionMetadataBinding
+                                          ? WorkerVersionMetadata
+                                          : T extends WorkerLoaderResource
+                                            ? WorkerLoader
+                                            : T extends WorkflowLike<
+                                                  infer Params
+                                                >
+                                              ? Workflow<Params>
+                                              : T extends DurableObjectLike
+                                                ? DurableObjectNamespace<
+                                                    Exclude<
+                                                      T["Shape"],
+                                                      undefined
+                                                    >
+                                                  >
+                                                : T extends Redacted<any>
+                                                  ? // redacteds are always stored as secret_text, so are always string
+                                                    // we JSON.stringify when not a Redacted<string>
+                                                    string
+                                                  : T;
 
 /**
  * Cloudflare service-binding wire shape for an Effect-native Worker.
@@ -98,7 +109,7 @@ export type GetBindingType<T> =
  * shape and re-introduced via `Service` so callers get the standard
  * `(input, init?) => Promise<Response>` signature.
  *
- * Use {@link toPromiseApi} to wrap a binding into a Promise<T>-flavored view
+ * Use {@link toRpcAsync} to wrap a binding into a Promise<T>-flavored view
  * where envelopes are decoded for you.
  */
 export type RpcWireShape<Shape> = {