alchemy 2.0.0-beta.32 → 2.0.0-beta.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.32",
+  "version": "2.0.0-beta.34",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
@@ -275,14 +275,14 @@
     "@ai-sdk/provider": "^3.0.8",
     "@aws-sdk/credential-providers": "^3.0.0",
     "@clack/prompts": "^0.11.0",
-    "@distilled.cloud/aws": "^0.16.7",
-    "@distilled.cloud/axiom": "^0.16.7",
-    "@distilled.cloud/cloudflare": "^0.16.8",
+    "@distilled.cloud/aws": "^0.17.0",
+    "@distilled.cloud/axiom": "^0.17.0",
+    "@distilled.cloud/cloudflare": "^0.17.0",
     "@distilled.cloud/cloudflare-rolldown-plugin": "0.3.0",
     "@distilled.cloud/cloudflare-runtime": "0.2.1",
     "@distilled.cloud/cloudflare-vite-plugin": "0.2.0",
-    "@distilled.cloud/core": "^0.16.7",
-    "@distilled.cloud/neon": "^0.16.7",
+    "@distilled.cloud/core": "^0.17.0",
+    "@distilled.cloud/neon": "^0.17.0",
     "pg": "^8.13.0",
     "@effect/vitest": ">=4.0.0-beta.60 || >=4.0.0",
     "@libsql/client": "^0.17.0",

package/src/Cli/commands/dev.ts

@@ -32,14 +32,19 @@ export const devCommand = Command.make(
       dev: true,
     });
     const bin = typeof globalThis.Bun !== "undefined" ? "bun" : "node";
