Summary

Effect.fn(name)(body) crashes at runtime with RuntimeException: Not a valid effect: {} when body is a generator function that has been lowered by a bundler/transpiler into a non-generator function returning an iterator. For example, babel-preset-expo on React Native / Hermes rewrites destructured-param generators like this:

// Source:
function*({ a }) { return a }

// babel-preset-expo output (approx):
function destr(_ref) {
  var a = _ref.a;
  return (function*() { return a })();
}

The lowered wrapper is no longer a GeneratorFunction, so isGeneratorFunction(body) in fnApply returns false. The else branch then takes body.apply(...)'s return value — an Iterator, not an Effect — and passes it to withSpan, which hands it to the fiber runLoop. The loop dies at the first instruction because the value has no _op.

Repro

import { Effect } from "effect"

// Simulates a transpiler lowering `function*({a}) { return a }`
const body = function (arg: { a: number }) {
  const a = arg.a
  return (function* () { return a })()
}

const fn = Effect.fn("repro")(body as any)
await Effect.runPromise(fn({ a: 42 }))
// 💥 RuntimeException: Not a valid effect: {}

Root cause

isGeneratorFunction in Utils.ts checks u.constructor === function*(){}.constructor. That works for native generators and for transpilers that preserve function* syntax in their output, but fails for any transformer that lowers function* into a plain function — including Babel's @babel/plugin-transform-parameters, which babel-preset-expo ships unconditionally on Hermes-native.

Effect.fn has had this hazard since it was introduced in 3.11.0. It is not a regression — it has always crashed under transformers that erase function* syntax.

Fix

In fnApply's else branch, after calling body.apply(...), duck-type the result. If it looks like an iterator (has .next and Symbol.iterator) and isn't already an Effect, re-wrap it with core.fromIterator. The first iterator is consumed immediately; subsequent invocations re-apply body to produce fresh iterators (preserving Effect.fn's reusable-wrapper contract).

fnUntraced does not need this change: it unconditionally wraps with fromIterator, so a transpiler-lowered body's returned iterator flows through correctly already.

Test

Added a regression test in packages/effect/test/Effect/fn.test.ts constructing the exact shape the transpiler produces — a plain function returning a generator IIFE. Verified red → green against main.

Related

• Add missing exhaustiveness guards in Layer.buildWithScope and FiberRuntime.evaluateEffect #6158 — missing absurd-guard hardening in Effect.fn (this PR resolves one observable manifestation; the broader hardening is still useful).
• TypeError: Cannot use 'in' operator to search for '_op' in undefined #2708 — same family of "iterator vs Effect" runtime crash from a different source.