@shivaedev/service 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.6.0 - 2026-10-30
+
+### Added
+
+- Jobs services share one scoped pg-boss client through the Effect environment. Registration, worker and producer Layers use the same connection and pool settings.
+- Service definitions accept marked generic methods alongside declared dependencies. Generic signatures retain their caller requirements unchanged; initialization can capture declared dependencies as private state.
+
+### Breaking
+
+- Move connection, pool, client factory, cache key and stop options from each `Jobs.layer` call into one `pgBossLayer` from `@shivaedev/jobs/server/service.ts`. Supply `connectionString` as `Redacted<string>` and provide that Layer to the merged jobs services. Keep only `jobs` and `onError` in `Jobs.layer`.
+- Call `jobs.health()` instead of yielding `jobs.health`. Custom jobs service implementations must expose health as a method. Admin's built-in jobs handlers call the method automatically. Jobs services passed to webhook routes and enqueue helpers must also implement the new method shape.
+
+## 0.5.1 - 2026-10-30
+
+### Changed
+
+- Require Effect 4.0.6 and align the Effect companion package peers and generated starter catalog to the same exact release. Install the 4.0.6 Effect stack together.
+
+### Fixed
+
+- Register hosted RPC cache-control handling through Effect 4.0.6's request-scoped pre-response API so responses keep `private, no-store`.
+- Accept native RPC's `application/x-ndjson` media type while preserving `application/ndjson` callers at the transport guard.
+- Keep subscriptions open after their HTTP request body completes; closing the socket still cancels them.
+
 ## 0.5.0 - 2026-10-27
 
 ### Breaking

package/README.md

@@ -8,14 +8,12 @@ A service should explain what it needs and what callers can do with it. When eve
 
 ```ts
 const Greetings = defineService({
-  id: "app/Greetings",
-  requires: [Prefix],
-  initialize: Effect.succeed({ punctuation: "!" }),
-  methods: (state) => ({
-    greet: Effect.fn("Greetings.greet")((name: string) =>
-      Effect.map(Prefix, (prefix) => `${prefix}${name}${state.punctuation}`),
-    ),
-  }),
+	id: "app/Greetings",
+	requires: [Prefix],
+	initialize: Effect.succeed({ punctuation: "!" }),
+	methods: (state) => ({
+		greet: Effect.fn("Greetings.greet")((name: string) => Effect.map(Prefix, (prefix) => `${prefix}${name}${state.punctuation}`)),
+	}),
 });
 ```
 
@@ -34,7 +32,6 @@ A **declared dependency** is a service tag in `requires`. The Layer supplies tho
 **Caller scope** is different from initialization scope. The Layer owns initialization resources: their finalizers run once when its scope closes or its owner is interrupted, including when initialization is still running. A method that acquires a scoped resource keeps `Scope.Scope` in its public requirement type; its caller supplies the scope and releases the resource when that scope closes, even while the service stays live. Interrupting a method call in `Effect.scoped` interrupts the call and releases its resources without ending the service's lifetime.
 
 The work has three parts:
-
 1. Once at the application boundary, compose service Layers with their dependencies.
 2. Once per service, define its dependency list, private state and methods.
 3. In application code, yield the service and call its methods.
@@ -48,23 +45,19 @@ import { defineService } from "@shivaedev/service/defineService.ts";
 class Prefix extends Context.Service<Prefix, string>()("app/Prefix") {}
 
 const Greetings = defineService({
-  id: "app/Greetings",
-  requires: [Prefix],
-  initialize: Effect.succeed({ punctuation: "!" }),
-  methods: (state) => ({
-    greet: Effect.fn("Greetings.greet")((name: string) =>
-      Effect.map(Prefix, (prefix) => `${prefix}${name}${state.punctuation}`),
-    ),
-  }),
+	id: "app/Greetings",
+	requires: [Prefix],
+	initialize: Effect.succeed({ punctuation: "!" }),
+	methods: (state) => ({
+		greet: Effect.fn("Greetings.greet")((name: string) => Effect.map(Prefix, (prefix) => `${prefix}${name}${state.punctuation}`)),
+	}),
 });
 
