[effect-bot]

Native proof of concept: Rolldown removes Effect service methods that nothing in the bundle reads. It's behind experimental.effectServiceShaking and off by default. The base is Rolldown v1.2.16 (de6facf), so the diff shows only this work.

Closes EFF-3380

Feasibility

It works for closed Effect applications under four approved assumptions (below). Two kinds of program were checked:

• The generator/constructor base case. All six pruning gates remove their unread methods on the real effect 4.1.2 package, and their output still runs.
• A generated client. The generated OpenAI client from @effect/ai-openai 4.1.2 is used through its service, calling one method against a mock HTTP client. The bundle goes from 2,068,645 B to 532,916 B (−74.2%), with identical runtime results:
  • the other 378 methods, httpClient and the schemas only they use are removed;
  • retrieveModel and RetrieveModel200 stay;
  • there's no global bailout.

A third program shows where the pass doesn't apply:

• A Distilled client. @distilled.cloud/stripe 1.0.0-rc.18 calls one of its 589 operations against a mock HTTP client.
  • The bundles are byte-identical at 439,842 B off and on, with identical runtime results.
  • Distilled exposes each operation as a separate /*@__PURE__*/ module-level export, not as a method of one service object, so Rolldown's ordinary tree shaking already keeps CreateCustomer and removes the other 588.
  • The pass correctly turns itself off under A2, because Distilled core compiles operation specs with Function(...) and loads modules through getBuiltinModule("node:module").createRequire(...).
  • No compiler change is warranted, and nothing requires widening A1–A4.

Programs the pass can't model keep every method, or turn the pass off with a warning at the site.

What it does

A link-stage pass (crates/rolldown/src/stages/link_stage/effect_service_shaking.rs) runs after cross-module optimization. It works on the module ASTs with oxc's scoping and Rolldown's canonical symbols.

1. Keys. Module-level const K = Context.Service("literal"), or class K extends Context.Service<..>()("literal") {}.
   • A class body may only declare static members with constant names that don't redeclare the inherited Context.Service protocol (of, key, use, pipe, toString, ~… ids, and so on).
   • The body may not use this or super.
2. Consumers. const s = yield* K, const { a } = yield* K and (yield* K).a inside Effect.gen / Effect.fn, read with static member names.
3. Providers. Layer.succeed(K, {...}) and Layer.effect(K, e), where e is built from Effect.gen, Effect.sync, Effect.succeed and Effect.acquireRelease, and returns K.of({...}) or {...}.
   • Generated-client shape, outside the trusted packages only. Layer.effect(K, make(args)) with a module-level Effect.fn/fnUntraced constructor of the same module is followed through return and return yield*, into a module-level function in any module that returns only object literals.
   • Those literals count as provider objects only when every reference to the constructor and the builder is a call the pass followed. Constructor pipeables must be Effect.updateService, provideService, withSpan or annotateLogs.
   • A named callback, constructor or builder function expression whose own name is referenced isn't followed.
   • A Layer returned from a module-level function is followed through each call, and layer.pipe(Layer.provide(a), ...) like the plain call.
4. Demand is a least fixpoint. Reads inside a removed method don't count; code that runs during construction always does. A property that may read this keeps every property only if it's kept itself.
5. Edits. Unread provider properties and dead constructor-local const functions are deleted. Rolldown's shaker then drops helpers only they used, and construction-time code keeps running in order.
   • A property that reads a binding is removed only when the read can't throw.
   • So imports, and bindings read inside their own declaration, parameter list, catch pattern, switch case or loop-head right-hand side, are kept.
6. Lookups. A keyed lookup other than yield* (Context.get, Effect.updateService, provideService, ...) by a declared key keeps that key's methods.

The pass turns itself off for the whole build, with an EFFECT_SERVICE_SHAKING warning per site, in these cases:

• entry exports;
• external imports other than Node builtins;
• code loaders the compiler can name: eval, Function, require, dynamic import(), a .constructor read by a constant name, vm/module/inspector/repl bindings, and Reflect.get/getOwnPropertyDescriptor with a constant loader key;
• host values used other than through constant members, calls or typeof;
• keyed lookups by an untracked key or with spread arguments, and the string-keyed Context APIs;
• Context.Service used other than to declare a key;
• writes to builtin prototypes.

ROLLDOWN_EFFECT_SERVICE_SHAKING_REPORT=1 prints the bailouts, the demand per key and the removed items. docs/in-depth/effect-service-shaking.md has the full rules.

