alchemy 2.0.0-beta.62 → 2.0.0-beta.63

package/src/Cloudflare/Workers/WorkerRuntimeContext.ts

@@ -2,9 +2,12 @@ import type * as cf from "@cloudflare/workers-types";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as Redacted from "effect/Redacted";
 import type { HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
+import {
+  packEnvValueKeepRedacted,
+  unpackEnvValue,
+} from "../../RuntimeContext.ts";
 import type * as Serverless from "../../Serverless/index.ts";
 import type { DurableObjectExport } from "./DurableObject.ts";
 import { makeRequestHandler } from "./HttpServer.ts";
@@ -37,53 +40,19 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
     get: (key: string) =>
       Effect.serviceOption(WorkerEnvironment).pipe(
         Effect.map(Option.getOrUndefined),
-        // Key is already canonical (see RuntimeContext.sanitizeKey).
-        Effect.map((env) => env?.[key]),
-        Effect.map((json) => {
-          if (json === undefined) {
-            return undefined;
-          }
-          try {
-            const value = JSON.parse(json);
-            // The `set` path serializes Redacted values as
-            // `{_tag: "Redacted", value: ...}`. After JSON.parse the
-            // result is a plain object — `Redacted.isRedacted` would
-            // always return `false` on it — so detect the marker shape
-            // and rebuild the Redacted wrapper. Plain values pass
-            // through unchanged.
-            if (
-              typeof value === "object" &&
-              value?._tag === "Redacted" &&
-              "value" in value
-            ) {
-              return Redacted.make((value as { value: unknown }).value);
-            }
-            return value;
-          } catch {
-            return json;
-          }
-        }),
+        // Key is already canonical (see RuntimeContext.sanitizeKey). Read
+        // straight from `WorkerEnvironment` — see `unpackEnvValue` for why
+        // this must never resolve through `Config.string`.
+        Effect.map((env) => unpackEnvValue(env?.[key])),
       ) as any,
     set: (key: string, output: Output.Output) =>
       Effect.sync(() => {
-        // Preserve `Redacted`-ness across the Output → env → Cloudflare
-        // binding boundary so the put-worker loop can deploy secrets via
-        // `secret_text` instead of leaking them as `plain_text`. The JSON
-        // payload still carries the `{_tag: "Redacted", …}` marker so the
-        // runtime `get` accessor can rebuild the wrapper after Cloudflare
-        // hands the binding back as a plain string.
-        env[key] = output.pipe(
-          Output.map((value) =>
-            Redacted.isRedacted(value)
-              ? Redacted.make(
-                  JSON.stringify({
-                    _tag: "Redacted",
-                    value: Redacted.value(value),
-                  }),
-                )
-              : JSON.stringify(value),
-          ),
-        );
+        // `packEnvValueKeepRedacted` keeps the Redacted wrapper on the
+        // outside so the put-worker loop can deploy secrets via
+        // `secret_text` instead of leaking them as `plain_text`, while the
+        // inner marker lets the runtime `get` accessor rebuild the wrapper
+        // after Cloudflare hands the binding back as a plain string.
+        env[key] = output.pipe(Output.map(packEnvValueKeepRedacted));
         return key;
       }),
     serve: <Req = never>(

package/src/Cloudflare/Workers/index.ts

@@ -2,6 +2,7 @@ export * from "./AccountSetting.ts";
 export * from "./Assets.ts";
 export * from "./Browser.ts";
 export * from "./BrowserBinding.ts";
+export * from "./BrowserLocal.ts";
 export * from "./Cache.ts";
 export * from "./ConfigProvider.ts";
 export * from "./CronEventSource.ts";

package/src/Diff.ts

@@ -1,3 +1,4 @@
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import type { Input } from "./Input.ts";
@@ -53,6 +54,38 @@ const _hasUnresolved = (value: unknown): boolean => {
   return false;
 };
 
+/**
+ * Deeply replace every unresolved plan-time expression (an `Output`/`Expr`
+ * or an un-evaluated `Effect`) with `undefined`, leaving resolved values
+ * (including opaque `Redacted`/`Duration` instances) intact.
+ *
+ * Persisted resource state must only ever hold plain data. Durable (JSON)
+ * state stores already enforce this implicitly — Output proxies are
+ * function-typed, so `JSON.stringify` silently drops them — but the
+ * in-memory store used by tests retains live proxies, which would later be
+ * fed back into provider lifecycle operations as `olds` after an
+ * interrupted apply (e.g. `read` during a destroy plan) and blow up on
+ * first string coercion. Sanitizing at the commit boundary keeps both
+ * store kinds consistent with the provider contract that `olds` is
+ * resolved `Props`.
+ */
+export const stripUnresolved = <T>(value: T): T => _stripUnresolved(value) as T;
+
+const _stripUnresolved = (value: unknown): unknown => {
+  if (value == null || isPrimitive(value)) return value;
+  if (Output.isExpr(value) || Effect.isEffect(value)) return undefined;
+  // Opaque resolved values — rebuilding them structurally would strip
+  // their prototype (see resolveInput in Plan.ts for the same rule).
+  if (Redacted.isRedacted(value) || Duration.isDuration(value)) return value;
+  if (Array.isArray(value)) return value.map(_stripUnresolved);
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, _stripUnresolved(item)]),
+    );
+  }
+  return value;
+};
+
 export const somePropsAreDifferent = <Props extends Record<string, any>>(
   olds: Props,
   news: Props,

package/src/GitHub/Secrets.ts

@@ -41,7 +41,7 @@ export interface SecretsProps {
  * ```ts
  * yield* GitHub.Secrets({
  *   owner: "alchemy-run",
- *   repository: "alchemy-effect",
+ *   repository: "alchemy",
  *   secrets: {
  *     AXIOM_INGEST_TOKEN: tokenValue,
  *     AXIOM_DATASET_TRACES: traces.name,

package/src/GitHub/Variables.ts

@@ -33,7 +33,7 @@ export interface VariablesProps {
  * ```ts
  * yield* GitHub.Variables({
  *   owner: "alchemy-run",
- *   repository: "alchemy-effect",
+ *   repository: "alchemy",
  *   variables: {
  *     AWS_ROLE_ARN: role.roleArn,
  *     AWS_REGION: region,

package/src/Local/RpcSerialization.ts

@@ -7,6 +7,7 @@ import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import * as NodeUtil from "node:util";
 import * as Output from "../Output.ts";
+import { isRedactedMarker, type RedactedMarker } from "../RuntimeContext.ts";
 
 type RpcEffectHandler<Args extends Array<any>, Success, Error> = (
   ...args: Args
@@ -173,7 +174,10 @@ const unwrapRpcStreamHandler = <Args extends Array<any>, Success, Error>(
 
 const serializeRpcArgs = (value: unknown): unknown => {
   if (Redacted.isRedacted(value)) {
-    return { _tag: "Redacted", value: Redacted.value(value) };
+    return {
+      _tag: "Redacted",
+      value: Redacted.value(value),
+    } satisfies RedactedMarker;
   }
   if (Output.isOutput(value)) {
     return {
@@ -204,7 +208,7 @@ const deserializeRpcArgs = (value: unknown): unknown => {
   } else if (typeof value === "object" && value !== null) {
     // These values are serialized as `{_tag: "Redacted", value: ...}` and `{_tag: "Output", description: ...}`,
     // so we need to detect them manually - Redacted.isRedacted and Output.isOutput do not work.
-    if ("_tag" in value && value._tag === "Redacted" && "value" in value) {
+    if (isRedactedMarker(value)) {
       return Redacted.make(value.value);
     } else if (
       "_tag" in value &&

package/src/Local/RpcSpawner.ts

@@ -1,5 +1,6 @@
 import { exitHook } from "@alchemy.run/node-utils/exit-hook";
 import * as Cache from "effect/Cache";
+import * as Console from "effect/Console";
 import * as Context from "effect/Context";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
@@ -78,7 +79,11 @@ export const make = Effect.fn(function* ({
       }[bin],
       {
         stdout: "pipe",
-        stderr: "inherit",
+        // Piped (NOT inherited) so the child's output routes through the
+        // Effect Console service: raw writes to the parent's fd corrupt the
+        // test runner's reporter/TUI. The drain below is mandatory — an
+        // unread pipe eventually fills and blocks the child.
+        stderr: "pipe",
         detached: false,
         env: {
           [RPC_SERVER_ENVIRONMENT_KEY]: JSON.stringify(environment),
@@ -87,6 +92,13 @@ export const make = Effect.fn(function* ({
       },
     );
     const handle = yield* spawner.spawn(command);
+    yield* handle.stderr.pipe(
+      Stream.decodeText,
+      Stream.splitLines,
+      Stream.runForEach((line) => Console.error(line)),
+      Effect.ignore,
+      Effect.forkScoped,
+    );
     const unregister = exitHook(() => {
       killProcessGroup(handle.pid, "SIGKILL");
     });
@@ -168,13 +180,14 @@ const getRpcAddress = (stdout: Stream.Stream<Uint8Array, PlatformError>) =>
       Stream.splitLines,
       Stream.runForEach((line) => {
         if (done) {
-          console.log(line);
-        } else {
-          const match = line.match(RPC_ADDRESS_REGEX);
-          if (match) {
-            done = true;
-            return Deferred.succeed(address, match[2]);
-          }
+          // Through the Console SERVICE so runners that override it (e.g.
+          // alchemy-test's per-test buffer) capture the sidecar's output.
+          return Console.log(line);
+        }
+        const match = line.match(RPC_ADDRESS_REGEX);
+        if (match) {
+          done = true;
+          return Deferred.succeed(address, match[2]);
         }
         return Effect.void;
       }),

package/src/Neon/AuthProvider.ts

@@ -129,7 +129,7 @@ export const NeonAuth = AuthProviderLayer<
                 ? Effect.fail(
                     new AuthError({
                       message:
-                        "Neon stored credentials not found. Run: alchemy-effect login --configure",
+                        "Neon stored credentials not found. Run: alchemy login --configure",
                     }),
                   )
                 : Effect.succeed({

package/src/Plan.ts

@@ -543,7 +543,18 @@ export const make = <A>(
         (action) =>
           [
             action.FQN,
-            Object.values(Output.upstreamAny(action.Input)).map((r) => r.FQN),
+            // An Action depends on the resources referenced by its Input *and*
+            // any Output captured via `yield* output` inside its init Effect.
+            Array.from(
+              new Set([
+                ...Object.values(Output.upstreamAny(action.Input)).map(
+                  (r) => r.FQN,
+                ),
+                ...Object.values(Output.upstreamAny(action.Captures)).map(
+                  (r) => r.FQN,
+                ),
+              ]),
+            ),
           ] as const,
       ),
     ]);
@@ -572,7 +583,8 @@ export const make = <A>(
         const bindDeps = bindingUpstreamDependencies[fqn] ?? [];
         return [fqn, [...new Set([...propDeps, ...bindDeps])]];
       }),
-      // Actions have no bindings — their upstream is purely their input.
+      // Actions have no bindings — their upstream is input + init captures,
+      // both already folded into newUpstreamDependencies above.
       ...actions.map((action): [string, string[]] => {
         const fqn = action.FQN;
         return [fqn, newUpstreamDependencies[fqn] ?? []];
@@ -717,7 +729,7 @@ export const make = <A>(
             // If planning persisted here, a mere `alchemy plan` / `--dry-run`
             // would claim ownership of an unowned cloud resource, arming a
             // later unrelated deploy to orphan-delete it. See
-            // https://github.com/alchemy-run/alchemy-effect/issues/793.
+            // https://github.com/alchemy-run/alchemy/issues/793.
             //
             // After a cold-start adoption (engine just discovered an
             // existing cloud resource via `read`), force the engine's
@@ -784,7 +796,7 @@ export const make = <A>(
                 // The adopted state rides onto the plan node via `oldState`
                 // (→ `node.state`) and is persisted at APPLY time by the
                 // update lifecycle's `updating` / `updated` commits. See
-                // https://github.com/alchemy-run/alchemy-effect/issues/793.
+                // https://github.com/alchemy-run/alchemy/issues/793.
                 oldState = adoptedState;
                 forceUpdateAfterAdoption = true;
               }
@@ -1212,6 +1224,7 @@ export const make = <A>(
                   LogicalId: logicalId,
                   Type: persisted.actionType,
                   Input: persisted.input,
+                  Captures: {},
                   Run: () => undefined as any,
                   Output: undefined as any,
                 } satisfies ActionLike,

package/src/Planetscale/Database.ts

@@ -29,7 +29,8 @@ export interface BaseDatabaseProps {
 
   /**
    * Number of replicas for the database. `0` for non-HA, `2+` for HA.
-   * Create-only.
+   * Create-only for PostgreSQL databases; MySQL databases reconcile
+   * changes in place ({@link MySQLDatabaseProps.replicas}).
    */
   replicas?: number;
 

package/src/Planetscale/MySQL/MySQLClusterSize.ts

@@ -1,6 +1,7 @@
 import * as ops from "@distilled.cloud/planetscale/Operations";
 import * as Effect from "effect/Effect";
-import { pollUntil } from "../Util.ts";
+import * as Schedule from "effect/Schedule";
+import { PlanetscaleConflict, pollUntil } from "../Util.ts";
 
 /**
  * Available PlanetScale MySQL (Vitess) cluster sizes.
@@ -55,15 +56,15 @@ export const waitForKeyspaceReady = Effect.fn(function* (
 });
 
 /**
- * Ensures the default keyspace of a MySQL production branch has the
- * expected cluster size, triggering a resize if it doesn't. Cluster sizes
- * can only be configured on production branches.
+ * Observes the default keyspace of a branch. The default keyspace usually
+ * shares the database's name, but a renamed database keeps its original
+ * keyspace name, so prefer the `default` flag and fall back to name
+ * matching.
  */
-export const ensureMySQLProductionBranchClusterSize = Effect.fn(function* (
+const observeDefaultKeyspace = Effect.fn(function* (
   organization: string,
   database: string,
   branch: string,
-  expectedClusterSize: MySQLClusterSize,
 ) {
   const keyspaces = yield* ops.listKeyspaces({
     organization,
@@ -72,31 +73,129 @@ export const ensureMySQLProductionBranchClusterSize = Effect.fn(function* (
     page: 1,
     per_page: 100,
   });
-  // Default keyspace is always the same name as the database.
-  const defaultKeyspace = keyspaces.data.find((x) => x.name === database);
-  if (!defaultKeyspace) {
+  return (
+    keyspaces.data.find((x) => x.default) ??
+    keyspaces.data.find((x) => x.name === database)
+  );
+});
+
+/**
+ * Observes the total replica count of a branch's default keyspace, or
+ * `undefined` when the branch or keyspace does not exist (yet).
+ */
+export const observeDefaultKeyspaceReplicas = Effect.fn(function* (
+  organization: string,
+  database: string,
+  branch: string,
+) {
+  return yield* observeDefaultKeyspace(organization, database, branch).pipe(
+    Effect.map((keyspace) => keyspace?.replicas),
+    Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+  );
+});
+
+/**
+ * Ensures the default keyspace of a MySQL production branch has the
+ * expected cluster size and (optionally) total replica count, driving
+ * PlanetScale's in-place keyspace resize lifecycle when it doesn't.
+ * Cluster sizes can only be configured on production branches. Returns
+ * the final observed keyspace.
+ */
+export const ensureMySQLProductionBranchClusterSize = Effect.fn(function* (
+  organization: string,
+  database: string,
+  branch: string,
+  expectedClusterSize: MySQLClusterSize,
+  expectedReplicas?: number,
+) {
+  let keyspace = yield* observeDefaultKeyspace(organization, database, branch);
+  if (!keyspace) {
     return yield* Effect.die(`No default keyspace found for branch ${branch}`);
   }
 
-  yield* waitForKeyspaceReady(
-    organization,
-    database,
-    branch,
-    defaultKeyspace.name,
-  );
+  yield* waitForKeyspaceReady(organization, database, branch, keyspace.name);
 
-  if (defaultKeyspace.cluster_name !== expectedClusterSize) {
+  if (keyspace.cluster_name !== expectedClusterSize) {
     yield* ops.updateBranchClusterConfig({
       organization,
       database,
       branch,
       cluster_size: expectedClusterSize,
     });
-    yield* waitForKeyspaceReady(
-      organization,
-      database,
-      branch,
-      defaultKeyspace.name,
+    yield* waitForKeyspaceReady(organization, database, branch, keyspace.name);
+    // Re-observe so the replica sync below diffs against the post-resize
+    // keyspace state.
+    keyspace =
+      (yield* observeDefaultKeyspace(organization, database, branch)) ??
+      keyspace;
+  }
+
+  // Sync replicas — MySQL databases cannot configure replicas at
+  // creation time (the API rejects the `replicas` param for mysql), so
+  // the desired total replica count is converged in place via a keyspace
+  // resize request.
+  if (
+    expectedReplicas !== undefined &&
+    keyspace.replicas !== expectedReplicas
+  ) {
+    // Each cluster size includes a fixed number of replicas (2 for
+    // production PS_* sizes); the resize API only accepts the count of
+    // additional replicas beyond that.
+    const includedReplicas = keyspace.replicas - keyspace.extra_replicas;
+    const extraReplicas = expectedReplicas - includedReplicas;
+    if (extraReplicas < 0) {
+      return yield* Effect.fail(
+        new PlanetscaleConflict({
+          message:
+            `Cannot set replicas to ${expectedReplicas} on keyspace "${keyspace.name}": ` +
+            `cluster size ${keyspace.cluster_name} always includes ${includedReplicas} replicas. ` +
+            `Set replicas to ${includedReplicas} or more (or omit it).`,
+        }),
+      );
+    }
+
+    const resize = yield* ops
+      .createKeyspaceResizeRequest({
+        organization,
+        database,
+        branch,
+        keyspace: keyspace.name,
+        extra_replicas: extraReplicas,
+      })
+      .pipe(
+        // A prior resize (e.g. the cluster-size change above) can still
+        // be finalizing after the keyspace reports `resizing: false`;
+        // PlanetScale rejects new resize requests during that window.
+        Effect.retry({
+          while: (e): boolean =>
+            e._tag === "UnprocessableEntity" &&
+            e.message.includes("resize in progress"),
+          schedule: Schedule.max([
+            Schedule.spaced("5 seconds"),
+            Schedule.recurs(120),
+          ]),
+        }),
+      );
+
+    yield* pollUntil(
+      `keyspace "${keyspace.name}" resize completed`,
+      ops.listKeyspaceResizeRequests({
+        organization,
+        database,
+        branch,
+        keyspace: keyspace.name,
+      }),
+      (page) => {
+        const request = page.data.find((r) => r.id === resize.id);
+        // If the request is missing, treat as settled (caller re-observes).
+        return request ? request.state === "completed" : true;
+      },
     );
+
+    keyspace =
+      (yield* observeDefaultKeyspace(organization, database, branch)) ??
+      keyspace;
   }
+
+  return keyspace;
 });