-const live = Greetings.layer.pipe(
-  Layer.provide(Layer.succeed(Prefix, "Hello ")),
-);
+const live = Greetings.layer.pipe(Layer.provide(Layer.succeed(Prefix, "Hello ")));
 
 const greeting = Effect.gen(function* () {
-  const greetings = yield* Greetings;
-  return yield* greetings.greet("Ada");
+	const greetings = yield* Greetings;
+	return yield* greetings.greet("Ada");
 }).pipe(Effect.provide(live));
 ```
 
@@ -83,28 +76,30 @@ import { Context, Effect, type Scope } from "effect";
 import { defineService } from "@shivaedev/service/defineService.ts";
 import type { ServiceRequirements } from "@shivaedev/service/ServiceRequirements.ts";
 
-class Declared extends Context.Service<Declared, { readonly identity: object }>()(
-  "app/Declared",
-) {}
+class Declared extends Context.Service<Declared, { readonly identity: object }>()("app/Declared") {}
 
 const requirements = [Declared] as const;
 
-type Requirements<Success, Failure = never, CallerScope extends Scope.Scope = never> =
-  ServiceRequirements<typeof requirements, Success, Failure, CallerScope>;
+type Requirements<Success, Failure = never, CallerScope extends Scope.Scope = never> = ServiceRequirements<
+	typeof requirements,
+	Success,
+	Failure,
+	CallerScope
+>;
 
 const Identity = defineService({
-  id: "app/Identity",
-  requires: requirements,
-  initialize: Effect.fn("Identity.initialize")(function* (): Requirements<{
-    readonly identity: object;
-  }> {
-    return { identity: (yield* Declared).identity };
-  })(),
-  methods: (state) => ({
-    sameIdentity: Effect.fn("Identity.sameIdentity")(function* (): Requirements<boolean> {
-      return (yield* Declared).identity === state.identity;
-    }),
-  }),
+	id: "app/Identity",
+	requires: requirements,
+	initialize: Effect.fn("Identity.initialize")(function* (): Requirements<{
+		readonly identity: object;
+	}> {
+		return { identity: (yield* Declared).identity };
+	})(),
+	methods: (state) => ({
+		sameIdentity: Effect.fn("Identity.sameIdentity")(function* (): Requirements<boolean> {
+			return (yield* Declared).identity === state.identity;
+		}),
+	}),
 });
 ```
 
@@ -117,24 +112,19 @@ import { Effect, Ref } from "effect";
 import { defineService } from "@shivaedev/service/defineService.ts";
 
 const Resources = defineService({
-  id: "app/Resources",
-  requires: [],
-  initialize: Ref.make(0),
-  methods: (released) => ({
-    open: Effect.fn("Resources.open")(() =>
-      Effect.acquireRelease(
-        Effect.succeed("resource"),
-        () => Ref.update(released, (count) => count + 1),
-      ),
-    ),
-    released: Effect.fn("Resources.released")(() => Ref.get(released)),
-  }),
+	id: "app/Resources",
+	requires: [],
+	initialize: Ref.make(0),
+	methods: (released) => ({
+		open: Effect.fn("Resources.open")(() => Effect.acquireRelease(Effect.succeed("resource"), () => Ref.update(released, (count) => count + 1))),
+		released: Effect.fn("Resources.released")(() => Ref.get(released)),
+	}),
 });
 
 const useResource = Effect.gen(function* () {
-  const resources = yield* Resources;
-  yield* Effect.scoped(resources.open());
-  return yield* resources.released();
+	const resources = yield* Resources;
+	yield* Effect.scoped(resources.open());
+	return yield* resources.released();
 }).pipe(Effect.provide(Resources.layer));
 ```
 
@@ -146,7 +136,7 @@ A native Layer can provide the method interface directly:
 
 ```ts
 const testGreetings = Layer.succeed(Greetings, {
-  greet: Effect.fn("TestGreetings.greet")((name: string) => Effect.succeed(name)),
+	greet: Effect.fn("TestGreetings.greet")((name: string) => Effect.succeed(name)),
 });
 ```
 
@@ -154,43 +144,37 @@ The replacement provides the public method interface, rather than private initia
 
 ### Preserve a generic method's signature
 
-Ordinary methods have one concrete signature. For a service with an empty `requires` list, `genericMethod` marks a generic function so its success, failure and caller requirements remain related at each call:
+Ordinary methods have one concrete signature. `genericMethod` marks a generic function so its success, failure and caller requirements remain related at each call:
 
 ```ts
 import { Context, Effect } from "effect";
 import { defineService } from "@shivaedev/service/defineService.ts";
 import { genericMethod } from "@shivaedev/service/genericMethod.ts";
 
