alchemy 2.0.0-beta.50 → 2.0.0-beta.52

package/src/Local/RpcSerialization.ts

@@ -89,7 +89,7 @@ export const unwrapRpcHandlers = <T extends Record<string, any>>(
   ) as RpcUnwrapped<T>;
 };
 
-const serializeError = Schema.encodeSync(Schema.Defect);
+const serializeError = Schema.encodeSync(Schema.Defect());
 
 const wrapRpcEffectHandler = <Args extends Array<any>, Success, Error>(
   handler: RpcEffectHandler<Args, Success, Error>,
@@ -107,7 +107,10 @@ const wrapRpcEffectHandler = <Args extends Array<any>, Success, Error>(
         cause: exit.cause.reasons.map((reason): RpcSerializedCause<Error> => {
           switch (reason._tag) {
             case "Fail":
-              return { _tag: "Fail", error: serializeError(reason.error) };
+              return {
+                _tag: "Fail",
+                error: serializeError(reason.error) as Error,
+              };
             case "Die":
               return { _tag: "Die", defect: serializeError(reason.defect) };
             case "Interrupt":

package/src/Output.ts

@@ -72,6 +72,8 @@ export type ToOutput<A, Req = never> = [Extract<A, object>] extends [never]
 
 export const ExprSymbol = Symbol.for("alchemy/Expr");
 
+const exprKind = (node: any): unknown => node?.[ExprSymbol]?.kind ?? node?.kind;
+
 export const isExpr = (value: any): value is Expr<any> =>
   value &&
   (typeof value === "object" || typeof value === "function") &&
@@ -145,7 +147,7 @@ export type ArrayExpr<A extends any[], Req = any> = Output<A, Req> & {
 
 export const isResourceExpr = <Value = any, Req = any>(
   node: Expr<Value, Req> | any,
-): node is ResourceExpr<Value, Req> => node?.kind === "ResourceExpr";
+): node is ResourceExpr<Value, Req> => exprKind(node) === "ResourceExpr";
 
 export class ResourceExpr<Value, Req = never> extends BaseExpr<Value, Req> {
   readonly kind = "ResourceExpr";
@@ -163,7 +165,7 @@ export class ResourceExpr<Value, Req = never> extends BaseExpr<Value, Req> {
 
 export const isPropExpr = <A = any, Prop extends keyof A = keyof A, Req = any>(
   node: any,
-): node is PropExpr<A, Prop, Req> => node?.kind === "PropExpr";
+): node is PropExpr<A, Prop, Req> => exprKind(node) === "PropExpr";
 
 export class PropExpr<
   A = any,
@@ -186,7 +188,7 @@ export class PropExpr<
 export const literal = <A>(value: A) => new LiteralExpr(value);
 
 export const isLiteralExpr = <A = any>(node: any): node is LiteralExpr<A> =>
-  node?.kind === "LiteralExpr";
+  exprKind(node) === "LiteralExpr";
 
 export class LiteralExpr<A> extends BaseExpr<A, never> {
   readonly kind = "LiteralExpr";
@@ -217,7 +219,7 @@ export const map: {
 //Output.ApplyExpr<any, any, ResourceLike, any>
 export const isApplyExpr = <In = any, Out = any, Req = any>(
   node: Output<Out, Req>,
-): node is ApplyExpr<In, Out, Req> => node?.kind === "ApplyExpr";
+): node is ApplyExpr<In, Out, Req> => exprKind(node) === "ApplyExpr";
 
 export class ApplyExpr<A, B, Req = never> extends BaseExpr<B, Req> {
   readonly kind = "ApplyExpr";
@@ -259,7 +261,7 @@ export const flatMap: {
 
 export const isFlatMapExpr = <In = any, Out = any, Req = any, Req2 = any>(
   node: any,
-): node is FlatMapExpr<In, Out, Req, Req2> => node?.kind === "FlatMapExpr";
+): node is FlatMapExpr<In, Out, Req, Req2> => exprKind(node) === "FlatMapExpr";
 
 export class FlatMapExpr<A, B, Req = never, Req2 = never> extends BaseExpr<
   B,
@@ -280,7 +282,7 @@ export class FlatMapExpr<A, B, Req = never, Req2 = never> extends BaseExpr<
 
 export const isEffectExpr = <In = any, Out = any, Req = any, Req2 = any>(
   node: any,
-): node is EffectExpr<In, Out, Req, Req2> => node?.kind === "EffectExpr";
+): node is EffectExpr<In, Out, Req, Req2> => exprKind(node) === "EffectExpr";
 
 export class EffectExpr<A, B, Req = never, Req2 = never> extends BaseExpr<
   B,
@@ -301,7 +303,7 @@ export class EffectExpr<A, B, Req = never, Req2 = never> extends BaseExpr<
 
 export const isNamedExpr = <A = any, Req = any>(
   node: any,
-): node is NamedExpr<A, Req> => node?.kind === "NamedExpr";
+): node is NamedExpr<A, Req> => exprKind(node) === "NamedExpr";
 
 /**
  * Wraps another `Expr` and overrides its `toString()` / inspect output.
@@ -352,7 +354,7 @@ type Tuple<
 
 export const isAllExpr = <Outs extends Expr[] = Expr[]>(
   node: any,
-): node is AllExpr<Outs> => node?.kind === "AllExpr";
+): node is AllExpr<Outs> => exprKind(node) === "AllExpr";
 
 export class AllExpr<Outs extends Expr[]> extends BaseExpr<Outs> {
   readonly kind = "AllExpr";
@@ -366,7 +368,7 @@ export class AllExpr<Outs extends Expr[]> extends BaseExpr<Outs> {
 }
 
 export const isRefExpr = <A = any>(node: any): node is RefExpr<A> =>
-  node?.kind === "RefExpr";
+  exprKind(node) === "RefExpr";
 
 export class RefExpr<A> extends BaseExpr<A, never> {
   readonly kind = "RefExpr";
@@ -384,7 +386,7 @@ export class RefExpr<A> extends BaseExpr<A, never> {
 }
 
 export const isStackRefExpr = <A = any>(node: any): node is StackRefExpr<A> =>
-  node?.kind === "StackRefExpr";
+  exprKind(node) === "StackRefExpr";
 
 /**
  * A reference to the persisted output of a Stack at `(stack, stage)`.

package/src/Plan.ts

@@ -714,7 +714,10 @@ export const make = <A>(
                 .pipe(providePlanScope(fqn, adoptInstanceId));
               if (readResult !== undefined) {
                 const isUnowned = Unowned.is(readResult);
-                if (isUnowned && !(yield* shouldAdopt)) {
+                // A resource-scoped `adopt(...)` (captured on the resource at
+                // registration) overrides the stack/CLI default.
+                const adoptThis = resource.Adopt ?? (yield* shouldAdopt);
+                if (isUnowned && !adoptThis) {
                   return yield* new OwnedBySomeoneElse({
                     message:
                       `Cannot adopt resource '${fqn}' (${resource.Type}): ` +
@@ -1229,6 +1232,7 @@ export const make = <A>(
                     Binding: undefined!,
                     Provider: Provider(resourceType),
                     RemovalPolicy: oldState.removalPolicy,
+                    Adopt: undefined,
                     RuntimeContext: undefined!,
                     Providers: undefined,
                   } as ResourceLike,

package/src/Planetscale/MySQL/MySQLDatabase.ts

@@ -66,9 +66,6 @@ export interface MySQLDatabaseProps extends BaseDatabaseProps {
  * Output attributes of a deployed MySQL PlanetScale database.
  */
 export interface MySQLDatabaseAttributes extends BaseDatabaseAttributes {
-  /** Engine kind discriminator. */
-  kind: "mysql";
-
   /**
    * Whether to copy migration data to new branches and in deploy requests.
    */
@@ -177,7 +174,7 @@ export const MySQLDatabaseProvider = () =>
       const createBr = yield* ops.createBranch;
 
       return {
-        stables: ["id", "organization", "kind", "region"],
+        stables: ["id", "organization", "region"],
 
         diff: Effect.fn(function* ({ news, olds, output }) {
           if (!isResolved(news)) return undefined;
@@ -249,7 +246,6 @@ export const MySQLDatabaseProvider = () =>
                   output?.migrationsTable ?? olds?.migrationsTable,
                 migrationsHashes: output?.migrationsHashes ?? {},
                 importHashes: output?.importHashes ?? {},
-                kind: "mysql" as const,
                 clusterSize: output?.clusterSize ?? "",
                 requireApprovalForDeploy:
                   data.require_approval_for_deploy ?? false,
@@ -415,7 +411,6 @@ export const MySQLDatabaseProvider = () =>
             updatedAt: updated.updated_at,
             htmlUrl: updated.html_url,
             region: { slug: updated.region.slug },
-            kind: "mysql" as const,
             clusterSize,
             migrationsDir: news.migrationsDir,
             migrationsTable: news.migrationsDir ? migrationsTable : undefined,

package/src/Planetscale/Postgres/PostgresDatabase.ts

@@ -53,8 +53,6 @@ export interface PostgresDatabaseProps extends BaseDatabaseProps {
  * Output attributes of a deployed PostgreSQL PlanetScale database.
  */
 export interface PostgresDatabaseAttributes extends BaseDatabaseAttributes {
-  /** Engine kind discriminator. */
-  kind: "postgresql";
   /** PostgreSQL CPU architecture. */
   arch: "x86" | "arm";
 }
@@ -125,7 +123,7 @@ export const PostgresDatabaseProvider = () =>
       const createBr = yield* ops.createBranch;
 
       return {
-        stables: ["id", "organization", "kind", "region"],
+        stables: ["id", "organization", "region"],
 
         diff: Effect.fn(function* ({ news, olds, output }) {
           if (!isResolved(news)) return undefined;
@@ -222,7 +220,6 @@ export const PostgresDatabaseProvider = () =>
             migrationsTable: output?.migrationsTable ?? olds?.migrationsTable,
             migrationsHashes: output?.migrationsHashes ?? {},
             importHashes: output?.importHashes ?? {},
-            kind: "postgresql" as const,
             clusterSize,
             arch,
             requireApprovalForDeploy: data.require_approval_for_deploy ?? false,
@@ -378,7 +375,6 @@ export const PostgresDatabaseProvider = () =>
             updatedAt: updated.updated_at,
             htmlUrl: updated.html_url,
             region: { slug: updated.region.slug },
-            kind: "postgresql" as const,
             clusterSize: clusterSize,
             migrationsDir: news.migrationsDir,
             migrationsTable: news.migrationsDir ? migrationsTable : undefined,

package/src/Platform.ts

@@ -2,13 +2,12 @@ import * as ConfigError from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
+import * as Effectable from "effect/Effectable";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import type { Scope } from "effect/Scope";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
-import { SingleShotGen } from "effect/Utils";
 import type { PolicyLike } from "./Binding.ts";
 import type { Dependencies } from "./Dependencies.ts";
 import type { ExecutionContext } from "./ExecutionContext.ts";
@@ -76,7 +75,11 @@ export interface Platform<
       id: string,
       props:
         | InputProps<Resource["Props"]>
-        | Effect.Effect<InputProps<Resource["Props"]>, never, PropsReq>,
+        | Effect.Effect<
+            InputProps<Resource["Props"]>,
+            ConfigError.ConfigError,
+            PropsReq
+          >,
     ): Effect.Effect<
       Resource & Rpc<Self> & Dependencies<Deps>,
       never,
@@ -103,7 +106,7 @@ export interface Platform<
       id: string,
       props:
         | InputProps<Resource["Props"]>
-        | Effect.Effect<Resource["Props"], never, PropsReq>,
+        | Effect.Effect<Resource["Props"], ConfigError.ConfigError, PropsReq>,
       impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
     ): Effect.Effect<
       Resource & Rpc<Self>,
@@ -118,7 +121,11 @@ export interface Platform<
       id: string,
       props:
         | InputProps<Resource["Props"]>
-        | Effect.Effect<InputProps<Resource["Props"]>, never, PropsReq>,
+        | Effect.Effect<
+            InputProps<Resource["Props"]>,
+            ConfigError.ConfigError,
+            PropsReq
+          >,
     ): Effect.Effect<
       Resource & Rpc<Self>,
       never,
@@ -134,7 +141,7 @@ export interface Platform<
       >;
       new (_: never): MakeShape<Shape, BaseShape>;
     } & (<InitReq extends Services | PlatformServices | Resource = never>(
-        impl: Effect.Effect<Shape, never, InitReq>,
+        impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
       ) => Effect.Effect<
         Resource & Rpc<Self>,
         never,
@@ -217,7 +224,7 @@ export const Platform = <
         constructor(id, props, impl, true);
     } else if (!impl) {
       const cls = makeClass(id, props);
-      const asEffect = () =>
+      const evaluate = () =>
         (!isTag
           ? // this is a non-tagged resource yielded without providing an implementation
             // e.g.
@@ -264,7 +271,7 @@ export const Platform = <
         );
       return Object.assign(
         function (impl: Impl) {
-          return cls.asEffect().pipe(Effect.provide(cls.make(impl)));
+          return cls.Self.pipe(Effect.provide(cls.make(impl)));
         },
         // we splice in the Effect so this can be yielded to indicate a non-Effect native instance
         // e.g. here, we yield it - in this case we don't want to provide an implementation
@@ -272,42 +279,29 @@ export const Platform = <
         //  main: "./src/worker.ts"
         // });
         cls,
-        {
-          asEffect,
-          // @ts-expect-error
-          pipe: (...args: any[]) => asEffect().pipe(...args),
-          [Symbol.iterator]: () => new SingleShotGen(asEffect()),
-        },
+        // Spread the Effect prototype LAST so it overrides the evaluate copied
+        // from `cls`: yielding this no-impl form bridges to the (possibly
+        // non-Effect-native) resource rather than resolving the Self tag.
+        Effectable.Prototype({
+          label: `${type}<${id}>`,
+          evaluate,
+        }),
       );
     } else {
       // impl was provided inline, this is a non-tagged eager instance
       // e.g.
       // export default Cloudflare.Worker("id", { main: "./src/worker.ts" }, Effect.gen(function* () { .. })
       const cls = makeClass(id, props);
-      return cls.asEffect().pipe(Effect.provide(cls.make(impl)), effectClass);
+      return cls.Self.pipe(Effect.provide(cls.make(impl)), effectClass);
     }
   };
 
   const makeClass = (id: string, props: Props) => {
-    return class Platform {
+    class Platform {
       static readonly Self = Self(`${type}<${id}>`);
       static readonly Platform = Context.Service<Platform, Platform>(
         `Platform<${type}<${id}>>`,
       );
-      static [Symbol.iterator](): Iterator<
-        Effect.Effect<void, never, Self>,
-        Resource,
-        void
-      > {
-        return new SingleShotGen(this.asEffect()) as any;
-      }
-      static asEffect() {
-        return this.Self;
-      }
-      static pipe(...args: any[]) {
-        // @ts-expect-error
-        return pipe(this, ...args);
-      }
       static of = (shape: any) => shape;
       static make = (impl: Impl) => {
         // build the Layer once for the root Self
@@ -452,13 +446,31 @@ export const Platform = <
           SelfLayer,
         );
       };
-    };
+    }
+    // Make the platform class itself a real Effect: `yield* MyWorker` resolves
+    // the Self tag. Replaces the hand-rolled asEffect/pipe/[Symbol.iterator].
+    return Object.assign(
+      Platform,
+      Effectable.Prototype({
+        label: `${type}<${id}>`,
+        evaluate: () => Platform.Self,
+      }),
+    );
   };
 
-  const instance = Object.assign(constructor, resource, {
-    Platform: Platform,
-    asEffect: () => resource.Self,
-    ...methods,
-  }) as any;
+  const instance = Object.assign(
+    constructor,
+    resource,
+    // Spread the Effect prototype LAST so it overrides any evaluate inherited
+    // from `resource`; `yield* Cloudflare.Worker` resolves the resource Self.
+    Effectable.Prototype({
+      label: `${type}`,
+      evaluate: () => resource.Self,
+    }),
+    {
+      Platform: Platform,
+      ...methods,
+    },
+  ) as any;
   return instance;
 };

package/src/Resource.ts

@@ -1,7 +1,8 @@
 import * as Effect from "effect/Effect";
+import * as Effectable from "effect/Effectable";
 import * as Option from "effect/Option";
-import { pipeArguments, type Pipeable } from "effect/Pipeable";
-import { SingleShotGen } from "effect/Utils";
+import type { Pipeable } from "effect/Pipeable";
+import { AdoptPolicy } from "./AdoptPolicy.ts";
 import { toFqn } from "./FQN.ts";
 import type { Input, InputProps } from "./Input.ts";
 import { CurrentNamespace, type NamespaceNode } from "./Namespace.ts";
@@ -106,6 +107,12 @@ export interface ResourceLike<
    * Removal Policy of the Resource.
    */
   RemovalPolicy: RemovalPolicy["Service"];
+  /**
+   * Per-resource adoption policy captured from the ambient {@link AdoptPolicy}
+   * at registration time (e.g. via `.pipe(adopt(true))`). `undefined` means no
+   * resource-scoped override — the planner falls back to the stack/CLI default.
+   */
+  Adopt: boolean | undefined;
   /** @internal phantom */
   Attributes: Attributes;
   /** @internal phantom */
@@ -246,6 +253,9 @@ export function Resource<R extends ResourceLike>(
         RemovalPolicy: yield* Effect.serviceOption(RemovalPolicy).pipe(
           Effect.map(Option.getOrElse(() => defaultRemovalPolicy)),
         ),
+        Adopt: yield* Effect.serviceOption(AdoptPolicy).pipe(
+          Effect.map(Option.getOrUndefined),
+        ),
         bind,
         toString(this: typeof target) {
           return `Resource<${this.Type}>(${this.LogicalId})`;
@@ -277,17 +287,6 @@ export function Resource<R extends ResourceLike>(
   const ProviderTag = Provider(type);
 
   const Service = {
-    [Symbol.iterator]() {
-      return new SingleShotGen(this.asEffect());
-    },
-    pipe() {
-      return pipeArguments(this, arguments);
-    },
-    asEffect() {
-      return Effect.succeed((id: string, props: R["Props"]) =>
-        constructor(id, props),
-      );
-    },
     /**
      * Build a typed reference to a deployed instance of this resource
      * — in the current stack/stage by default, or in another via
@@ -313,6 +312,16 @@ export function Resource<R extends ResourceLike>(
         ? Object.assign(ResourceClass, args[0])
         : constructor(...(args as [string, R["Props"]])),
     Service,
+    // Make the constructor itself a real Effect: `yield* MyResource` resolves
+    // to the constructor function (same as the old `asEffect()`), and
+    // `Effect.isEffect(MyResource)` is now true so `Effect.all`/`forEach` work.
+    Effectable.Prototype({
+      label: `Resource<${type}>`,
+      evaluate: () =>
+        Effect.succeed((id: string, props: R["Props"]) =>
+          constructor(id, props),
+        ),
+    }),
   ) as any;
 
   return ResourceClass;

package/src/Runtime.ts

@@ -7,6 +7,7 @@
  */
 
 import * as Layer from "effect/Layer";
+import { asEffect } from "./Util/types.ts";
 
 /**
  * Resolve the user's default-export entrypoint into a `Layer` for the
@@ -14,7 +15,7 @@ import * as Layer from "effect/Layer";
  *
  * `entrypoint` may be any of:
  *   - a `Layer` factory (`{ build: (...) => ... }`) — used as-is
- *   - an effect-class with `asEffect()` (Alchemy `Platform`/`Worker` shape)
+ *   - an Alchemy `Platform`/`Worker` construct (now a real `Effect`)
  *   - a plain `Effect`
  *
  * Centralized so the inline ternary doesn't have to be re-emitted into
@@ -29,10 +30,5 @@ export const makeEntrypointLayer = (
   if (typeof entrypoint?.build === "function") {
     return entrypoint;
   }
-  return Layer.effect(
-    tag,
-    typeof entrypoint?.asEffect === "function"
-      ? entrypoint.asEffect()
-      : entrypoint,
-  );
+  return Layer.effect(tag, asEffect(entrypoint));
 };

package/src/Stack.ts

@@ -1,3 +1,4 @@
+import type { ConfigError } from "effect/Config";
 import { ConfigProvider } from "effect/ConfigProvider";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
@@ -77,16 +78,16 @@ export const Stack: Context.ServiceClass<
     },
     effect: Effect.Effect<
       NoInfer<A extends object ? InputProps<A> : Input<A>>,
-      never,
+      ConfigError,
       Req
     >,
-  ): Effect.Effect<CompiledStack<A>>;
+  ): Effect.Effect<CompiledStack<A>, ConfigError>;
   <Self>(): {
     <A, Req>(
       stackName: string,
       options: StackProps<NoInfer<Req>>,
-      eff: Effect.Effect<A, never, Req>,
-    ): Effect.Effect<Self> & {
+      eff: Effect.Effect<A, ConfigError, Req>,
+    ): Effect.Effect<Self, ConfigError> & {
       new (_: never): A extends object ? A : {};
       stage: {
         [stage: string]: Effect.Effect<Self>;
@@ -99,8 +100,8 @@ export const Stack: Context.ServiceClass<
       new (_: never): Output.ToOutput<Shape>;
       make: <A, Req>(
         options: StackProps<NoInfer<Req>>,
-        effect: Effect.Effect<A, never, Req>,
-      ) => Effect.Effect<CompiledStack<A>>;
+        effect: Effect.Effect<A, ConfigError, Req>,
+      ) => Effect.Effect<CompiledStack<A>, ConfigError>;
       stage: {
         [stage: string]: Effect.Effect<Self>;
       };
@@ -109,15 +110,15 @@ export const Stack: Context.ServiceClass<
   <A, Req>(
     stackName: string,
     options: StackProps<NoInfer<Req>>,
-    eff: Effect.Effect<A, never, Req | StackServices>,
-  ): Effect.Effect<CompiledStack<A>>;
+    eff: Effect.Effect<A, ConfigError, Req | StackServices>,
+  ): Effect.Effect<CompiledStack<A>, ConfigError>;
 } = Object.assign(
   taggedFunction(
     Context.Service<Stack, Omit<StackSpec, "output">>()("Stack"),
     <A, Req>(
       stackName?: string,
       options?: StackProps<NoInfer<Req>>,
-      eff?: Effect.Effect<A, never, Req>,
+      eff?: Effect.Effect<A, ConfigError, Req>,
     ) => {
       if (!stackName) {
         return (stackName: string) =>
@@ -131,7 +132,7 @@ export const Stack: Context.ServiceClass<
               providers: options?.providers,
               make: <Req = never>(
                 options: StackProps<NoInfer<Req>>,
-                eff: Effect.Effect<A, never, Req>,
+                eff: Effect.Effect<A, ConfigError, Req>,
               ) => Stack(stackName, options, eff),
             },
           );

package/src/Util/effect.ts

@@ -1,7 +1,6 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import { pipeArguments } from "effect/Pipeable";
-import { SingleShotGen } from "effect/Utils";
+import * as Effectable from "effect/Effectable";
 
 export type EffectClass<Shape, A, Err = never, Req = never> = Effect.Effect<
   A,
@@ -22,18 +21,15 @@ export const effectClass: {
   impl === undefined
     ? (innerImpl: any) => effectClass(innerImpl)
     : (Object.assign(
-        class {
-          static asEffect() {
-            return impl;
-          }
-          static [Symbol.iterator]() {
-            return new SingleShotGen(this.asEffect());
-          }
-          static pipe(...fns: any) {
-            return pipeArguments(this, fns);
-          }
-        },
-        impl,
+        class {},
+        // Spreading the Effect prototype onto the class (static side) makes the
+        // class itself a real Effect — `Effect.isEffect(X)` is true, so
+        // `Effect.all([X])` / `Effect.forEach` work — and subclasses
+        // (`class Y extends effectClass(impl)`) inherit the protocol statically.
+        Effectable.Prototype({
+          label: "alchemy/EffectClass",
+          evaluate: () => impl,
+        }),
       ) as unknown as EffectClass<any, any, any, any>)) as any;
 
 export const taggedFunction = <
@@ -43,10 +39,10 @@ export const taggedFunction = <
   tag: Tag,
   fn: Fn,
 ): Tag & Fn => {
+  // The Proxy below forwards every Effect-protocol key to `tag` (already an
+  // Effect), so `asEffect`/`[Symbol.iterator]`/`pipe` need no explicit
+  // override — only `toString` diverges.
   const overrides = {
-    asEffect: () => tag,
-    [Symbol.iterator]: () => tag[Symbol.iterator](),
-    pipe: (...fns: any[]) => pipeArguments(tag, fns as any),
     toString: () => `${tag.toString()}.${fn.name}`,
   };
 

package/src/Util/poll.ts

@@ -27,7 +27,6 @@ export const poll = Effect.fn("poll")(
     effect: Effect.Effect<A, E, R>;
     predicate: (value: A) => boolean;
     schedule?: Schedule.Schedule<unknown, unknown, never>;
-    times?: number;
   }) =>
     input.effect.pipe(
       Effect.filterOrFail(
@@ -40,8 +39,9 @@ export const poll = Effect.fn("poll")(
       ),
       Effect.retry({
         while: isPredicateFailed,
-        schedule: input.schedule ?? Schedule.spaced("3 seconds"),
-        times: input.times ?? 50,
+        schedule:
+          input.schedule ??
+          Schedule.both(Schedule.spaced("5 seconds"), Schedule.recurs(50)),
       }),
     ),
 );