@shivaedev/service 0.0.0 → 0.5.0

package/CHANGELOG.md

@@ -0,0 +1,65 @@
+# Changelog
+
+## 0.5.0 - 2026-10-27
+
+### Breaking
+
+- Rename `@shivaedev/effect-service` to `@shivaedev/service`. Change dependency declarations and imports from `@shivaedev/effect-service/...` to `@shivaedev/service/...`; module paths inside the package are unchanged.
+
+## 0.4.1 - 2026-10-24
+
+### Changed
+
+- Require Effect and its companion packages at exactly 4.0.5. Generated applications use the same versions.
+
+## 0.4.0 - 2026-10-18
+
+### Breaking
+
+- Modules are named after their export: `define-service.ts` becomes `defineService.ts`, `generic-method.ts` becomes `genericMethod.ts`, `initializer-proof.ts` becomes `InitializerProof.ts`, `method-proof.ts` becomes `MethodProof.ts`, `requirement-proof.ts` becomes `RequirementProof.ts`, and `service-requirements.ts` becomes `ServiceRequirements.ts`.
+
+## 0.3.0 - 2026-10-13
+
+### Changed
+
+- Prefix generic type parameter names in service definitions and method proofs with `T`, preserving their type relationships and runtime behavior.
+- Document the service definition, private state, dependency binding and caller scope in the README, agent guidance, north star and roadmap; publish `docs/` with the README while keeping agent guidance out of the package.
+- Build package JavaScript, declarations and source maps with TypeScript 7.
+
+### Breaking
+
+- Requires stable Effect 4.0.4 in place of 4.0.0-rc.112. Effect 4.0.4 moves the former `effect/unstable/*` modules to `effect/*` and renames constructors such as `Config.string` to `Config.String`.
+
+## 0.2.0 - 2026-10-04
+
+### Changed
+
+- Breaking: no root entry and no module that re-exports another. `exports` maps one `"./*.ts"` pattern to every module (`src` under the `source` condition, `dist` otherwise), so you import the module that defines a name, and a bundler sees only the modules you use. Where each name now lives:
+  - `@shivaedev/effect-service`: `@shivaedev/effect-service/define-service.ts` (`defineService`), `@shivaedev/effect-service/generic-method.ts` (`genericMethod`), `@shivaedev/effect-service/service-requirements.ts` (`ServiceRequirements`)
+
+## 0.1.1 - 2026-10-04
+
+### Changed
+
+- Imports that leave their folder go through `#` aliases declared in the `imports` field of `package.json`: `#*.ts` resolves to `src` under the `source` condition and to `dist` otherwise, and `#test/*` names a test file. The published modules and declarations name the package's own files through these aliases.
+
+- Validate packed consumers and executable bins through the shared workspace gate.
+
+- Build with the `@shivaedev/quality` tsconfig presets, which target ESNext and allow only erasable TypeScript syntax.
+
+- Type-check with TypeScript 7 only. TypeScript 6 still builds the package.
+
+- Lint and format with the `@shivaedev/quality` Biome preset through `quality lint` at the repository root, which replaces the package's `check` script.
+
+- Run tests through the `@shivaedev/quality` Vitest projects, which take a test's environment from its file name. Type tests are named `*.typecheck.test.ts`.
+
+- Keep `package.json` in sort-package-json key order, checked by `quality lint`.
+
+## 0.1.0 - 2026-09-26
+
+### Added
+
+- Declare service dependencies once and bind them in scoped initialization and
+  ordinary Effect methods.
+- Preserve typed initialization failures, method failures, caller scopes, and
+  explicitly marked generic methods.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShivaeDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,225 @@
 # @shivaedev/service
 