-class Caller extends Context.Service<Caller, { readonly value: number }>()(
-  "app/Caller",
-) {}
+class Caller extends Context.Service<Caller, { readonly value: number }>()("app/Caller") {}
 
 const preserve = Effect.fn("Generic.preserve")(
-  <Success, Failure, Requirements>(
-    effect: Effect.Effect<Success, Failure, Requirements>,
-  ): Effect.Effect<{ readonly value: Success }, Failure, Requirements> =>
-    Effect.map(effect, (value) => ({ value })),
+	<Success, Failure, Requirements>(
+		effect: Effect.Effect<Success, Failure, Requirements>,
+	): Effect.Effect<{ readonly value: Success }, Failure, Requirements> => Effect.map(effect, (value) => ({ value })),
 );
 
 const Generic = defineService({
-  id: "app/Generic",
-  requires: [],
-  initialize: Effect.void,
-  methods: () => ({ preserve: genericMethod(preserve) }),
+	id: "app/Generic",
+	requires: [],
+	initialize: Effect.void,
+	methods: () => ({ preserve: genericMethod(preserve) }),
 });
 
 const preserved = Effect.gen(function* () {
-  const service = yield* Generic;
-  return yield* service.preserve(Effect.map(Caller, ({ value }) => value));
-}).pipe(
-  Effect.provide(Generic.layer),
-  Effect.provideService(Caller, { value: 42 }),
-);
+	const service = yield* Generic;
+	return yield* service.preserve(Effect.map(Caller, ({ value }) => value));
+}).pipe(Effect.provide(Generic.layer), Effect.provideService(Caller, { value: 42 }));
 ```
 
 The wrapped Effect still requires `Caller`, which the caller supplies separately. The generic service's Layer has no declared dependencies. The emitted declarations preserve the generic success and failure types as well as caller requirements.
 
-Marked generic methods require a service with no declared dependencies. The compiler rejects an unmarked generic that correlates its input and returned Effect, and a structurally distinct two-signature overload; it may not reject other generic or overloaded signatures. Use ordinary methods with concrete signatures when the service binds dependencies.
+Marked generic methods also work with declared initializer dependencies. Their signatures keep all caller requirements unchanged; unlike ordinary methods, they do not subtract declared dependencies from the public signature. The compiler rejects an unmarked generic that correlates its input and returned Effect, and a structurally distinct two-signature overload; it may not reject other generic or overloaded signatures. Use initialization state to close over bound dependencies in generic methods.
 
 Dependency binding wraps the method's outer returned Effect. A Stream returned as its value retains its own service requirements; provide them when running the Stream.
 
@@ -198,28 +182,27 @@ Dependency binding wraps the method's outer returned Effect. A Stream returned a
 
 Import the module that defines the name:
 
-| Module | Name | Use |
-| --- | --- | --- |
-| `@shivaedev/service/defineService.ts` | `defineService(definition)` | Create a native service with its `.layer`. |
-| `@shivaedev/service/genericMethod.ts` | `genericMethod(method)` | Mark a generic Effect-returning function in a service with no declared dependencies. |
+| Module                                      | Name                                                                               | Use                                                                                     |
+| ------------------------------------------- | ---------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| `@shivaedev/service/defineService.ts`       | `defineService(definition)`                                                        | Create a native service with its `.layer`.                                              |
+| `@shivaedev/service/genericMethod.ts`       | `genericMethod(method)`                                                            | Preserve a generic Effect-returning function and its caller requirements.               |
 | `@shivaedev/service/ServiceRequirements.ts` | `ServiceRequirements<Requirements, Success, Failure = never, CallerScope = never>` | Annotate an `Effect.fn` generator with declared dependencies and optional caller scope. |
 
 The definition's fields are:
 
-| Field | Meaning |
-| --- | --- |
-| `id` | The Context service identity, also retained in the Layer's output type. |
-| `requires` | A readonly list of service tags available to initialization and ordinary methods. |
-| `initialize` | The Effect producing private state; its failure type becomes the Layer's failure type. |
+| Field            | Meaning                                                                                                                     |
+| ---------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `id`             | The Context service identity, also retained in the Layer's output type.                                                     |
+| `requires`       | A readonly list of service tags available to initialization and ordinary methods.                                           |
+| `initialize`     | The Effect producing private state; its failure type becomes the Layer's failure type.                                      |
 | `methods(state)` | A function returning the public method record, with declared dependencies removed from ordinary methods' requirement types. |
 
 ### Install and limits
 
 ```sh
