@shivaedev/service 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 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
+
+- Accept native `Context.Reference` keys in `defineService` requirements without treating their `never` identifier as caller-owned `Scope.Scope`.
+
 ## 0.6.0 - 2026-10-30
 
 ### Added

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";
+
+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:
 
-class Prefix extends Context.Service<Prefix, string>()("app/Prefix") {}
+```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,9 @@ 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.
 
 Return functions from the method factory, each producing an Effect. An Effect value placed directly in the method record is rejected. Keep the private state behind those functions; it is absent from the emitted public service declaration.
 
@@ -73,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") {}
@@ -87,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.
@@ -109,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());
@@ -147,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";
-
-class Caller extends Context.Service<Caller, { readonly value: number }>()("app/Caller") {}
+import { Effect } from "effect";
 
-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",
@@ -165,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));
@@ -174,6 +206,8 @@ const preserved = Effect.gen(function* () {
 
 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.
 
+A generic method's remaining requirements follow native Effect rules: execution without them is a compile error. Composing the call into a Layer retains those dependencies until they are provided; an initializer cannot use the call unless its service declares those 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.

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/dist/RequirementProof.d.ts

@@ -1,9 +1,9 @@
 import type { Context, Scope } from "effect";
-import type { RequirementRecord } from "./ServiceRequirements.ts";
+import type { RequirementRecord } from "#ServiceRequirements.ts";
 interface ScopeCannotBeDeclaredAsServiceRequirement {
     readonly _serviceDefinitionError: "Scope.Scope is caller-owned and cannot be declared as a service requirement";
 }
-type ProveRequirement<TRequirement> = TRequirement extends Context.Service.Any ? Context.Service.Identifier<TRequirement> extends Scope.Scope ? ScopeCannotBeDeclaredAsServiceRequirement : TRequirement : never;
+type ProveRequirement<TRequirement> = TRequirement extends Context.Service.Any ? [Context.Service.Identifier<TRequirement>] extends [never] ? TRequirement : Context.Service.Identifier<TRequirement> extends Scope.Scope ? ScopeCannotBeDeclaredAsServiceRequirement : TRequirement : never;
 export type RequirementProof<TRequirements extends RequirementRecord> = {
     readonly [TIndex in keyof TRequirements]: ProveRequirement<TRequirements[TIndex]>;
 };

package/dist/RequirementProof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RequirementProof.d.ts","sourceRoot":"","sources":["../src/RequirementProof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,UAAU,yCAAyC;IAClD,QAAQ,CAAC,uBAAuB,EAAE,6EAA6E,CAAC;CAChH;AAED,KAAK,gBAAgB,CAAC,YAAY,IAAI,YAAY,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG,GAC3E,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,SAAS,KAAK,CAAC,KAAK,GAC3D,yCAAyC,GACzC,YAAY,GACb,KAAK,CAAC;AAET,MAAM,MAAM,gBAAgB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACvE,QAAQ,EAAE,MAAM,IAAI,MAAM,aAAa,GAAG,gBAAgB,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;CACjF,CAAC"}
+{"version":3,"file":"RequirementProof.d.ts","sourceRoot":"","sources":["../src/RequirementProof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,UAAU,yCAAyC;IAClD,QAAQ,CAAC,uBAAuB,EAAE,6EAA6E,CAAC;CAChH;AAED,KAAK,gBAAgB,CAAC,YAAY,IAAI,YAAY,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG,GAC3E,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACzD,YAAY,GACZ,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,SAAS,KAAK,CAAC,KAAK,GAC3D,yCAAyC,GACzC,YAAY,GACd,KAAK,CAAC;AAET,MAAM,MAAM,gBAAgB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACvE,QAAQ,EAAE,MAAM,IAAI,MAAM,aAAa,GAAG,gBAAgB,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;CACjF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/service",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Declared Effect services with scoped initialization and bound dependencies",
   "keywords": [
     "effect"
@@ -44,9 +44,9 @@
   ],
   "devDependencies": {
     "@effect/vitest": "4.0.6",
-    "@shivaedev/quality": "0.46.0",
-    "@shivaedev/test": "0.11.0",
-    "@shivaedev/test-story": "0.25.0",
+    "@shivaedev/quality": "0.58.0",
+    "@shivaedev/test": "0.14.0",
+    "@shivaedev/test-story": "0.37.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>;
 };

package/src/RequirementProof.ts

@@ -1,14 +1,16 @@
 import type { Context, Scope } from "effect";
-import type { RequirementRecord } from "./ServiceRequirements.ts";
+import type { RequirementRecord } from "#ServiceRequirements.ts";
 
 interface ScopeCannotBeDeclaredAsServiceRequirement {
 	readonly _serviceDefinitionError: "Scope.Scope is caller-owned and cannot be declared as a service requirement";
 }
 
 type ProveRequirement<TRequirement> = TRequirement extends Context.Service.Any
-	? Context.Service.Identifier<TRequirement> extends Scope.Scope
-		? ScopeCannotBeDeclaredAsServiceRequirement
-		: TRequirement
+	? [Context.Service.Identifier<TRequirement>] extends [never]
+		? TRequirement
+		: Context.Service.Identifier<TRequirement> extends Scope.Scope
+			? ScopeCannotBeDeclaredAsServiceRequirement
+			: TRequirement
 	: never;
 
 export type RequirementProof<TRequirements extends RequirementRecord> = {