Function makeModule

makeModule<
    TProps = void,
    TReturn extends
        AnyContribution | readonly AnyContribution[] = readonly AnyContribution[],
    E extends Error = Error,
    R extends Requirements<readonly AnyTag[]> = Capability.Service,
>(
    fn: (props: TProps) => Effect<TReturn, E, Scope | R>,
): (props: TProps) => Effect<TReturn, E, Scope | R>

Helper to define a capability module with explicit typing. Wraps the default export function to provide better type inference and make the pattern explicit.

This helper provides explicit typing for the module activation function, making it clear that the function should:

Access declared requires via yield* (or the ambient Capability.Service/Plugin.Service)
Return an array of typed Contributions (see contribute/contributeAll)

Type Parameters

TProps = void
TReturn extends AnyContribution | readonly AnyContribution[] = readonly AnyContribution[]
E extends Error = Error
R extends Requirements<readonly AnyTag[]> = Capability.Service

Parameters

fn: (props: TProps) => Effect<TReturn, E, Scope | R>

Returns (props: TProps) => Effect<TReturn, E, Scope | R>

Example

// Module without options - single capability
export default Capability.makeModule(
  Effect.fnUntraced(function* () {
    const client = yield* ClientCapabilities.Client;
    return Capability.contribute(Capabilities.SettingsStore, store);
  })
);

// Module with multiple capabilities
export default Capability.makeModule(
  Effect.fnUntraced(function* () {
    return [
      Capability.contribute(Capabilities.SettingsStore, store),
      Capability.contribute(Capabilities.Translations, translations),
    ];
  })
);

// Module with required options (context accessed via layer)
export default Capability.makeModule(
  Effect.fnUntraced(function* (props: { observability: boolean }) {
    const invoker = yield* Capabilities.OperationInvoker;
    return Capability.contribute(Capabilities.OperationHandler, ...);
  })
);

// Module with scoped resources (closed automatically on deactivation)
export default Capability.makeModule(
  Effect.fnUntraced(function* () {
    const scope = yield* Scope.Scope;
    yield* Scope.addFinalizer(scope, Effect.sync(() => cleanup()));
    return Capability.contribute(Capabilities.MyCapability, implementation);
  })
);