-Placeholder. Real releases start above 0.0.0.
+Declare an Effect service's dependencies once, initialize its private state, and call its methods without supplying those dependencies again. The service remains a native Context service with a native Layer; its methods remain Effects with their own result, failure and caller scope types.
+
+## Why you want this
+
+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
+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}`),
+    ),
+  }),
+});
+```
+
+`Prefix` is an Effect service. Provide it to `Greetings.layer` once; callers ask for `Greetings` and call `greet(name)`. The punctuation stays private, the prefix stays bound to the service's dependency, and each caller sees an ordinary Effect instead of dependency plumbing.
+
+## Using it
+
+### How to think about it
+
+A **service definition** has four parts: an identity, a list of required services, an initialization Effect, and a function that turns its private state into methods. `defineService` returns the native Context service callers yield and its `.layer`, which applications compose with the dependencies' Layers.
+
+A **declared dependency** is a service tag in `requires`. The Layer supplies those services to initialization and binds them to each method. The public method's type removes their requirements. If a caller provides a different value for a declared dependency around a method call, the method still uses the value supplied when the service was initialized.
+
+**Private initialization state** is the value returned by `initialize`. The method factory receives it, but a caller receives only the methods. Within one provided Layer's lifetime, initialization and the method factory each run once, and two reads of the service share the same state.
+
+**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.
+
+### 1. Define a service and provide its dependencies
+
+```ts
+import { Context, Effect, Layer } from "effect";
+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}`),
+    ),
+  }),
+});
+
+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");
+}).pipe(Effect.provide(live));
+```
+
+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`.
+
+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.
+
+### 2. Annotate generators when inference needs help
+
+For an explicitly annotated `Effect.fn` generator, `ServiceRequirements` expresses the declared services without repeating their union:
+
+```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",
+) {}
+
+const requirements = [Declared] as const;
+
+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;
+    }),
+  }),
+});
+```
+
+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.
+
+### 3. Give method resources a caller scope
+
+```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)),
+  }),
+});
+
+const useResource = Effect.gen(function* () {
+  const resources = yield* Resources;
+  yield* Effect.scoped(resources.open());
+  return yield* resources.released();
+}).pipe(Effect.provide(Resources.layer));
+```
+
+`open()` requires a caller scope. `Effect.scoped` supplies it and closes it before the next method call. The finalizer updates the private counter while the service is still available. An initializer that registers a finalizer instead ties that finalizer to the service Layer's scope.
+
+### Replace a service at an external test boundary
+
+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)),
+});
+```
+
+The replacement provides the public method interface, rather than private initialization state. The compiler rejects a replacement that leaves a required method out. Keep the real service in tests of its behavior; use a replacement where the service represents an external boundary.
+
+### 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:
+
+```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",
+) {}
+
+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 })),
+);
+
+const Generic = defineService({
+  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 }),
+);
+```
+
+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.
+
+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.
+
+### API
+
+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. |
+| `@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. |
+| `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
+```
+
+`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/InitializerProof.d.ts

@@ -0,0 +1,7 @@
+import type { Effect, Scope } from "effect";
+interface InitializerHasUndeclaredServiceRequirements {
+    readonly _serviceDefinitionError: "initializer has service requirements absent from the service declaration";
+}
+export type InitializerProof<TInitializer, TRequirements> = TInitializer extends Effect.Effect<unknown, unknown, infer TResidual> ? [Exclude<TResidual, TRequirements | Scope.Scope>] extends [never] ? TInitializer : InitializerHasUndeclaredServiceRequirements : never;
+export {};
+//# sourceMappingURL=InitializerProof.d.ts.map

package/dist/InitializerProof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializerProof.d.ts","sourceRoot":"","sources":["../src/InitializerProof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE5C,UAAU,2CAA2C;IACpD,QAAQ,CAAC,uBAAuB,EAAE,0EAA0E,CAAC;CAC7G;AAED,MAAM,MAAM,gBAAgB,CAAC,YAAY,EAAE,aAAa,IACvD,YAAY,SAAS,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC,GAClE,CAAC,OAAO,CAAC,SAAS,EAAE,aAAa,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAChE,YAAY,GACZ,2CAA2C,GAC5C,KAAK,CAAC"}

package/dist/InitializerProof.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=InitializerProof.js.map

package/dist/InitializerProof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializerProof.js","sourceRoot":"","sources":["../src/InitializerProof.ts"],"names":[],"mappings":""}

package/dist/MethodProof.d.ts

@@ -0,0 +1,26 @@
+import type { Effect, Scope } from "effect";
+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>>;
+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";
+}
+interface ServiceMembersMustBeMethods {
+    readonly _serviceDefinitionError: "service members must be methods";
+}
+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;
+export type MethodProof<TMethods extends MethodInventory, TRequirements extends RequirementRecord> = {
+    readonly [TName in keyof TMethods]: SupportedMethod<TMethods[TName], TRequirements>;
+};
+export {};
+//# sourceMappingURL=MethodProof.d.ts.map

package/dist/MethodProof.d.ts.map

@@ -0,0 +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"}

package/dist/MethodProof.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=MethodProof.js.map

package/dist/MethodProof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodProof.js","sourceRoot":"","sources":["../src/MethodProof.ts"],"names":[],"mappings":""}

package/dist/RequirementProof.d.ts

@@ -0,0 +1,11 @@
+import type { Context, Scope } from "effect";
+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;
+export type RequirementProof<TRequirements extends RequirementRecord> = {
+    readonly [TIndex in keyof TRequirements]: ProveRequirement<TRequirements[TIndex]>;
+};
+export {};
+//# sourceMappingURL=RequirementProof.d.ts.map

package/dist/RequirementProof.d.ts.map

@@ -0,0 +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"}

package/dist/RequirementProof.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RequirementProof.js.map

package/dist/RequirementProof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequirementProof.js","sourceRoot":"","sources":["../src/RequirementProof.ts"],"names":[],"mappings":""}

package/dist/ServiceRequirements.d.ts

@@ -0,0 +1,5 @@
+import type { Context, Effect, Scope } from "effect";
+export type RequirementRecord = readonly Context.Service.Any[];
+export type RequirementsOf<TRequirements extends RequirementRecord> = Context.Service.Identifier<TRequirements[number]>;
+export type ServiceRequirements<TRequirements extends RequirementRecord, TSuccess, TFailure = never, TCallerScope extends Scope.Scope = never> = Effect.fn.Return<TSuccess, TFailure, RequirementsOf<TRequirements> | TCallerScope>;
+//# sourceMappingURL=ServiceRequirements.d.ts.map

package/dist/ServiceRequirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceRequirements.d.ts","sourceRoot":"","sources":["../src/ServiceRequirements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;AAE/D,MAAM,MAAM,cAAc,CAAC,aAAa,SAAS,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;AAExH,MAAM,MAAM,mBAAmB,CAC9B,aAAa,SAAS,iBAAiB,EACvC,QAAQ,EACR,QAAQ,GAAG,KAAK,EAChB,YAAY,SAAS,KAAK,CAAC,KAAK,GAAG,KAAK,IACrC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,cAAc,CAAC,aAAa,CAAC,GAAG,YAAY,CAAC,CAAC"}

package/dist/ServiceRequirements.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ServiceRequirements.js.map

package/dist/ServiceRequirements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceRequirements.js","sourceRoot":"","sources":["../src/ServiceRequirements.ts"],"names":[],"mappings":""}

package/dist/defineService.d.ts

@@ -0,0 +1,23 @@
+import { Context, Effect, Layer } from "effect";
+import type { GenericMethodDescriptor } from "./genericMethod.ts";
+import type { InitializerProof } from "./InitializerProof.ts";
+import type { MethodInventory, MethodProof } from "./MethodProof.ts";
+import type { RequirementProof } from "./RequirementProof.ts";
+import type { RequirementRecord, RequirementsOf } from "./ServiceRequirements.ts";
+type BoundMethod<TMethod, TRequirements> = TMethod extends (...arguments_: infer TArguments) => Effect.Effect<infer TSuccess, infer TFailure, infer TResidual> ? (...arguments_: TArguments) => Effect.Effect<TSuccess, TFailure, Exclude<TResidual, TRequirements>> : never;
+type PublicMethod<TEntry, TRequirements> = TEntry extends GenericMethodDescriptor<infer TMethod> ? TMethod : BoundMethod<TEntry, TRequirements>;
+type ServiceShape<TMethods extends MethodInventory, TRequirements extends RequirementRecord> = Readonly<{
+    [TName in keyof TMethods]: PublicMethod<TMethods[TName], RequirementsOf<TRequirements>>;
+}>;
+interface ServiceDefinition<TIdentifier extends string, TRequirements extends RequirementRecord, TInitializer extends Effect.Effect<unknown, unknown, unknown>, TMethods extends MethodInventory> {
+    readonly id: TIdentifier;
+    readonly initialize: TInitializer & InitializerProof<TInitializer, RequirementsOf<TRequirements>>;
+    readonly methods: (state: Effect.Success<TInitializer>) => TMethods & MethodProof<NoInfer<TMethods>, TRequirements>;
+    readonly requires: TRequirements & RequirementProof<TRequirements>;
+}
+type DefinedService<TIdentifier extends string, TShape, TFailure, TRequirements> = Context.Service<TIdentifier, TShape> & {
+    readonly layer: Layer.Layer<TIdentifier, TFailure, TRequirements>;
+};
+export declare function defineService<const TIdentifier extends string, const TRequirements extends RequirementRecord, const TInitializer extends Effect.Effect<unknown, unknown, unknown>, const TMethods extends MethodInventory>(definition: ServiceDefinition<TIdentifier, TRequirements, TInitializer, TMethods>): DefinedService<TIdentifier, ServiceShape<TMethods, TRequirements>, Effect.Error<TInitializer>, RequirementsOf<TRequirements>>;
+export {};
+//# sourceMappingURL=defineService.d.ts.map

package/dist/defineService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineService.d.ts","sourceRoot":"","sources":["../src/defineService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AACxD,OAAO,KAAK,EAAa,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAe,eAAe,EAAE,WAAW,EAAwC,MAAM,kBAAkB,CAAC;AACxH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAElF,KAAK,WAAW,CAAC,OAAO,EAAE,aAAa,IAAI,OAAO,SAAS,CAC1D,GAAG,UAAU,EAAE,MAAM,UAAU,KAC3B,MAAM,CAAC,MAAM,CAAC,MAAM,QAAQ,EAAE,MAAM,QAAQ,EAAE,MAAM,SAAS,CAAC,GAChE,CAAC,GAAG,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,GACnG,KAAK,CAAC;AAET,KAAK,YAAY,CAAC,MAAM,EAAE,aAAa,IAAI,MAAM,SAAS,uBAAuB,CAAC,MAAM,OAAO,CAAC,GAAG,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAEhJ,KAAK,YAAY,CAAC,QAAQ,SAAS,eAAe,EAAE,aAAa,SAAS,iBAAiB,IAAI,QAAQ,CAAC;KACtG,KAAK,IAAI,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,aAAa,CAAC,CAAC;CACvF,CAAC,CAAC;AAEH,UAAU,iBAAiB,CAC1B,WAAW,SAAS,MAAM,EAC1B,aAAa,SAAS,iBAAiB,EACvC,YAAY,SAAS,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAC7D,QAAQ,SAAS,eAAe;IAEhC,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,YAAY,GAAG,gBAAgB,CAAC,YAAY,EAAE,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC;IAClG,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,CAAC;IACpH,QAAQ,CAAC,QAAQ,EAAE,aAAa,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;CACnE;AASD,KAAK,cAAc,CAAC,WAAW,SAAS,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IACzH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC;CAClE,CAAC;AAEF,wBAAgB,aAAa,CAC5B,KAAK,CAAC,WAAW,SAAS,MAAM,EAChC,KAAK,CAAC,aAAa,SAAS,iBAAiB,EAC7C,KAAK,CAAC,YAAY,SAAS,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EACnE,KAAK,CAAC,QAAQ,SAAS,eAAe,EAEtC,UAAU,EAAE,iBAAiB,CAAC,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,QAAQ,CAAC,GAC/E,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC,QAAQ,EAAE,aAAa,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC"}

package/dist/defineService.js

@@ -0,0 +1,15 @@
+import { Context, Effect, Layer, Record } from "effect";
+export function defineService(definition) {
+    const service = Context.Service(definition.id);
+    const layer = Layer.effect(service)(Effect.gen(function* () {
+        const ambient = yield* Effect.context();
+        const declared = Context.pick(...definition.requires)(ambient);
+        const state = yield* Effect.provide(definition.initialize, declared);
+        return Record.map(definition.methods(state), (entry) => {
+            const method = typeof entry === "function" ? entry : entry.method;
+            return (...arguments_) => Effect.provide(method(...arguments_), declared);
+        });
+    }));
+    return Object.assign(service, { layer });
+}
+//# sourceMappingURL=defineService.js.map

package/dist/defineService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineService.js","sourceRoot":"","sources":["../src/defineService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAkDxD,MAAM,UAAU,aAAa,CAAS,UAAqC;IAC1E,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAuB,UAAU,CAAC,EAAE,CAAC,CAAC;IACrE,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAClC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,EAAU,CAAC;QAChD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QACrE,OAAO,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,KAAkB,EAAE,EAAE;YACnE,MAAM,MAAM,GAAc,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;YAC7E,OAAO,CAAC,GAAG,UAA4B,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC7F,CAAC,CAAC,CAAC;IACJ,CAAC,CAAC,CACF,CAAC;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;AAC1C,CAAC"}

package/dist/genericMethod.d.ts

@@ -0,0 +1,18 @@
+import type { Effect } from "effect";
+export type AnyMethod = (...arguments_: readonly never[]) => Effect.Effect<unknown, unknown, unknown>;
+export interface GenericMethodDescriptor<TMethod extends AnyMethod> {
+    readonly _tag: "GenericMethod";
+    readonly method: TMethod;
+}
+type Same<TLeft, TRight> = (<TValue>() => TValue extends TLeft ? 1 : 2) extends <TValue>() => (TValue extends TRight ? 1 : 2) ? true : false;
+export type HasDistinctCallSignatures<TMethod> = TMethod extends {
+    (...arguments_: infer TFirstArguments): infer TFirstResult;
+    (...arguments_: infer TLastArguments): infer TLastResult;
+} ? Same<TFirstArguments, TLastArguments> extends true ? Same<TFirstResult, TLastResult> extends true ? false : true : true : false;
+export interface GenericOrStructurallyOverloadedMethodsAreUnsupported {
+    readonly _serviceDefinitionError: "generic and structurally overloaded methods are unsupported";
+}
+type MarkedMethod<TMethod extends AnyMethod> = HasDistinctCallSignatures<TMethod> extends true ? GenericOrStructurallyOverloadedMethodsAreUnsupported : GenericMethodDescriptor<TMethod>;
+export declare function genericMethod<TMethod extends AnyMethod>(method: TMethod): MarkedMethod<TMethod>;
+export {};
+//# sourceMappingURL=genericMethod.d.ts.map

package/dist/genericMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genericMethod.d.ts","sourceRoot":"","sources":["../src/genericMethod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,UAAU,EAAE,SAAS,KAAK,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAEtG,MAAM,WAAW,uBAAuB,CAAC,OAAO,SAAS,SAAS;IACjE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CACzB;AAED,KAAK,IAAI,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC,CAAC,MAAM,OAAO,MAAM,SAAS,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,MAAM,QAAO,MAAM,SAAS,MAAM,GAAG,CAAC,GAAG,CAAC,CAAA,GAAG,IAAI,GAAG,KAAK,CAAC;AAE3I,MAAM,MAAM,yBAAyB,CAAC,OAAO,IAAI,OAAO,SAAS;IAChE,CAAC,GAAG,UAAU,EAAE,MAAM,eAAe,GAAG,MAAM,YAAY,CAAC;IAC3D,CAAC,GAAG,UAAU,EAAE,MAAM,cAAc,GAAG,MAAM,WAAW,CAAC;CACzD,GACE,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,SAAS,IAAI,GACjD,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,SAAS,IAAI,GAC3C,KAAK,GACL,IAAI,GACL,IAAI,GACL,KAAK,CAAC;AAET,MAAM,WAAW,oDAAoD;IACpE,QAAQ,CAAC,uBAAuB,EAAE,6DAA6D,CAAC;CAChG;AAED,KAAK,YAAY,CAAC,OAAO,SAAS,SAAS,IAC1C,yBAAyB,CAAC,OAAO,CAAC,SAAS,IAAI,GAAG,oDAAoD,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC;AAE3I,wBAAgB,aAAa,CAAC,OAAO,SAAS,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC"}

package/dist/genericMethod.js

@@ -0,0 +1,4 @@
+export function genericMethod(method) {
+    return { _tag: "GenericMethod", method };
+}
+//# sourceMappingURL=genericMethod.js.map

package/dist/genericMethod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"genericMethod.js","sourceRoot":"","sources":["../src/genericMethod.ts"],"names":[],"mappings":"AA8BA,MAAM,UAAU,aAAa,CAAC,MAAiB;IAC9C,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,CAAC;AAC1C,CAAC"}

package/package.json

@@ -1,10 +1,71 @@
 {
   "name": "@shivaedev/service",
-  "version": "0.0.0",
-  "description": "Placeholder for the ShivaeDev service package.",
-  "license": "MIT",
+  "version": "0.5.0",
+  "description": "Declared Effect services with scoped initialization and bound dependencies",
+  "keywords": [
+    "effect"
+  ],
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/service#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ShivaeDev/platform.git"
+    "url": "git+https://github.com/ShivaeDev/platform.git",
+    "directory": "packages/service"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    "./*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@effect/vitest": "4.0.5",
+    "@shivaedev/quality": "0.42.0",
+    "@shivaedev/test": "0.10.0",
+    "@shivaedev/test-story": "0.21.0",
+    "@types/node": "24.19.2",
+    "effect": "4.0.5",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "effect": "4.0.5"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
 }

package/src/InitializerProof.ts

@@ -0,0 +1,12 @@
+import type { Effect, Scope } from "effect";
+
+interface InitializerHasUndeclaredServiceRequirements {
+	readonly _serviceDefinitionError: "initializer has service requirements absent from the service declaration";
+}
+
+export type InitializerProof<TInitializer, TRequirements> =
+	TInitializer extends Effect.Effect<unknown, unknown, infer TResidual>
+		? [Exclude<TResidual, TRequirements | Scope.Scope>] extends [never]
+			? TInitializer
+			: InitializerHasUndeclaredServiceRequirements
+		: never;

package/src/MethodProof.ts

@@ -0,0 +1,57 @@
+import type { Effect, Scope } from "effect";
+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>>;
+
+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";
+}
+
+interface ServiceMembersMustBeMethods {
+	readonly _serviceDefinitionError: "service members must be methods";
+}
+
+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;
+
+export type MethodProof<TMethods extends MethodInventory, TRequirements extends RequirementRecord> = {
+	readonly [TName in keyof TMethods]: SupportedMethod<TMethods[TName], TRequirements>;
+};

package/src/RequirementProof.ts

@@ -0,0 +1,16 @@
+import type { Context, Scope } from "effect";
+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;
+
+export type RequirementProof<TRequirements extends RequirementRecord> = {
+	readonly [TIndex in keyof TRequirements]: ProveRequirement<TRequirements[TIndex]>;
+};

package/src/ServiceRequirements.ts

@@ -0,0 +1,12 @@
+import type { Context, Effect, Scope } from "effect";
+
+export type RequirementRecord = readonly Context.Service.Any[];
+
+export type RequirementsOf<TRequirements extends RequirementRecord> = Context.Service.Identifier<TRequirements[number]>;
+
+export type ServiceRequirements<
+	TRequirements extends RequirementRecord,
+	TSuccess,
+	TFailure = never,
+	TCallerScope extends Scope.Scope = never,
+> = Effect.fn.Return<TSuccess, TFailure, RequirementsOf<TRequirements> | TCallerScope>;

package/src/defineService.ts

@@ -0,0 +1,65 @@
+import { Context, Effect, Layer, Record } from "effect";
+import type { AnyMethod, GenericMethodDescriptor } from "./genericMethod.ts";
+import type { InitializerProof } from "./InitializerProof.ts";
+import type { MethodEntry, MethodInventory, MethodProof, MethodRecord, RuntimeMethodInventory } from "./MethodProof.ts";
+import type { RequirementProof } from "./RequirementProof.ts";
+import type { RequirementRecord, RequirementsOf } from "./ServiceRequirements.ts";
+
+type BoundMethod<TMethod, TRequirements> = TMethod extends (
+	...arguments_: infer TArguments
+) => Effect.Effect<infer TSuccess, infer TFailure, infer TResidual>
+	? (...arguments_: TArguments) => Effect.Effect<TSuccess, TFailure, Exclude<TResidual, TRequirements>>
+	: never;
+
+type PublicMethod<TEntry, TRequirements> = TEntry extends GenericMethodDescriptor<infer TMethod> ? TMethod : BoundMethod<TEntry, TRequirements>;
+
+type ServiceShape<TMethods extends MethodInventory, TRequirements extends RequirementRecord> = Readonly<{
+	[TName in keyof TMethods]: PublicMethod<TMethods[TName], RequirementsOf<TRequirements>>;
+}>;
+
+interface ServiceDefinition<
+	TIdentifier extends string,
+	TRequirements extends RequirementRecord,
+	TInitializer extends Effect.Effect<unknown, unknown, unknown>,
+	TMethods extends MethodInventory,
+> {
+	readonly id: TIdentifier;
+	readonly initialize: TInitializer & InitializerProof<TInitializer, RequirementsOf<TRequirements>>;
+	readonly methods: (state: Effect.Success<TInitializer>) => TMethods & MethodProof<NoInfer<TMethods>, TRequirements>;
+	readonly requires: TRequirements & RequirementProof<TRequirements>;
+}
+
+interface RuntimeDefinition<TState> {
+	readonly id: string;
+	readonly initialize: Effect.Effect<TState, unknown, unknown>;
+	readonly methods: (state: TState) => RuntimeMethodInventory;
+	readonly requires: RequirementRecord;
+}
+
+type DefinedService<TIdentifier extends string, TShape, TFailure, TRequirements> = Context.Service<TIdentifier, TShape> & {
+	readonly layer: Layer.Layer<TIdentifier, TFailure, TRequirements>;
+};
+
+export function defineService<
+	const TIdentifier extends string,
+	const TRequirements extends RequirementRecord,
+	const TInitializer extends Effect.Effect<unknown, unknown, unknown>,
+	const TMethods extends MethodInventory,
+>(
+	definition: ServiceDefinition<TIdentifier, TRequirements, TInitializer, TMethods>,
+): DefinedService<TIdentifier, ServiceShape<TMethods, TRequirements>, Effect.Error<TInitializer>, RequirementsOf<TRequirements>>;
+export function defineService<TState>(definition: RuntimeDefinition<TState>): unknown {
+	const service = Context.Service<string, MethodRecord>(definition.id);
+	const layer = Layer.effect(service)(
+		Effect.gen(function* () {
+			const ambient = yield* Effect.context<string>();
+			const declared = Context.pick(...definition.requires)(ambient);
+			const state = yield* Effect.provide(definition.initialize, declared);
+			return Record.map(definition.methods(state), (entry: MethodEntry) => {
+				const method: AnyMethod = typeof entry === "function" ? entry : entry.method;
+				return (...arguments_: readonly never[]) => Effect.provide(method(...arguments_), declared);
+			});
+		}),
+	);
+	return Object.assign(service, { layer });
+}

package/src/genericMethod.ts

@@ -0,0 +1,33 @@
+import type { Effect } from "effect";
+
+export type AnyMethod = (...arguments_: readonly never[]) => Effect.Effect<unknown, unknown, unknown>;
+
+export interface GenericMethodDescriptor<TMethod extends AnyMethod> {
+	readonly _tag: "GenericMethod";
+	readonly method: TMethod;
+}
+
+type Same<TLeft, TRight> = (<TValue>() => TValue extends TLeft ? 1 : 2) extends <TValue>() => TValue extends TRight ? 1 : 2 ? true : false;
+
+export type HasDistinctCallSignatures<TMethod> = TMethod extends {
+	(...arguments_: infer TFirstArguments): infer TFirstResult;
+	(...arguments_: infer TLastArguments): infer TLastResult;
+}
+	? Same<TFirstArguments, TLastArguments> extends true
+		? Same<TFirstResult, TLastResult> extends true
+			? false
+			: true
+		: true
+	: false;
+
+export interface GenericOrStructurallyOverloadedMethodsAreUnsupported {
+	readonly _serviceDefinitionError: "generic and structurally overloaded methods are unsupported";
+}
+
+type MarkedMethod<TMethod extends AnyMethod> =
+	HasDistinctCallSignatures<TMethod> extends true ? GenericOrStructurallyOverloadedMethodsAreUnsupported : GenericMethodDescriptor<TMethod>;
+
+export function genericMethod<TMethod extends AnyMethod>(method: TMethod): MarkedMethod<TMethod>;
+export function genericMethod(method: AnyMethod): unknown {
+	return { _tag: "GenericMethod", method };
+}