@shivaedev/service 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.7.0 - 2026-11-04
+
+### Breaking
+
+- TypeScript source exports now use `@shivaedev/source` instead of `source`. Replace `source` with `@shivaedev/source` in Node `--conditions`, TypeScript `customConditions`, and Vite/Vitest `resolve.conditions`. Bare `source` selects built JavaScript; no compatibility alias is provided.
+
+## 0.6.2 - 2026-11-04
+
+### Fixed
+
+- Name the ordinary method and every missing service type in undeclared service requirement diagnostics, excluding declared dependencies and caller scope.
+
 ## 0.6.1 - 2026-11-02
 
 ### Fixed

package/README.md

@@ -7,13 +7,16 @@ Declare an Effect service's dependencies once, initialize its private state, and
 A service should explain what it needs and what callers can do with it. When every method binds dependencies separately, that explanation is scattered across setup and application code. Put the dependency list, private initialization and public methods in one definition:
 
 ```ts
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { greet } from "#greetings/greet.ts";
+import { initializeGreetings } from "#greetings/initialize.ts";
+import { Prefix } from "#Prefix.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}`)),
-	}),
+	initialize: initializeGreetings,
+	methods: (state) => ({ greet: greet(state) }),
 });
 ```
 
@@ -36,22 +39,51 @@ The work has three parts:
 2. Once per service, define its dependency list, private state and methods.
 3. In application code, yield the service and call its methods.
 
-### 1. Define a service and provide its dependencies
+### 1. Assemble the service from focused files
+
+A service file is an inventory: a top-level `defineService` call lists `id`, `requires`, `initialize` and `methods` directly. Keep each initializer and operation in its own focused file and import its named export. Use `Effect.void` when there is no initialization state. The methods arrow returns the operation record directly. Each entry names an imported operation or calls an imported state factory; `genericMethod` may wrap either form.
+
+Quality enforces this with `effect/service-definition-assembly`, including adapters and tests. It rejects a configuration hidden behind a variable, spreads or computed configuration members, hidden method records, inline operations, local implementation references and implementation bodies beside the assembly. Keep setup inside the imported initializer or operation factory. Existing Quality span checks apply to the implementations: use names such as `Greetings.greet`, with an operation matching its binding. No second span convention applies to service assemblies.
+
+The initializer module exports its Effect:
 
 ```ts
-import { Context, Effect, Layer } from "effect";
-import { defineService } from "@shivaedev/service/defineService.ts";
+import { Effect } from "effect";
 
-class Prefix extends Context.Service<Prefix, string>()("app/Prefix") {}
+export const initializeGreetings = Effect.succeed({ punctuation: "!" });
+```
+
+The operation module exports a state factory; its returned function is the public method:
+
+```ts
+import { Effect } from "effect";
+import { Prefix } from "#Prefix.ts";
+
+export function greet(state: { readonly punctuation: string }) {
+	return Effect.fn("Greetings.greet")((name: string) => Effect.map(Prefix, (prefix) => `${prefix}${name}${state.punctuation}`));
+}
+```
+
+The service module imports those exports. `Prefix` is a separate native Context service:
+
+```ts
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { greet } from "#greetings/greet.ts";
+import { initializeGreetings } from "#greetings/initialize.ts";
+import { Prefix } from "#Prefix.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}`)),
-	}),
+	initialize: initializeGreetings,
+	methods: (state) => ({ greet: greet(state) }),
 });
+```
+
+Application code composes its Layer and calls the service:
+
+```ts
+import { Effect, Layer } from "effect";
 
 const live = Greetings.layer.pipe(Layer.provide(Layer.succeed(Prefix, "Hello ")));
 
@@ -63,7 +95,7 @@ const greeting = Effect.gen(function* () {
 
 The Layer needs `Prefix`. After a caller resolves `Greetings`, `greet` needs no `Prefix` from that caller. Its argument and success type are inferred from the method. An initialization failure fails the Layer build with that typed error and runs finalizers registered before the failure. A method failure reaches the caller as that method's typed error, and the same service instance can handle the next call. A method defect remains a defect.
 
-`initialize` and ordinary methods may require the listed services and `Scope.Scope`. The compiler rejects a definition that reads another service. Scope is supplied by the Layer or method caller, so `Scope.Scope` itself cannot appear in `requires`.
+`initialize` and ordinary methods may require the listed services and `Scope.Scope`. The compiler rejects a definition that reads another service. For an ordinary method, the diagnostic names the method and its missing service types, such as `MethodHasUndeclaredServiceRequirements<"write", Reactivity>`. When a method is missing several services, the diagnostic includes their union; declared services and caller scope are excluded. Scope is supplied by the Layer or method caller, so `Scope.Scope` itself cannot appear in `requires`.
 
 Native `Context.Reference` keys can appear in `requires`. Their defaults make them requirement-free in Effect, so they add no Layer dependency, including when the reference's value is a scope.
 
@@ -75,7 +107,6 @@ For an explicitly annotated `Effect.fn` generator, `ServiceRequirements` express
 
 ```ts
 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") {}
@@ -89,20 +120,11 @@ type Requirements<Success, Failure = never, CallerScope extends Scope.Scope = ne
 	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;
-		}),
-	}),
-});
+export const initializeIdentity = Effect.fn("Identity.initializeIdentity")(function* (): Requirements<{
+	readonly identity: object;
+}> {
+	return { identity: (yield* Declared).identity };
+})();
 ```
 
 The alias is `Effect.fn.Return<Success, Failure, declared services | CallerScope>`. The last parameter can be `Scope.Scope` when the generator acquires a scoped resource; it cannot add another undeclared service. The annotation describes the implementation's requirements. `defineService` removes declared dependencies from the public methods' requirements.
@@ -111,18 +133,15 @@ The alias is `Effect.fn.Return<Success, Failure, declared services | CallerScope
 
 ```ts
 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)),