Approved assumptions and limitations

Tim approved these for the POC. A program that breaks one can be miscompiled instead of keeping its methods.

• A1. User code doesn't reflect on, serialise or mutate Effect runtime objects, and doesn't modify builtin prototypes.
• A2. The app is closed: the entry exports only primitive constants, externals are Node builtins, and code loaders the compiler can name turn the pass off. Not checked: a loader reached through a member name built at run time, such as (() => 0)[["con", "structor"].join("")].
• A3. Effect reads user service values only by key. Constructor/builder following and Layer factories are therefore never applied inside Effect's own modules.
• A4. There is one bundled copy of effect.

Other limitations:

• Unsupported shapes keep every method: combinator consumers (Key.use, Effect.map(Key, ...)), providers built by spreading a parameter (NodeFileSystem), constructors with other pipeables, and named callbacks whose name is referenced. Library builds with entry exports aren't optimized.
• Conservative fallbacks:
  • any member named getOwnPropertyDescriptor, and aliasing or destructuring process/globalThis, turn the pass off;
  • class keys that override the protocol turn it off.
• The keyed-lookup list is pinned to effect 4.1.2's public API.

Results at 8434b35b

The test binary was compiled separately (effect-verify profile), and every bundling and runtime command ran under timeout 10.

• cargo test -- effect_service: 69 of 69 pass in 3.5 s.
  • 17 stub fixtures, 44 real-Effect fixtures and 8 bailout-site tests.
  • Every miscompile found in adversarial review has a regression: TDZ cases (forward, switch, import cycle, own initializer, parameters, loop heads, catch patterns), loader and host-value paths, keyed lookups, class-key overrides, builder and callback escapes, and recursive constructors.
• -- effect_generated_client: 2 of 2 pass in 1.8 s (OpenAI and Distilled Stripe). It runs separately because bundling the generated clients takes a few seconds.
• Full integration suite: 2254 pass at 91403544. The one failure is test262_module_code, because its submodule isn't checked out. 7f8a8e04 is a behavior-preserving refactor reviewed against these results, and the later commits change only docs.
• Clippy and fmt are clean.

Bundle measurements, from a release examples/effect_service_shaking.rs: median of 5 interleaved builds, and both outputs of every program run with Node.

program	off	on
lifecycle	149,375 B	149,007 B
cross_module	137,512 B	137,426 B
run_options	137,601 B	137,512 B
retained_fiber	140,984 B	140,895 B
provenance_success_channel	139,809 B	139,720 B
provenance_numeric_index	154,834 B	154,745 B
OpenAI generated client	2,068,645 B	532,916 B (−74.2%)
Distilled Stripe client, one operation	439,842 B	439,842 B (identical; the pass bails under A2)

The gates are minimal programs with one or a few unread methods each. Build times on the gates are 15–40 ms either way. For OpenAI they were 205–350 ms off and 170–300 ms on, depending on host load; the enabled build is usually faster because it writes far less. For Distilled Stripe they were 57–71 ms off and 82–111 ms on: the extra time is the analysis before it bails.

CI and docs

• .github/workflows/effect-service-shaking.yml runs one Linux / Node 24 job on pull requests and manual dispatch:
  • the effect_service fixtures under a 10-second limit, compiled in a separate step;
  • a snapshot check;
  • a debug NAPI binding build;
  • the real-Effect gates through the JS API.
• @effect/ai-openai 4.1.2 and @distilled.cloud/stripe 1.0.0-rc.18 (pinned) are root devDependencies for the generated-client fixtures. Both resolve to the single bundled effect 4.1.2.
• docs/in-depth/effect-service-shaking.md documents the handled shapes, the bailouts, the A1–A4 contract and the report.

Try it

cargo test --profile effect-verify -p rolldown --test integration -- effect_service
cargo test --profile effect-verify -p rolldown --test integration -- effect_generated_client
cargo run --release -p rolldown --example effect_service_shaking -- <entry> <out-dir> [runs]

[effect-bot]

Superseded by EFF-3430 following Tim’s design session. Closing unmerged; retaining this branch and effect-service-provenance-spec-tests for their tooling and fixtures. The feasibility result at 81230a1 works under A1–A4 and reduces the OpenAI client from 2,068,645 B to 532,916 B. The side-branch source-derivation evaluator is abandoned. Further work belongs to EFF-3430.