alchemy 2.0.0-beta.60 → 2.0.0-beta.62

package/src/Cloudflare/Healthcheck/Healthcheck.ts

@@ -293,7 +293,9 @@ export type Healthcheck = Resource<TypeId, Props, Attributes, never, Providers>;
  *
  * @see https://developers.cloudflare.com/health-checks/
  */
-export const Healthcheck = Resource<Healthcheck>(TypeId);
+export const Healthcheck = Resource<Healthcheck>(TypeId, {
+  aliases: ["Cloudflare.Healthcheck"],
+});
 
 /**
  * Returns true if the given value is a Healthcheck resource.

package/src/Cloudflare/HostnameTlsSetting/HostnameTlsSetting.ts

@@ -150,7 +150,9 @@ export type HostnameTlsSetting = Resource<
  * @see https://developers.cloudflare.com/ssl/edge-certificates/additional-options/custom-metadata/
  * @see https://developers.cloudflare.com/api/resources/hostnames/subresources/settings/subresources/tls/
  */
-export const HostnameTlsSetting = Resource<HostnameTlsSetting>(TypeId);
+export const HostnameTlsSetting = Resource<HostnameTlsSetting>(TypeId, {
+  aliases: ["Cloudflare.HostnameTlsSetting"],
+});
 
 /**
  * Returns true if the given value is a HostnameTlsSetting resource.

package/src/Cloudflare/Hyperdrive/Connection.ts

@@ -1,6 +1,5 @@
 import * as hyperdrive from "@distilled.cloud/cloudflare/hyperdrive";
 import * as Effect from "effect/Effect";
-import * as Predicate from "effect/Predicate";
 import * as Redacted from "effect/Redacted";
 import * as Stream from "effect/Stream";
 
@@ -8,7 +7,7 @@ import { AlchemyContext } from "../../AlchemyContext.ts";
 import { isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
-import { Resource } from "../../Resource.ts";
+import { isResourceOfType, Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import { generateLocalId, isLiveId } from "../LocalRuntime.ts";
 import type { Providers } from "../Providers.ts";
@@ -160,8 +159,7 @@ export type Connection = Resource<
 export const Connection = Resource<Connection>("Cloudflare.Hyperdrive");
 
 export const isHyperdriveConnection = (value: unknown): value is Connection =>
-  Predicate.hasProperty(value, "Type") &&
-  value.Type === "Cloudflare.Hyperdrive";
+  isResourceOfType(value, "Cloudflare.Hyperdrive");
 
 export const ConnectionProvider = () =>
   Provider.succeed(Connection, {

package/src/Cloudflare/Images/Variant.ts

@@ -322,9 +322,10 @@ export const VariantProvider = () =>
       // Bounded — if it never clears we stop polling and proceed.
       yield* getVariant(output.accountId, output.variantName).pipe(
         Effect.repeat({
-          schedule: Schedule.exponential("500 millis").pipe(
-            Schedule.both(Schedule.recurs(12)),
-          ),
+          schedule: Schedule.max([
+            Schedule.exponential("500 millis"),
+            Schedule.recurs(12),
+          ]),
           until: (observed) => observed === undefined,
         }),
       );

package/src/Cloudflare/KV/Namespace.ts

@@ -5,13 +5,12 @@ import * as Stream from "effect/Stream";
 import { isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
-import { Resource } from "../../Resource.ts";
+import { isResourceOfType, Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type { Providers } from "../Providers.ts";
 
 export const isNamespace = (value: unknown): value is Namespace =>
-  typeof value === "object" &&
-  (value as any)?.Type === "Cloudflare.KV.Namespace";
+  isResourceOfType(value, "Cloudflare.KV.Namespace");
 
 export type NamespaceProps = {
   /**
@@ -68,7 +67,9 @@ export type Namespace = Resource<
  * / `Cloudflare.KV.WriteNamespace` for least-privilege read- or
  * write-only access.
  */