-	}),
-});
+export function open(released: Ref.Ref<number>) {
+	return Effect.fn("Resources.open")(() => Effect.acquireRelease(Effect.succeed("resource"), () => Ref.update(released, (count) => count + 1)));
+}
+```
 
+The assembly imports `open`, a `released` state factory and an initializer that returns `Ref.make(0)`. Its methods inventory is `(state) => ({ open: open(state), released: released(state) })`. A caller can then use:
+
+```ts
 const useResource = Effect.gen(function* () {
 	const resources = yield* Resources;
 	yield* Effect.scoped(resources.open());
@@ -149,17 +168,24 @@ The replacement provides the public method interface, rather than private initia
 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";
+import { Effect } from "effect";
 
-class Caller extends Context.Service<Caller, { readonly value: number }>()("app/Caller") {}
-
-const preserve = Effect.fn("Generic.preserve")(
+export 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 })),
 );
+```
+
+The assembly imports the generic operation and marks it in the inventory:
+
+```ts
+import { Context, Effect } from "effect";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { genericMethod } from "@shivaedev/service/genericMethod.ts";
+import { preserve } from "#preserve.ts";
+
+class Caller extends Context.Service<Caller, { readonly value: number }>()("app/Caller") {}
 
 const Generic = defineService({
 	id: "app/Generic",
@@ -167,7 +193,11 @@ const Generic = defineService({
 	initialize: Effect.void,
 	methods: () => ({ preserve: genericMethod(preserve) }),
 });
+```
 
+A caller keeps the generic operation's requirements:
+
+```ts
 const preserved = Effect.gen(function* () {
 	const service = yield* Generic;
 	return yield* service.preserve(Effect.map(Caller, ({ value }) => value));

package/dist/MethodProof.d.ts

@@ -1,23 +1,25 @@
 import type { Effect, Scope } from "effect";
-import type { AnyMethod, GenericMethodDescriptor, GenericOrStructurallyOverloadedMethodsAreUnsupported, HasDistinctCallSignatures } from "./genericMethod.ts";
-import type { RequirementRecord, RequirementsOf } from "./ServiceRequirements.ts";
+import type { AnyMethod, GenericMethodDescriptor, GenericOrStructurallyOverloadedMethodsAreUnsupported, HasDistinctCallSignatures } from "#genericMethod.ts";
+import type { RequirementRecord, RequirementsOf } from "#ServiceRequirements.ts";
 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>>;
 type MethodRequirements<TMethod> = TMethod extends (...arguments_: readonly never[]) => Effect.Effect<unknown, unknown, infer TRequirements> ? TRequirements : never;
-interface MethodHasUndeclaredServiceRequirements {
+interface MethodHasUndeclaredServiceRequirements<TName extends PropertyKey, TMissing> {
     readonly _serviceDefinitionError: "method has service requirements absent from the service declaration";
+    readonly method: TName;
+    readonly missingServices: TMissing;
 }
 interface ServiceMembersMustBeMethods {
     readonly _serviceDefinitionError: "service members must be methods";
 }
-type OrdinaryMethodProof<TMethod, TRequirements extends RequirementRecord> = [
+type OrdinaryMethodProof<TName extends PropertyKey, 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> ? 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;
+] extends [never] ? TMethod : MethodHasUndeclaredServiceRequirements<TName, Exclude<MethodRequirements<TMethod>, RequirementsOf<TRequirements> | Scope.Scope>>;
+type SupportedMethod<TName extends PropertyKey, 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<TName, TMethod, TRequirements> : GenericOrStructurallyOverloadedMethodsAreUnsupported : GenericOrStructurallyOverloadedMethodsAreUnsupported : ServiceMembersMustBeMethods;
 export type MethodProof<TMethods extends MethodInventory, TRequirements extends RequirementRecord> = {
-    readonly [TName in keyof TMethods]: SupportedMethod<TMethods[TName], TRequirements>;
+    readonly [TName in keyof TMethods]: SupportedMethod<TName, TMethods[TName], TRequirements>;
 };
 export {};
 //# sourceMappingURL=MethodProof.d.ts.map

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,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"}
+{"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,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEjF,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,CAAC,KAAK,SAAS,WAAW,EAAE,QAAQ;IACnF,QAAQ,CAAC,uBAAuB,EAAE,qEAAqE,CAAC;IACxG,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC;CACnC;AAED,UAAU,2BAA2B;IACpC,QAAQ,CAAC,uBAAuB,EAAE,iCAAiC,CAAC;CACpE;AAED,KAAK,mBAAmB,CAAC,KAAK,SAAS,WAAW,EAAE,OAAO,EAAE,aAAa,SAAS,iBAAiB,IAAI;IACvG,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,KAAK,EAAE,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AAEpI,KAAK,eAAe,CAAC,KAAK,SAAS,WAAW,EAAE,OAAO,EAAE,aAAa,SAAS,iBAAiB,IAC/F,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,KAAK,EAAE,OAAO,EAAE,aAAa,CAAC,GAClD,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,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;CAC1F,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/service",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Declared Effect services with scoped initialization and bound dependencies",
   "keywords": [
     "effect"
@@ -20,14 +20,14 @@
   "imports": {
     "#test/*": "./src/test-support/*",
     "#*.ts": {
-      "source": "./src/*.ts",
+      "@shivaedev/source": "./src/*.ts",
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
     }
   },
   "exports": {
     "./*.ts": {
-      "source": "./src/*.ts",
+      "@shivaedev/source": "./src/*.ts",
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
     },
@@ -44,9 +44,9 @@
   ],
   "devDependencies": {
     "@effect/vitest": "4.0.6",
-    "@shivaedev/quality": "0.55.0",
-    "@shivaedev/test": "0.12.1",
-    "@shivaedev/test-story": "0.33.0",
+    "@shivaedev/quality": "0.60.0",
+    "@shivaedev/test": "0.15.0",
+    "@shivaedev/test-story": "0.38.0",
     "@types/node": "24.19.2",
     "effect": "4.0.6",
     "typescript": "7.0.2",

package/src/MethodProof.ts

@@ -4,8 +4,8 @@ import type {
 	GenericMethodDescriptor,
 	GenericOrStructurallyOverloadedMethodsAreUnsupported,
 	HasDistinctCallSignatures,
-} from "./genericMethod.ts";
-import type { RequirementRecord, RequirementsOf } from "./ServiceRequirements.ts";
+} from "#genericMethod.ts";
+import type { RequirementRecord, RequirementsOf } from "#ServiceRequirements.ts";
 
 export type MethodEntry = AnyMethod | GenericMethodDescriptor<AnyMethod>;
 
@@ -19,21 +19,23 @@ type MethodRequirements<TMethod> = TMethod extends (...arguments_: readonly neve
 	? TRequirements
 	: never;
 
-interface MethodHasUndeclaredServiceRequirements {
+interface MethodHasUndeclaredServiceRequirements<TName extends PropertyKey, TMissing> {
 	readonly _serviceDefinitionError: "method has service requirements absent from the service declaration";
+	readonly method: TName;
+	readonly missingServices: TMissing;
 }
 
 interface ServiceMembersMustBeMethods {
 	readonly _serviceDefinitionError: "service members must be methods";
 }
 
-type OrdinaryMethodProof<TMethod, TRequirements extends RequirementRecord> = [
+type OrdinaryMethodProof<TName extends PropertyKey, TMethod, TRequirements extends RequirementRecord> = [
 	Exclude<MethodRequirements<TMethod>, RequirementsOf<TRequirements> | Scope.Scope>,
 ] extends [never]
 	? TMethod
-	: MethodHasUndeclaredServiceRequirements;
+	: MethodHasUndeclaredServiceRequirements<TName, Exclude<MethodRequirements<TMethod>, RequirementsOf<TRequirements> | Scope.Scope>>;
 
-type SupportedMethod<TMethod, TRequirements extends RequirementRecord> =
+type SupportedMethod<TName extends PropertyKey, TMethod, TRequirements extends RequirementRecord> =
 	TMethod extends GenericMethodDescriptor<AnyMethod>
 		? TMethod
 		: TMethod extends AnyMethod
@@ -41,11 +43,11 @@ type SupportedMethod<TMethod, TRequirements extends RequirementRecord> =
 				? GenericOrStructurallyOverloadedMethodsAreUnsupported
 				: TMethod extends (...arguments_: infer TArguments) => infer TResult
 					? ((...arguments_: TArguments) => TResult) extends TMethod
-						? OrdinaryMethodProof<TMethod, TRequirements>
+						? OrdinaryMethodProof<TName, TMethod, TRequirements>
 						: GenericOrStructurallyOverloadedMethodsAreUnsupported
 					: GenericOrStructurallyOverloadedMethodsAreUnsupported
 			: ServiceMembersMustBeMethods;
 
 export type MethodProof<TMethods extends MethodInventory, TRequirements extends RequirementRecord> = {
-	readonly [TName in keyof TMethods]: SupportedMethod<TMethods[TName], TRequirements>;
+	readonly [TName in keyof TMethods]: SupportedMethod<TName, TMethods[TName], TRequirements>;
 };