+    const main = fileURLToPath(import.meta.resolve(execEntry));
     const child = yield* ChildProcess.make(
       bin,
-      [
-        "run",
-        "--watch",
-        "--no-clear-screen",
-        fileURLToPath(import.meta.resolve(execEntry)),
-      ],
+      {
+        bun: ["run", ...process.execArgv, "--watch", "--no-clear-screen", main],
+        node: [
+          ...process.execArgv,
+          "--experimental-transform-types",
+          "--watch",
+          "--watch-preserve-output",
+          main,
+        ],
+      }[bin],
       {
         stdin: "inherit",
         stdout: "inherit",

package/src/Cloudflare/StateStore/Api.ts

@@ -1,22 +1,17 @@
-import {
-  BearerTokenValidator,
-  StateApi,
-  StateAuthLive,
-} from "../../State/HttpStateApi.ts";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import * as Etag from "effect/unstable/http/Etag";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import * as HttpPlatform from "effect/unstable/http/HttpPlatform";
 import * as HttpRouter from "effect/unstable/http/HttpRouter";
 import * as HttpApiBuilder from "effect/unstable/httpapi/HttpApiBuilder";
 import * as HttpApiError from "effect/unstable/httpapi/HttpApiError";
-import * as OtlpLogger from "effect/unstable/observability/OtlpLogger";
-import * as OtlpMetrics from "effect/unstable/observability/OtlpMetrics";
-import * as OtlpSerialization from "effect/unstable/observability/OtlpSerialization";
-import * as OtlpTracer from "effect/unstable/observability/OtlpTracer";
 import crypto from "node:crypto";
+import {
+  BearerTokenValidator,
+  StateApi,
+  StateAuthLive,
+} from "../../State/HttpStateApi.ts";
 import * as Secret from "../SecretsStore/Secret.ts";
 import { SecretBindingLive } from "../SecretsStore/SecretBinding.ts";
 import { Worker } from "../Workers/Worker.ts";
@@ -34,7 +29,7 @@ export const STATE_STORE_SCRIPT_NAME = "alchemy-state-store" as const;
  * compare against this constant; a mismatch (or 404) triggers a
  * forced redeploy via the bootstrap flow.
  */
-export const STATE_STORE_VERSION = 2 as const;
+export const STATE_STORE_VERSION = 3 as const;
 
 /**
  * Hard-coded OTLP/HTTP endpoints. Point at the public ingest relay
@@ -43,9 +38,9 @@ export const STATE_STORE_VERSION = 2 as const;
  * coded on purpose: the worker has no env-var plumbing and the relay
  * is account-level infra that lives outside any single deploy.
  */
-const OTEL_TRACES_URL = "https://otel.alchemy.run/v1/traces";
-const OTEL_METRICS_URL = "https://otel.alchemy.run/v1/metrics";
-const OTEL_LOGS_URL = "https://otel.alchemy.run/v1/logs";
+// const OTEL_TRACES_URL = "https://otel.alchemy.run/v1/traces";
+// const OTEL_METRICS_URL = "https://otel.alchemy.run/v1/metrics";
+// const OTEL_LOGS_URL = "https://otel.alchemy.run/v1/logs";
 
 /**
  * OTLP traces + metrics + logs Layer for the state-store worker.
@@ -55,38 +50,38 @@ const OTEL_LOGS_URL = "https://otel.alchemy.run/v1/logs";
  * brand each signal with the worker's service name + contract version
  * so they're easy to slice in Axiom.
  */
-const otelResource = {
-  serviceName: STATE_STORE_SCRIPT_NAME,
-  serviceVersion: String(STATE_STORE_VERSION),
-  attributes: {
-    "alchemy.state_store.script_name": STATE_STORE_SCRIPT_NAME,
-    "alchemy.state_store.version": STATE_STORE_VERSION,
-  },
-} as const;
+// const otelResource = {
+//   serviceName: STATE_STORE_SCRIPT_NAME,
+//   serviceVersion: String(STATE_STORE_VERSION),
+//   attributes: {
+//     "alchemy.state_store.script_name": STATE_STORE_SCRIPT_NAME,
+//     "alchemy.state_store.version": STATE_STORE_VERSION,
+//   },
+// } as const;
 
-const TelemetryLive = Layer.mergeAll(
-  OtlpTracer.layer({
-    url: OTEL_TRACES_URL,
-    resource: otelResource,
-    exportInterval: "1 second",
-  }),
-  OtlpMetrics.layer({
-    url: OTEL_METRICS_URL,
-    resource: otelResource,
-    exportInterval: "1 second",
-  }),
-  // Replace (don't merge with) the default stdout logger so worker logs
-  // ship to Axiom instead of just `wrangler tail`.
-  OtlpLogger.layer({
-    url: OTEL_LOGS_URL,
-    resource: otelResource,
-    exportInterval: "1 second",
-    mergeWithExisting: false,
-  }),
-).pipe(
-  Layer.provide(OtlpSerialization.layerJson),
-  Layer.provide(FetchHttpClient.layer),
-);
+// const TelemetryLive = Layer.mergeAll(
+//   OtlpTracer.layer({
+//     url: OTEL_TRACES_URL,
+//     resource: otelResource,
+//     exportInterval: "1 second",
+//   }),
+//   OtlpMetrics.layer({
+//     url: OTEL_METRICS_URL,
+//     resource: otelResource,
+//     exportInterval: "1 second",
+//   }),
+//   // Replace (don't merge with) the default stdout logger so worker logs
+//   // ship to Axiom instead of just `wrangler tail`.
+//   OtlpLogger.layer({
+//     url: OTEL_LOGS_URL,
+//     resource: otelResource,
+//     exportInterval: "1 second",
+//     mergeWithExisting: false,
+//   }),
+// ).pipe(
+//   Layer.provide(OtlpSerialization.layerJson),
+//   Layer.provide(FetchHttpClient.layer),
+// );
 
 /**
  * Path on disk to *this* file, used as the worker's bundling entry.
@@ -288,7 +283,7 @@ export default Worker(
         // file-response surface is stubbed.
         Layer.provide([Etag.layer, HttpPlatformStub, Path.layer]),
         HttpRouter.toHttpEffect,
-        Effect.provide(TelemetryLive),
+        // Effect.provide(TelemetryLive),
       ),
     };
   }).pipe(Effect.provide(Layer.mergeAll(SecretBindingLive))),

package/src/Cloudflare/StateStore/State.ts

@@ -1,13 +1,14 @@
 import * as SecretsStore from "@distilled.cloud/cloudflare/secrets-store";
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as Effect from "effect/Effect";
-import * as Output from "../../Output.ts";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
 import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
 import crypto from "node:crypto";
+import * as Output from "../../Output.ts";
 
 import * as Config from "effect/Config";
 import { adopt } from "../../AdoptPolicy.ts";
@@ -198,32 +199,7 @@ export const bootstrap = (options: BootstrapOptions = {}) =>
     }),
   );
 
-export const state = (props?: {
-  /**
-   * The name of the script to use for the state store.
-   * @default "alchemy-state-store"
-   */
-  workerName?: string;
-  /**
-   * Suppress the per-deployment Cloudflare account hash on telemetry
-   * spans. Lets a caller opt out of having their state-store's
-   * accountId pseudonymously counted on the maintainer dashboard
-   * without disabling all telemetry.
-   *
-   * - `true`  — always opt out, regardless of env.
-   * - `false` — always opt in, regardless of env.
-   * - `undefined` (default) — fall back to the `NO_TRACK` env var
-   *   (`true`/`1` → opt out). Default-default is opt-in.
-   *
-   * Independent of the global telemetry kill-switch
-   * (`DO_NOT_TRACK` / `ALCHEMY_TELEMETRY_DISABLED`), which kills the
-   * entire OTLP exporter — `noTrack` here only suppresses the
-   * `alchemy.cloudflare.account_hash` attribute on state-store
-   * spans, leaving the rest of the telemetry intact.
-   * @default undefined
-   */
-  noTrack?: boolean;
-}) =>
+export const state = () =>
   Layer.effect(
     State,
     Effect.gen(function* () {
@@ -235,13 +211,15 @@ export const state = (props?: {
         CREDENTIALS_FILE,
       );
 
-      const scriptName = props?.workerName ?? STATE_STORE_SCRIPT_NAME;
+      const scriptName = STATE_STORE_SCRIPT_NAME;
       yield* Effect.annotateCurrentSpan({
         "alchemy.state_store.script_name": scriptName,
         "alchemy.state_store.profile": profileName,
         "alchemy.state_store.ci": isCI,
       });
-      yield* annotateAccountHash(props?.noTrack);
+      yield* annotateAccountHash(
+        yield* Config.boolean("NO_TRACK").pipe(Config.withDefault(false)),
+      );
 
       // The bootstrap of the Cloudflare State Store is only considered
       // successful once two invariants hold:
@@ -529,6 +507,16 @@ const deployStateStore = (scriptName: string, state?: StateService) =>
       // TODO(sam): we should not need to do this, but types do complain. fix deploy
       Effect.provide(stateLayer),
     );
+    // Cloudflare's worker upload is eventually consistent: the deploy
+    // call returns as soon as the script upload is accepted, but the
+    // edge can keep serving the previous version for several seconds
+    // afterwards. Block here until `/version` reports the version this
+    // CLI was built against — otherwise downstream steps (syncing
+    // local state into the deployed store, version probes during
+    // adoption) end up talking to the old worker and may either
+    // observe stale data or trip the staleness check and recurse into
+    // another redeploy.
+    yield* waitForStateStoreVersion(url);
     return { url, authToken, localState };
   }).pipe(
     Effect.withSpan("state_store.deploy", {
@@ -694,19 +682,84 @@ const redeployIfStale = ({
  * since the caller's response in every case is the same: fall
  * through to the idempotent bootstrap flow.
  */
+/**
+ * Block until the worker at `url` reports the {@link STATE_STORE_VERSION}
+ * this CLI was built against, with bounded exponential retry. Used
+ * post-deploy to wait out Cloudflare's edge cache so any subsequent
+ * read or write goes to the new worker.
+ *
+ * Failures (transport errors, 404 from a pre-`/version` build, schema
+ * mismatch, version mismatch) all collapse to "not ready yet" and are
+ * retried; once the budget is exhausted we surface a hard failure
+ * since continuing would talk to the wrong worker.
+ */
+class StateStoreVersionNotReady extends Error {
+  readonly _tag = "StateStoreVersionNotReady";
+  constructor(
+    readonly expected: number,
+    readonly observed: number | undefined,
+  ) {
+    super(
+      `Cloudflare State Store version not ready (expected v${expected}, observed v${observed ?? "unknown"}).`,
+    );
+  }
+}
+
+const waitForStateStoreVersion = (url: string) =>
+  Effect.gen(function* () {
+    const { matches, expected, observed } = yield* checkStateStoreVersion(url);
+    if (!matches) {
+      return yield* Effect.fail(
+        new StateStoreVersionNotReady(expected, observed),
+      );
+    }
+  }).pipe(
+    Effect.retry({
+      while: (error) => error instanceof StateStoreVersionNotReady,
+      // Edge propagation is usually sub-second; poll fast and cap the
+      // overall wait at ~10s so we fail loudly if something is really
+      // wrong rather than silently hanging.
+      schedule: Schedule.spaced("200 millis").pipe(
+        Schedule.both(Schedule.recurs(50)),
+      ),
+    }),
+    Effect.withSpan("state_store.wait_for_version", {
+      attributes: {
+        "alchemy.state_store.op": "wait_for_version",
+        "alchemy.state_store.url": url,
+        "alchemy.state_store.expected_version": STATE_STORE_VERSION,
+      },
+    }),
+  );
+
 const checkStateStoreVersion = (url: string) =>
   Effect.gen(function* () {
     const client = yield* HttpApiClient.make(StateApi, { baseUrl: url });
-    const result = yield* client.version
-      .getVersion()
-      .pipe(Effect.catch(() => Effect.succeed(undefined)));
+    // The /version route may 404 transiently after a fresh deploy
+    // while Cloudflare propagates the new script to the edge, and may
+    // also surface transport-level blips on cold workers.dev hosts.
+    // Retry the probe itself for ~10s before giving up — only after
+    // exhausting that budget do we collapse to `undefined` and let
+    // the caller treat it as a version mismatch.
+    const result = yield* client.version.getVersion().pipe(
+      Effect.retry({
+        schedule: Schedule.spaced("250 millis").pipe(
+          Schedule.both(Schedule.recurs(40)),
+        ),
+      }),
+      Effect.catch(() => Effect.succeed(undefined)),
+    );
     const matches = result?.version === STATE_STORE_VERSION;
     yield* Effect.annotateCurrentSpan({
       "alchemy.state_store.expected_version": STATE_STORE_VERSION,
       "alchemy.state_store.observed_version": result?.version ?? -1,
       "alchemy.state_store.version_match": matches,
     });
-    return { matches, expected: STATE_STORE_VERSION, observed: result?.version };
+    return {
+      matches,
+      expected: STATE_STORE_VERSION,
+      observed: result?.version,
+    };
   }).pipe(
     Effect.withSpan("state_store.check_version", {
       attributes: { "alchemy.state_store.op": "check_version" },

package/src/Cloudflare/Workers/Worker.ts

@@ -893,8 +893,8 @@ export const Worker: Platform<
                 const scope = Scope.makeUnsafe();
                 return eff
                   .pipe(
-                    Scope.provide(scope),
                     Effect.provideContext(services),
+                    Scope.provide(scope),
                     Effect.provide(
                       Layer.succeed(WorkerExecutionContext, context),
                     ),
@@ -1091,11 +1091,18 @@ export const LiveWorkerProvider = () =>
           accountId,
         }).pipe(Effect.map((result) => result.subdomain));
 
+      // Toggle the workers.dev subdomain via `POST /subdomain` with
+      // `enabled: true | false`. Mirrors the upstream Alchemy
+      // implementation in `.vendor/alchemy/.../worker-subdomain.ts`.
+      // When enabling we also set `previewsEnabled: true` so the
+      // script is reachable both at its stable workers.dev URL and at
+      // version-preview URLs; on disable we send just `enabled: false`.
       const setWorkerSubdomain = (name: string, enabled: boolean) =>
         createScriptSubdomain({
           accountId,
           scriptName: name,
           enabled,
+          previewsEnabled: enabled ? true : undefined,
         });
 
       const createWorkerName = (id: string, name: string | undefined) =>
@@ -1923,12 +1930,26 @@ export const LiveWorkerProvider = () =>
             name,
             expectedDurableObjectClassNames,
           );
-        if (!olds || news.url !== olds.url) {
-          const enable = news.url !== false;
+        // Reconcile workers.dev subdomain against observed cloud state.
+        // We can't diff `news.url` against `olds.url` here because both
+        // default to `undefined` (meaning "enable") — that comparison
+        // would skip the API call on every deploy where the user never
+        // explicitly set `url`, leaving the subdomain in whatever state
+        // Cloudflare currently has it (disabled by default, or whatever
+        // a previous failed/external action left it as).
+        const desiredSubdomainEnabled = news.url !== false;
+        const observedSubdomainEnabled = yield* getScriptSubdomain({
+          accountId,
+          scriptName: name,
+        }).pipe(
+          Effect.map((s) => s.enabled === true),
+          Effect.catch(() => Effect.succeed(false)),
+        );
+        if (desiredSubdomainEnabled !== observedSubdomainEnabled) {
           yield* session.note(
-            `${enable ? "Enabling" : "Disabling"} workers.dev subdomain...`,
+            `${desiredSubdomainEnabled ? "Enabling" : "Disabling"} workers.dev subdomain...`,
           );
-          yield* setWorkerSubdomain(name, enable);
+          yield* setWorkerSubdomain(name, desiredSubdomainEnabled);
         }
         const desiredDomains = normalizeDomains(news.domain);
         const previousDomains = output?.domains ?? [];

package/src/State/HttpStateApi.ts

@@ -11,7 +11,21 @@ import * as HttpApiMiddleware from "effect/unstable/httpapi/HttpApiMiddleware";
 import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
 import * as HttpApiSecurity from "effect/unstable/httpapi/HttpApiSecurity";
 
-export const ResourceStateSchema = Schema.Any;
+/**
+ * Resource-state payload shape on the wire.
+ *
+ * Pinned to JSON encoding via {@link HttpApiSchema.asJson} so that both
+ * sides of the API agree on `Content-Type: application/json`. With a
+ * bare `Schema.Any` the server's payload-decoder map is keyed off the
+ * default content type only — any client request that arrives with a
+ * differently-shaped body (or a transport that drops the
+ * `Content-Type` header entirely) falls into the `payloadBy.get(
+ * contentType)` miss branch in `HttpApiBuilder.decodePayload` and
+ * surfaces as a confusing `415 Unsupported Media Type`. Annotating
+ * the schema makes the encoding explicit on both endpoints and the
+ * client encoder, so the wire format is unambiguous.
+ */
+export const ResourceStateSchema = Schema.Any.pipe(HttpApiSchema.asJson());
 
 export class BearerTokenValidator extends Context.Service<
   BearerTokenValidator,

package/src/State/HttpStateStore.ts

@@ -159,13 +159,12 @@ const isTransient = (e: any): boolean => {
 const retryTransient = <A, Err, Req>(eff: Effect.Effect<A, Err, Req>) =>
   Effect.retry(eff, {
     while: isTransient,
-    // Exponential backoff capped at 2s, no attempt limit. The state
-    // store is on the deploy critical path; we'd rather block than
-    // surface a transient blip as a hard failure (which historically
-    // stranded `syncState` mid-flight, leaving the remote store
-    // partially populated).
+    // Exponential backoff capped at 2s, max 5 attempts. Beyond that
+    // the issue isn't transient and we'd rather surface a hard
+    // failure than block the deploy indefinitely.
     schedule: Schedule.exponential(100).pipe(
       Schedule.either(Schedule.spaced("2 seconds")),
+      Schedule.both(Schedule.recurs(5)),
     ),
   });