-export const Namespace = Resource<Namespace>("Cloudflare.KV.Namespace");
+export const Namespace = Resource<Namespace>("Cloudflare.KV.Namespace", {
+  aliases: ["Cloudflare.KVNamespace"],
+});
 
 export const NamespaceProvider = () =>
   Provider.succeed(Namespace, {

package/src/Cloudflare/KeylessCertificate/KeylessCertificate.ts

@@ -214,7 +214,9 @@ export type KeylessCertificate = Resource<
  *
  * @see https://developers.cloudflare.com/ssl/keyless-ssl/
  */
-export const KeylessCertificate = Resource<KeylessCertificate>(TypeId);
+export const KeylessCertificate = Resource<KeylessCertificate>(TypeId, {
+  aliases: ["Cloudflare.KeylessCertificate"],
+});
 
 /**
  * Returns true if the given value is a KeylessCertificate resource.

package/src/Cloudflare/LeakedCredentialCheck/LeakedCredentialCheck.ts

@@ -91,7 +91,9 @@ export type LeakedCredentialCheck = Resource<
  *
  * @see https://developers.cloudflare.com/waf/detections/leaked-credentials/
  */
-export const LeakedCredentialCheck = Resource<LeakedCredentialCheck>(TypeId);
+export const LeakedCredentialCheck = Resource<LeakedCredentialCheck>(TypeId, {
+  aliases: ["Cloudflare.LeakedCredentialCheck"],
+});
 
 /**
  * Returns true if the given value is a LeakedCredentialCheck resource.

package/src/Cloudflare/LoadBalancer/LoadBalancer.ts

@@ -239,7 +239,9 @@ export type LoadBalancer = Resource<
  *
  * @see https://developers.cloudflare.com/load-balancing/
  */
-export const LoadBalancer = Resource<LoadBalancer>(TypeId);
+export const LoadBalancer = Resource<LoadBalancer>(TypeId, {
+  aliases: ["Cloudflare.LoadBalancer"],
+});
 
 /**
  * Returns true if the given value is a LoadBalancer resource.

package/src/Cloudflare/LoadBalancer/Monitor.ts

@@ -286,9 +286,10 @@ export const MonitorProvider = () =>
         .pipe(
           Effect.retry({
             while: (e) => e._tag === "MonitorInUse",
-            schedule: Schedule.exponential("1 second").pipe(
-              Schedule.both(Schedule.recurs(6)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential("1 second"),
+              Schedule.recurs(6),
+            ]),
           }),
           Effect.catchTag("MonitorNotFound", () => Effect.void),
         );

package/src/Cloudflare/LoadBalancer/MonitorGroup.ts

@@ -220,9 +220,10 @@ export const MonitorGroupProvider = () =>
         .pipe(
           Effect.retry({
             while: (e) => e._tag === "MonitorGroupInUse",
-            schedule: Schedule.exponential("1 second").pipe(
-              Schedule.both(Schedule.recurs(6)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential("1 second"),
+              Schedule.recurs(6),
+            ]),
           }),
           Effect.catchTag("MonitorGroupNotFound", () => Effect.void),
         );

package/src/Cloudflare/LoadBalancer/Pool.ts

@@ -336,9 +336,10 @@ export const PoolProvider = () =>
         .pipe(
           Effect.retry({
             while: (e) => e._tag === "PoolInUse",
-            schedule: Schedule.exponential("1 second").pipe(
-              Schedule.both(Schedule.recurs(6)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential("1 second"),
+              Schedule.recurs(6),
+            ]),
           }),
           Effect.catchTag("PoolNotFound", () => Effect.void),
         );

package/src/Cloudflare/LocalRuntime.ts

@@ -32,6 +32,22 @@ export class LocalRuntimeState extends Context.Service<
       Consumer["Attributes"]["consumerId"],
       Consumer["Attributes"]
     >;
+    /**
+     * Restart hooks for locally running Workers, keyed by script name.
+     *
+     * A local workerd instance bakes its queue-consumer wiring in at start
+     * time (`runtime.start({ queueConsumers })`), but the `Consumer`
+     * resource that populates {@link queueConsumers} reconciles as a
+     * *sibling* of the Worker — the engine may start workerd before the
+     * consumer registers. Providers that mutate a worker's runtime wiring
+     * (e.g. `ConsumerProviderLocal`) invoke the script's hook after
+     * updating state so the running instance is reconfigured; the hook is
+     * a no-op until the worker has served at least once.
+     */
+    readonly workerRestarts: MutableHashMap.MutableHashMap<
+      string,
+      Effect.Effect<void>
+    >;
   }
 >()("alchemy/cloudflare/LocalRuntimeState") {}
 
@@ -40,6 +56,7 @@ const LocalRuntimeStateLive = Layer.succeed(
   LocalRuntimeState.of({
     queues: MutableHashMap.empty(),
     queueConsumers: MutableHashMap.empty(),
+    workerRestarts: MutableHashMap.empty(),
   }),
 );
 

package/src/Cloudflare/MagicNetworkMonitoring/Rule.ts

@@ -286,9 +286,10 @@ export const RuleProvider = () =>
             // config has propagated, so ride out that consistency window.
             Effect.retry({
               while: (e) => e._tag === "MnmConfigMissing",
-              schedule: Schedule.exponential("500 millis").pipe(
-                Schedule.both(Schedule.recurs(8)),
-              ),
+              schedule: Schedule.max([
+                Schedule.exponential("500 millis"),
+                Schedule.recurs(8),
+              ]),
             }),
             Effect.catchTag("DuplicateMnmRuleName", (error) =>
               findByName(accountId, name).pipe(

package/src/Cloudflare/ManagedTransforms/ManagedTransforms.ts

@@ -172,7 +172,9 @@ export type ManagedTransforms = Resource<
  *
  * @see https://developers.cloudflare.com/rules/transform/managed-transforms/
  */
-export const ManagedTransforms = Resource<ManagedTransforms>(TypeId);
+export const ManagedTransforms = Resource<ManagedTransforms>(TypeId, {
+  aliases: ["Cloudflare.ManagedTransforms"],
+});
 
 /**
  * Returns true if the given value is a ManagedTransforms resource.

package/src/Cloudflare/MtlsCertificate/MtlsCertificate.ts

@@ -167,7 +167,9 @@ export type MtlsCertificate = Resource<
  *
  * @see https://developers.cloudflare.com/ssl/client-certificates/
  */
-export const MtlsCertificate = Resource<MtlsCertificate>(TypeId);
+export const MtlsCertificate = Resource<MtlsCertificate>(TypeId, {
+  aliases: ["Cloudflare.MtlsCertificate"],
+});
 
 /**
  * Returns true if the given value is a MtlsCertificate resource.

package/src/Cloudflare/Organization/Organization.ts

@@ -183,7 +183,9 @@ export type Organization = Resource<
  *
  * @see https://developers.cloudflare.com/fundamentals/setup/manage-organizations/
  */
-export const Organization = Resource<Organization>(TypeId);
+export const Organization = Resource<Organization>(TypeId, {
+  aliases: ["Cloudflare.Organization"],
+});
 
 /**
  * Returns true if the given value is an Organization resource.

package/src/Cloudflare/OriginCaCertificate/OriginCaCertificate.ts

@@ -145,7 +145,9 @@ export type OriginCaCertificate = Resource<
  *
  * @see https://developers.cloudflare.com/ssl/origin-configuration/origin-ca/
  */
-export const OriginCaCertificate = Resource<OriginCaCertificate>(TypeId);
+export const OriginCaCertificate = Resource<OriginCaCertificate>(TypeId, {
+  aliases: ["Cloudflare.OriginCaCertificate"],
+});
 
 /**
  * Returns true if the given value is an OriginCaCertificate resource.
@@ -238,7 +240,10 @@ export const OriginCaCertificateProvider = () =>
       // adopt policy. Ambiguity (several live certs with the same
       // hostnames) means no identity at all — report missing and recreate
       // (certificates are free and revocation is harmless).
-      if (!olds?.hostnames?.length) return undefined;
+      // Output-valued hostname elements don't survive a `creating`-state
+      // round-trip (they deserialize as null/undefined) — without a concrete
+      // hostname there is no identity to search by.
+      if (typeof olds?.hostnames?.[0] !== "string") return undefined;
       const matches = yield* findByHostnames(olds.hostnames);
       if (matches.length !== 1) return undefined;
       const observed = yield* getCertificate(matches[0].id!);

package/src/Cloudflare/OriginPostQuantumEncryption/OriginPostQuantumEncryption.ts

@@ -113,7 +113,9 @@ export type OriginPostQuantumEncryption = Resource<
  * @see https://developers.cloudflare.com/ssl/origin-configuration/pqc-to-origin/
  */
 export const OriginPostQuantumEncryption =
-  Resource<OriginPostQuantumEncryption>(TypeId);
+  Resource<OriginPostQuantumEncryption>(TypeId, {
+    aliases: ["Cloudflare.OriginPostQuantumEncryption"],
+  });
 
 /**
  * Returns true if the given value is an OriginPostQuantumEncryption resource.

package/src/Cloudflare/OriginTlsClientAuth/HostnameCertificate.ts

@@ -175,8 +175,12 @@ export const HostnameCertificateProvider = () =>
       ) {
         return { action: "replace" } as const;
       }
+      // Compare the certificate only when the old value is known — an
+      // Output-valued `certificate` doesn't survive a `creating`-state
+      // round-trip (it deserializes as `undefined`).
       if (
-        normalizePem(olds.certificate) !== normalizePem(news.certificate) ||
+        (olds.certificate !== undefined &&
+          normalizePem(olds.certificate) !== normalizePem(news.certificate)) ||
         unwrap(olds.privateKey) !== unwrap(news.privateKey)
       ) {
         // There is no update API for hostname client certificates — every

package/src/Cloudflare/PageRule/PageRule.ts

@@ -170,7 +170,9 @@ export type PageRule = Resource<TypeId, Props, Attributes, never, Providers>;
  *
  * @see https://developers.cloudflare.com/rules/page-rules/
  */
-export const PageRule = Resource<PageRule>(TypeId);
+export const PageRule = Resource<PageRule>(TypeId, {
+  aliases: ["Cloudflare.PageRule"],
+});
 
 /**
  * Returns true if the given value is a PageRule resource.

package/src/Cloudflare/Pipelines/Pipeline.ts

@@ -175,9 +175,10 @@ export const PipelineProvider = () =>
         // race an `PipelineAlreadyExists` against the dying pipeline.
         yield* getPipeline(accountId, observed.id).pipe(
           Effect.repeat({
-            schedule: Schedule.exponential("250 millis").pipe(
-              Schedule.both(Schedule.recurs(8)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential("250 millis"),
+              Schedule.recurs(8),
+            ]),
             until: (p) => p === undefined,
           }),
         );
@@ -196,9 +197,10 @@ export const PipelineProvider = () =>
           .pipe(
             Effect.retry({
               while: (e) => e._tag === "TableNotFound",
-              schedule: Schedule.exponential("500 millis").pipe(
-                Schedule.both(Schedule.recurs(6)),
-              ),
+              schedule: Schedule.max([
+                Schedule.exponential("500 millis"),
+                Schedule.recurs(6),
+              ]),
             }),
             Effect.catchTag("PipelineAlreadyExists", (error) =>
               findPipelineByName(accountId, name).pipe(

package/src/Cloudflare/Pipelines/Sink.ts

@@ -348,9 +348,10 @@ export const SinkProvider = () =>
         // race a `SinkAlreadyExists` against the dying sink.
         yield* getSink(accountId, observed.id).pipe(
           Effect.repeat({
-            schedule: Schedule.exponential("250 millis").pipe(
-              Schedule.both(Schedule.recurs(8)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential("250 millis"),
+              Schedule.recurs(8),
+            ]),
             until: (s) => s === undefined,
           }),
         );
@@ -458,9 +459,10 @@ const deleteSink = (accountId: string, sinkId: string) =>
   pipelines.deleteSink({ accountId, sinkId }).pipe(
     Effect.retry({
       while: (e) => e._tag === "SinkInUse",
-      schedule: Schedule.exponential("500 millis").pipe(
-        Schedule.both(Schedule.recurs(8)),
-      ),
+      schedule: Schedule.max([
+        Schedule.exponential("500 millis"),
+        Schedule.recurs(8),
+      ]),
     }),
     Effect.catchTag("SinkNotFound", () => Effect.void),
     Effect.catchTag("InvalidSinkId", () => Effect.void),

package/src/Cloudflare/Pipelines/Stream.ts

@@ -367,9 +367,10 @@ export const StreamProvider = () =>
         .pipe(
           Effect.retry({
             while: (e) => e._tag === "StreamInUse",
-            schedule: Schedule.exponential("500 millis").pipe(
-              Schedule.both(Schedule.recurs(8)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential("500 millis"),
+              Schedule.recurs(8),
+            ]),
           }),
           Effect.catchTag("StreamNotFound", () => Effect.void),
           Effect.catchTag("InvalidStreamId", () => Effect.void),

package/src/Cloudflare/Providers.ts

@@ -476,7 +476,7 @@ export const providers = () =>
         Devices.DeviceSettingsProvider(),
 
         // Split into nested groups: a single flat mergeAll with ~200
-        // arguments exceeds tsgo's variadic inference ceiling and
+        // arguments exceeds tsc's variadic inference ceiling and
         // silently drops the tail layers from the inferred union.
         Layer.mergeAll(
           Diagnostics.EndpointHealthcheckProvider(),
@@ -684,31 +684,46 @@ export const providers = () =>
     ),
     Layer.provide(DockerLive),
     Layer.provideMerge(localRuntimeServices()),
-    Layer.provideMerge(Credentials.fromAuthProvider()),
+    Layer.provideMerge(CloudflareApiLive()),
+    Layer.orDie,
+  );
+
+/**
+ * The foundation every effect tree that talks to the Cloudflare API
+ * shares — credentials resolved through the Alchemy auth provider,
+ * account environment, Access, profile + credential store — plus a
+ * blanket retry policy applied to every Cloudflare API call.
+ *
+ * Used by {@link providers} and the Cloudflare state store
+ * ({@link ../Cloudflare/StateStore/State.ts state}) so that provider
+ * lifecycle operations and state-store init/bootstrap probes retry
+ * transient failures the same way; without it the state-store
+ * subdomain/script/secrets probes run on the SDK's shorter default
+ * policy and surface throttling ("Please wait and consider throttling
+ * your request speed") to users.
+ *
+ * The retry policy extends `Retry.makeDefault`'s transient detection
+ * (throttling / 5xx / network) with Cloudflare-specific
+ * misleadingly-tagged transient cases the SDK doesn't yet mark
+ * retryable — see `cloudflareRetryFactory` below. Deliberately
+ * narrow: we ONLY add cases where the message unambiguously indicates
+ * a transient infrastructure failure (not a real auth/permission
+ * failure). Auto-retrying ambiguous cases like `Unauthorized:
+ * Authentication error` would silently loop on genuinely invalid
+ * tokens.
+ *
+ * TODO(distilled): once
+ * https://github.com/alchemy-run/distilled/pull/233 lands, the retry
+ * wrapper can collapse back to `Retry.makeDefault`.
+ */
+export const CloudflareApiLive = () =>
+  Credentials.fromAuthProvider().pipe(
     Layer.provideMerge(CloudflareEnvironment.fromProfile()),
     Layer.provideMerge(CloudflareAuth),
     Layer.provideMerge(Access.AccessLive),
     Layer.provideMerge(ProfileLive),
     Layer.provideMerge(CredentialsStoreLive),
-    // Apply a blanket retry policy to every Cloudflare API call. Extends
-    // `Retry.makeDefault`'s transient detection (throttling / 5xx /
-    // network) with one Cloudflare-specific misleadingly-tagged
-    // transient case the SDK doesn't yet mark retryable — see
-    // `cloudflareRetryFactory` below. Without this, the matching brief
-    // CF infrastructure blips surface as test failures and resource
-    // leaks.
-    //
-    // Deliberately narrow: we ONLY add cases where the message
-    // unambiguously indicates a transient infrastructure failure (not
-    // a real auth/permission failure). Auto-retrying ambiguous cases
-    // like `Unauthorized: Authentication error` would silently loop on
-    // genuinely invalid tokens.
-    //
-    // TODO(distilled): once
-    // https://github.com/alchemy-run/distilled/pull/233 lands, this
-    // wrapper can collapse back to `Retry.makeDefault`.
     Layer.provideMerge(Layer.succeed(Retry.Retry, cloudflareRetryFactory)),
-    Layer.orDie,
   );
 
 const cloudflareRetryFactory: Retry.Factory = (lastError) => {
@@ -716,25 +731,27 @@ const cloudflareRetryFactory: Retry.Factory = (lastError) => {
   return {
     while: (error) =>
       defaults.while?.(error) === true || isMisleadinglyTaggedTransient(error),
-    schedule: pipe(
-      Schedule.exponential(Duration.millis(250), 2),
-      Schedule.modifyDelay(
-        Effect.fn(function* (duration) {
-          const error = yield* Ref.get(lastError);
-          // Throttling errors (429): honor a 500ms floor matching the
-          // distilled default.
-          const isThrottling =
-            (error as { _tag?: unknown })?._tag === "TooManyRequests";
-          if (isThrottling && Duration.toMillis(duration) < 500) {
-            return Duration.toMillis(Duration.millis(500));
-          }
-          return Duration.toMillis(duration);
-        }),
+    schedule: Schedule.max([
+      pipe(
+        Schedule.exponential(Duration.millis(250), 2),
+        Schedule.modifyDelay(
+          Effect.fn(function* ({ duration }) {
+            const error = yield* Ref.get(lastError);
+            // Throttling errors (429): honor a 500ms floor matching the
+            // distilled default.
+            const isThrottling =
+              (error as { _tag?: unknown })?._tag === "TooManyRequests";
+            if (isThrottling && Duration.toMillis(duration) < 500) {
+              return Duration.toMillis(Duration.millis(500));
+            }
+            return Duration.toMillis(duration);
+          }),
+        ),
+        Retry.capped(Duration.seconds(5)),
+        Retry.jittered,
       ),
-      Retry.capped(Duration.seconds(5)),
-      Retry.jittered,
-      Schedule.both(Schedule.recurs(8)),
-    ),
+      Schedule.recurs(8),
+    ]),
   };
 };
 

package/src/Cloudflare/Queues/Consumer.ts

@@ -115,7 +115,9 @@ export type Consumer = Resource<
  * });
  * ```
  */
-export const Consumer = Resource<Consumer>("Cloudflare.Queues.Consumer");
+export const Consumer = Resource<Consumer>("Cloudflare.Queues.Consumer", {
+  aliases: ["Cloudflare.QueueConsumer"],
+});
 
 // Cloudflare allows a single Worker consumer per queue, so the
 // first match in the paginated stream is the only one. Using
@@ -306,9 +308,10 @@ export const ConsumerProviderLive = () =>
             Effect.catchTag("ConsumerNotFound", () => Effect.void),
             Effect.retry({
               while: (e) => e === "still-attached",
-              schedule: Schedule.spaced("1 second").pipe(
-                Schedule.both(Schedule.recurs(30)),
-              ),
+              schedule: Schedule.max([
+                Schedule.spaced("1 second"),
+                Schedule.recurs(30),
+              ]),
             }),
             Effect.ignore,
           );
@@ -485,9 +488,10 @@ export const ConsumerProviderLive = () =>
           Effect.catchTag("ConsumerNotFound", () => Effect.void),
           Effect.retry({
             while: (e) => e === "still-attached",
-            schedule: Schedule.spaced("1 second").pipe(
-              Schedule.both(Schedule.recurs(30)),
-            ),
+            schedule: Schedule.max([
+              Schedule.spaced("1 second"),
+              Schedule.recurs(30),
+            ]),
           }),
           Effect.ignore,
         );
@@ -559,9 +563,10 @@ const toObserved = (c: {
 
 // ~60s budget — Worker reconcile uploads typically land in 2–10s,
 // but a fresh container/asset deploy can stretch that.
-const queueHandlerReadinessSchedule = Schedule.spaced("2 seconds").pipe(
-  Schedule.both(Schedule.recurs(30)),
-);
+const queueHandlerReadinessSchedule = Schedule.max([
+  Schedule.spaced("2 seconds"),
+  Schedule.recurs(30),
+]);
 
 export const ConsumerProviderLocal = () =>
   RpcProvider.effect(
@@ -569,6 +574,27 @@ export const ConsumerProviderLocal = () =>
     LOCAL_ENTRY_URL,
     Effect.gen(function* () {
       const localRuntimeState = yield* LocalRuntimeState;
+
+      // Restart the locally running workerd instances (if any) for the
+      // given scripts so start-time queue-consumer wiring is re-read from
+      // `localRuntimeState.queueConsumers`. See `workerRestarts` on
+      // {@link LocalRuntimeState}.
+      const restartScripts = (scriptNames: ReadonlyArray<string>) =>
+        Effect.forEach(
+          scriptNames,
+          (scriptName) =>
+            MutableHashMap.get(
+              localRuntimeState.workerRestarts,
+              scriptName,
+            ).pipe(
+              Option.match({
+                onNone: () => Effect.void,
+                onSome: (restart) => restart,
+              }),
+            ),
+          { discard: true },
+        );
+
       return {
         list: () =>
           Effect.sync(() =>
@@ -623,6 +649,17 @@ export const ConsumerProviderLocal = () =>
             consumer.consumerId,
             consumer,
           );
+          // A local workerd instance only reads its queue-consumer wiring
+          // at start time, and this reconcile races the sibling Worker's
+          // start (the Worker's `precreate` resolves `scriptName` before
+          // workerd is up). Restart any already-running instance so it
+          // picks up the new wiring; if the worker hasn't served yet this
+          // is a no-op and its first serve observes the map we just set.
+          yield* restartScripts(
+            output && output.scriptName !== consumer.scriptName
+              ? [output.scriptName, consumer.scriptName]
+              : [consumer.scriptName],
+          );
           return consumer;
         }),
         delete: Effect.fn(function* ({ output }) {
@@ -630,6 +667,7 @@ export const ConsumerProviderLocal = () =>
             localRuntimeState.queueConsumers,
             output.consumerId,
           );
+          yield* restartScripts([output.scriptName]);
         }),
       };
     }),