-pnpm add @shivaedev/service effect@4.0.5
+pnpm add @shivaedev/service effect
 ```
 
 `effect` is a peer dependency, and the package needs Node.js 24 or later.
-
 - Keep request identity at the request boundary when it changes per call. Pass it as a method argument rather than binding it into a service intended to live across requests.
 - Choose service Layer lifetimes at the application's composition boundary; keep initialization resource ownership separate from a method caller's scope.

package/dist/MethodProof.d.ts

@@ -5,9 +5,6 @@ export type MethodEntry = AnyMethod | GenericMethodDescriptor<AnyMethod>;
 export type MethodRecord = Readonly<Record<string, AnyMethod>>;
 export type MethodInventory = Readonly<Record<string, unknown>>;
 export type RuntimeMethodInventory = Readonly<Record<string, MethodEntry>>;
-interface GenericMethodWithDeclaredRequirementsIsUnsupported {
-    readonly _serviceDefinitionError: "generic methods cannot subtract declared service requirements";
-}
 type MethodRequirements<TMethod> = TMethod extends (...arguments_: readonly never[]) => Effect.Effect<unknown, unknown, infer TRequirements> ? TRequirements : never;
 interface MethodHasUndeclaredServiceRequirements {
     readonly _serviceDefinitionError: "method has service requirements absent from the service declaration";
@@ -18,7 +15,7 @@ interface ServiceMembersMustBeMethods {
 type OrdinaryMethodProof<TMethod, TRequirements extends RequirementRecord> = [
     Exclude<MethodRequirements<TMethod>, RequirementsOf<TRequirements> | Scope.Scope>
 ] extends [never] ? TMethod : MethodHasUndeclaredServiceRequirements;
-type SupportedMethod<TMethod, TRequirements extends RequirementRecord> = TMethod extends GenericMethodDescriptor<AnyMethod> ? TRequirements extends readonly [] ? TMethod : GenericMethodWithDeclaredRequirementsIsUnsupported : TMethod extends AnyMethod ? HasDistinctCallSignatures<TMethod> extends true ? GenericOrStructurallyOverloadedMethodsAreUnsupported : TMethod extends (...arguments_: infer TArguments) => infer TResult ? ((...arguments_: TArguments) => TResult) extends TMethod ? OrdinaryMethodProof<TMethod, TRequirements> : GenericOrStructurallyOverloadedMethodsAreUnsupported : GenericOrStructurallyOverloadedMethodsAreUnsupported : ServiceMembersMustBeMethods;
+type SupportedMethod<TMethod, TRequirements extends RequirementRecord> = TMethod extends GenericMethodDescriptor<AnyMethod> ? TMethod : TMethod extends AnyMethod ? HasDistinctCallSignatures<TMethod> extends true ? GenericOrStructurallyOverloadedMethodsAreUnsupported : TMethod extends (...arguments_: infer TArguments) => infer TResult ? ((...arguments_: TArguments) => TResult) extends TMethod ? OrdinaryMethodProof<TMethod, TRequirements> : GenericOrStructurallyOverloadedMethodsAreUnsupported : GenericOrStructurallyOverloadedMethodsAreUnsupported : ServiceMembersMustBeMethods;
 export type MethodProof<TMethods extends MethodInventory, TRequirements extends RequirementRecord> = {
     readonly [TName in keyof TMethods]: SupportedMethod<TMethods[TName], TRequirements>;
 };

package/dist/MethodProof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MethodProof.d.ts","sourceRoot":"","sources":["../src/MethodProof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,EACX,SAAS,EACT,uBAAuB,EACvB,oDAAoD,EACpD,yBAAyB,EACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAElF,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,uBAAuB,CAAC,SAAS,CAAC,CAAC;AAEzE,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEhE,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAE3E,UAAU,kDAAkD;IAC3D,QAAQ,CAAC,uBAAuB,EAAE,+DAA+D,CAAC;CAClG;AAED,KAAK,kBAAkB,CAAC,OAAO,IAAI,OAAO,SAAS,CAAC,GAAG,UAAU,EAAE,SAAS,KAAK,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC,GACzI,aAAa,GACb,KAAK,CAAC;AAET,UAAU,sCAAsC;IAC/C,QAAQ,CAAC,uBAAuB,EAAE,qEAAqE,CAAC;CACxG;AAED,UAAU,2BAA2B;IACpC,QAAQ,CAAC,uBAAuB,EAAE,iCAAiC,CAAC;CACpE;AAED,KAAK,mBAAmB,CAAC,OAAO,EAAE,aAAa,SAAS,iBAAiB,IAAI;IAC5E,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;CACjF,SAAS,CAAC,KAAK,CAAC,GACd,OAAO,GACP,sCAAsC,CAAC;AAE1C,KAAK,eAAe,CAAC,OAAO,EAAE,aAAa,SAAS,iBAAiB,IACpE,OAAO,SAAS,uBAAuB,CAAC,SAAS,CAAC,GAC/C,aAAa,SAAS,SAAS,EAAE,GAChC,OAAO,GACP,kDAAkD,GACnD,OAAO,SAAS,SAAS,GACxB,yBAAyB,CAAC,OAAO,CAAC,SAAS,IAAI,GAC9C,oDAAoD,GACpD,OAAO,SAAS,CAAC,GAAG,UAAU,EAAE,MAAM,UAAU,KAAK,MAAM,OAAO,GACjE,CAAC,CAAC,GAAG,UAAU,EAAE,UAAU,KAAK,OAAO,CAAC,SAAS,OAAO,GACvD,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,GAC3C,oDAAoD,GACrD,oDAAoD,GACtD,2BAA2B,CAAC;AAEjC,MAAM,MAAM,WAAW,CAAC,QAAQ,SAAS,eAAe,EAAE,aAAa,SAAS,iBAAiB,IAAI;IACpG,QAAQ,EAAE,KAAK,IAAI,MAAM,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;CACnF,CAAC"}
+{"version":3,"file":"MethodProof.d.ts","sourceRoot":"","sources":["../src/MethodProof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,EACX,SAAS,EACT,uBAAuB,EACvB,oDAAoD,EACpD,yBAAyB,EACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAElF,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,uBAAuB,CAAC,SAAS,CAAC,CAAC;AAEzE,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEhE,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAE3E,KAAK,kBAAkB,CAAC,OAAO,IAAI,OAAO,SAAS,CAAC,GAAG,UAAU,EAAE,SAAS,KAAK,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC,GACzI,aAAa,GACb,KAAK,CAAC;AAET,UAAU,sCAAsC;IAC/C,QAAQ,CAAC,uBAAuB,EAAE,qEAAqE,CAAC;CACxG;AAED,UAAU,2BAA2B;IACpC,QAAQ,CAAC,uBAAuB,EAAE,iCAAiC,CAAC;CACpE;AAED,KAAK,mBAAmB,CAAC,OAAO,EAAE,aAAa,SAAS,iBAAiB,IAAI;IAC5E,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;CACjF,SAAS,CAAC,KAAK,CAAC,GACd,OAAO,GACP,sCAAsC,CAAC;AAE1C,KAAK,eAAe,CAAC,OAAO,EAAE,aAAa,SAAS,iBAAiB,IACpE,OAAO,SAAS,uBAAuB,CAAC,SAAS,CAAC,GAC/C,OAAO,GACP,OAAO,SAAS,SAAS,GACxB,yBAAyB,CAAC,OAAO,CAAC,SAAS,IAAI,GAC9C,oDAAoD,GACpD,OAAO,SAAS,CAAC,GAAG,UAAU,EAAE,MAAM,UAAU,KAAK,MAAM,OAAO,GACjE,CAAC,CAAC,GAAG,UAAU,EAAE,UAAU,KAAK,OAAO,CAAC,SAAS,OAAO,GACvD,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,GAC3C,oDAAoD,GACrD,oDAAoD,GACtD,2BAA2B,CAAC;AAEjC,MAAM,MAAM,WAAW,CAAC,QAAQ,SAAS,eAAe,EAAE,aAAa,SAAS,iBAAiB,IAAI;IACpG,QAAQ,EAAE,KAAK,IAAI,MAAM,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;CACnF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/service",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Declared Effect services with scoped initialization and bound dependencies",
   "keywords": [
     "effect"
@@ -43,17 +43,17 @@
     "README.md"
   ],
   "devDependencies": {
-    "@effect/vitest": "4.0.5",
-    "@shivaedev/quality": "0.42.0",
-    "@shivaedev/test": "0.10.0",
-    "@shivaedev/test-story": "0.21.0",
+    "@effect/vitest": "4.0.6",
+    "@shivaedev/quality": "0.46.0",
+    "@shivaedev/test": "0.11.0",
+    "@shivaedev/test-story": "0.25.0",
     "@types/node": "24.19.2",
-    "effect": "4.0.5",
+    "effect": "4.0.6",
     "typescript": "7.0.2",
     "vitest": "5.0.5"
   },
   "peerDependencies": {
-    "effect": "4.0.5"
+    "effect": "4.0.6"
   },
   "engines": {
     "node": ">=24"

package/src/MethodProof.ts

@@ -15,10 +15,6 @@ export type MethodInventory = Readonly<Record<string, unknown>>;
 
 export type RuntimeMethodInventory = Readonly<Record<string, MethodEntry>>;
 
-interface GenericMethodWithDeclaredRequirementsIsUnsupported {
-	readonly _serviceDefinitionError: "generic methods cannot subtract declared service requirements";
-}
-
 type MethodRequirements<TMethod> = TMethod extends (...arguments_: readonly never[]) => Effect.Effect<unknown, unknown, infer TRequirements>
 	? TRequirements
 	: never;
@@ -39,9 +35,7 @@ type OrdinaryMethodProof<TMethod, TRequirements extends RequirementRecord> = [
 
 type SupportedMethod<TMethod, TRequirements extends RequirementRecord> =
 	TMethod extends GenericMethodDescriptor<AnyMethod>
-		? TRequirements extends readonly []
-			? TMethod
-			: GenericMethodWithDeclaredRequirementsIsUnsupported
+		? TMethod
 		: TMethod extends AnyMethod
 			? HasDistinctCallSignatures<TMethod> extends true
 				? GenericOrStructurallyOverloadedMethodsAreUnsupported