@shivaedev/effect-service 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 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,53 @@
 # @shivaedev/effect-service
 
-This version only reserves the name. Releases are published from https://github.com/ShivaeDev/platform.
+Declare an Effect service's dependencies once. Its Layer initializes private state, binds those dependencies to the public methods, and releases initialization resources when the Layer's scope closes. Methods remain ordinary Effects with their own success and failure types.
+
+```ts
+import { Context, Effect, Layer } from "effect";
+import { defineService } from "@shivaedev/effect-service";
+
+class Prefix extends Context.Service<Prefix, string>()("app/Prefix") {}
+
+const Greetings = defineService({
+  id: "app/Greetings",
+  requires: [Prefix],
+  initialize: Effect.succeed({ punctuation: "!" }),
+  methods: (state) => ({
+    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));
+```
+
+`Greetings` is a native Context service. `Greetings.layer` requires `Prefix`; a resolved service's `greet` method does not. Tests can replace the service directly with `Layer.succeed(Greetings, { greet: ... })`.
+
+## Contract
+
+- `initialize` and ordinary methods may use only declared services, plus `Scope.Scope`.
+- Initialization scope belongs to the Layer. A method's scope belongs to its caller and remains visible in its type. Scope cannot be a declared dependency.
+- Initializer failures remain in the Layer error type; method failures remain on each method.
+- Private initialization state is available to the method factory and is not part of the public service interface.
+- Dependency identifiers must be unique, following normal Effect Context conventions.
+
+For named `Effect.fn` generator return annotations, `ServiceRequirements<typeof requirements, Success, Failure, Scope.Scope>` describes the declared requirements and optional caller scope. It is optional when inference is enough.
+
+## Generic methods
+
+TypeScript cannot generally subtract dependencies from arbitrary generic function signatures without losing their relationships. Services with an empty `requires` list may mark a generic method with `genericMethod(fn)` to preserve its full signature, including caller requirements. Generic methods with declared dependencies and structurally distinct overloads are rejected. Prefer ordinary monomorphic methods for application services.
+
+## Scope
+
+This package only defines services. It does not register RPC operations, manage transactions, add retries, or change Effect's Layer lifetime and memoization rules. It targets the workspace's Effect 4 release candidate; no Effect 3 compatibility is claimed.
+
+## Validation
+
+`pnpm ready` checks formatting, both TypeScript compilers, runtime binding/lifetime behavior, positive and negative compiler fixtures, declaration generation, and an installed tarball consumer. Compiler fixtures cover undeclared dependencies, caller scopes, generic signatures, invalid members, and the public/private boundary.

package/dist/define-service.d.ts

@@ -0,0 +1,23 @@
+import { Context, Effect, Layer } from "effect";
+import type { GenericMethodDescriptor } from "./generic-method.ts";
+import type { InitializerProof } from "./initializer-proof.ts";
+import type { MethodInventory, MethodProof } from "./method-proof.ts";
+import type { RequirementProof } from "./requirement-proof.ts";
+import type { RequirementRecord, RequirementsOf } from "./service-requirements.ts";
+type BoundMethod<Method, Requirements> = Method extends (...arguments_: infer Arguments) => Effect.Effect<infer Success, infer Failure, infer Residual> ? (...arguments_: Arguments) => Effect.Effect<Success, Failure, Exclude<Residual, Requirements>> : never;
+type PublicMethod<Entry, Requirements> = Entry extends GenericMethodDescriptor<infer Method> ? Method : BoundMethod<Entry, Requirements>;
+type ServiceShape<Methods extends MethodInventory, Requirements extends RequirementRecord> = Readonly<{
+    [Name in keyof Methods]: PublicMethod<Methods[Name], RequirementsOf<Requirements>>;
+}>;
+interface ServiceDefinition<Identifier extends string, Requirements extends RequirementRecord, Initializer extends Effect.Effect<unknown, unknown, unknown>, Methods extends MethodInventory> {
+    readonly id: Identifier;
+    readonly initialize: Initializer & InitializerProof<Initializer, RequirementsOf<Requirements>>;
+    readonly methods: (state: Effect.Success<Initializer>) => Methods & MethodProof<NoInfer<Methods>, Requirements>;
+    readonly requires: Requirements & RequirementProof<Requirements>;
+}
+type DefinedService<Identifier extends string, Shape, Failure, Requirements> = Context.Service<Identifier, Shape> & {
+    readonly layer: Layer.Layer<Identifier, Failure, Requirements>;
+};
+export declare function defineService<const Identifier extends string, const Requirements extends RequirementRecord, const Initializer extends Effect.Effect<unknown, unknown, unknown>, const Methods extends MethodInventory>(definition: ServiceDefinition<Identifier, Requirements, Initializer, Methods>): DefinedService<Identifier, ServiceShape<Methods, Requirements>, Effect.Error<Initializer>, RequirementsOf<Requirements>>;
+export {};
+//# sourceMappingURL=define-service.d.ts.map

package/dist/define-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-service.d.ts","sourceRoot":"","sources":["../src/define-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AACxD,OAAO,KAAK,EAAa,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAe,eAAe,EAAE,WAAW,EAAwC,MAAM,mBAAmB,CAAC;AACzH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEnF,KAAK,WAAW,CAAC,MAAM,EAAE,YAAY,IAAI,MAAM,SAAS,CACvD,GAAG,UAAU,EAAE,MAAM,SAAS,KAC1B,MAAM,CAAC,MAAM,CAAC,MAAM,OAAO,EAAE,MAAM,OAAO,EAAE,MAAM,QAAQ,CAAC,GAC7D,CAAC,GAAG,UAAU,EAAE,SAAS,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,GAC9F,KAAK,CAAC;AAET,KAAK,YAAY,CAAC,KAAK,EAAE,YAAY,IAAI,KAAK,SAAS,uBAAuB,CAAC,MAAM,MAAM,CAAC,GAAG,MAAM,GAAG,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;AAEzI,KAAK,YAAY,CAAC,OAAO,SAAS,eAAe,EAAE,YAAY,SAAS,iBAAiB,IAAI,QAAQ,CAAC;KACpG,IAAI,IAAI,MAAM,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC;CAClF,CAAC,CAAC;AAEH,UAAU,iBAAiB,CAC1B,UAAU,SAAS,MAAM,EACzB,YAAY,SAAS,iBAAiB,EACtC,WAAW,SAAS,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAC5D,OAAO,SAAS,eAAe;IAE/B,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,WAAW,GAAG,gBAAgB,CAAC,WAAW,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC;IAC/F,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC;IAChH,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC;CACjE;AASD,KAAK,cAAc,CAAC,UAAU,SAAS,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,GAAG;IACnH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;CAC/D,CAAC;AAEF,wBAAgB,aAAa,CAC5B,KAAK,CAAC,UAAU,SAAS,MAAM,EAC/B,KAAK,CAAC,YAAY,SAAS,iBAAiB,EAC5C,KAAK,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAClE,KAAK,CAAC,OAAO,SAAS,eAAe,EAErC,UAAU,EAAE,iBAAiB,CAAC,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,CAAC,GAC3E,cAAc,CAAC,UAAU,EAAE,YAAY,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC"}

package/dist/define-service.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=define-service.js.map

package/dist/define-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-service.js","sourceRoot":"","sources":["../src/define-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAkDxD,MAAM,UAAU,aAAa,CAAQ,UAAoC;IACxE,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,UAAgC,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC;QACjG,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/generic-method.d.ts

@@ -0,0 +1,18 @@
+import type { Effect } from "effect";
+export type AnyMethod = (...arguments_: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>;
+export interface GenericMethodDescriptor<Method extends AnyMethod> {
+    readonly _tag: "GenericMethod";
+    readonly method: Method;
+}
+type Same<Left, Right> = (<Value>() => Value extends Left ? 1 : 2) extends <Value>() => Value extends Right ? 1 : 2 ? true : false;
+export type HasDistinctCallSignatures<Method> = Method extends {
+    (...arguments_: infer FirstArguments): infer FirstResult;
+    (...arguments_: infer LastArguments): infer LastResult;
+} ? Same<FirstArguments, LastArguments> extends true ? Same<FirstResult, LastResult> extends true ? false : true : true : false;
+export interface GenericOrStructurallyOverloadedMethodsAreUnsupported {
+    readonly _serviceDefinitionError: "generic and structurally overloaded methods are unsupported";
+}
+type MarkedMethod<Method extends AnyMethod> = HasDistinctCallSignatures<Method> extends true ? GenericOrStructurallyOverloadedMethodsAreUnsupported : GenericMethodDescriptor<Method>;
+export declare function genericMethod<Method extends AnyMethod>(method: Method): MarkedMethod<Method>;
+export {};
+//# sourceMappingURL=generic-method.d.ts.map

package/dist/generic-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-method.d.ts","sourceRoot":"","sources":["../src/generic-method.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,UAAU,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAE1G,MAAM,WAAW,uBAAuB,CAAC,MAAM,SAAS,SAAS;IAChE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAED,KAAK,IAAI,CAAC,IAAI,EAAE,KAAK,IAAI,CAAC,CAAC,KAAK,OAAO,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,OAAO,KAAK,SAAS,KAAK,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAEnI,MAAM,MAAM,yBAAyB,CAAC,MAAM,IAAI,MAAM,SAAS;IAC9D,CAAC,GAAG,UAAU,EAAE,MAAM,cAAc,GAAG,MAAM,WAAW,CAAC;IACzD,CAAC,GAAG,UAAU,EAAE,MAAM,aAAa,GAAG,MAAM,UAAU,CAAC;CACvD,GACE,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,SAAS,IAAI,GAC/C,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,SAAS,IAAI,GACzC,KAAK,GACL,IAAI,GACL,IAAI,GACL,KAAK,CAAC;AAET,MAAM,WAAW,oDAAoD;IACpE,QAAQ,CAAC,uBAAuB,EAAE,6DAA6D,CAAC;CAChG;AAED,KAAK,YAAY,CAAC,MAAM,SAAS,SAAS,IACzC,yBAAyB,CAAC,MAAM,CAAC,SAAS,IAAI,GAAG,oDAAoD,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAC;AAEzI,wBAAgB,aAAa,CAAC,MAAM,SAAS,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC"}

package/dist/generic-method.js

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

package/dist/generic-method.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { defineService } from "./define-service.ts";
+export { genericMethod } from "./generic-method.ts";
+export type { ServiceRequirements } from "./service-requirements.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { defineService } from "./define-service.js";
+export { genericMethod } from "./generic-method.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/initializer-proof.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<Initializer, Requirements> = Initializer extends Effect.Effect<unknown, unknown, infer Residual> ? [Exclude<Residual, Requirements | Scope.Scope>] extends [never] ? Initializer : InitializerHasUndeclaredServiceRequirements : never;
+export {};
+//# sourceMappingURL=initializer-proof.d.ts.map

package/dist/initializer-proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializer-proof.d.ts","sourceRoot":"","sources":["../src/initializer-proof.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,WAAW,EAAE,YAAY,IACrD,WAAW,SAAS,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC,GAChE,CAAC,OAAO,CAAC,QAAQ,EAAE,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAC9D,WAAW,GACX,2CAA2C,GAC5C,KAAK,CAAC"}

package/dist/initializer-proof.js

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

package/dist/initializer-proof.js.map

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

package/dist/method-proof.d.ts

@@ -0,0 +1,26 @@
+import type { Effect, Scope } from "effect";
+import type { AnyMethod, GenericMethodDescriptor, GenericOrStructurallyOverloadedMethodsAreUnsupported, HasDistinctCallSignatures } from "./generic-method.ts";
+import type { RequirementRecord, RequirementsOf } from "./service-requirements.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<Method> = Method extends (...arguments_: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, infer Requirements> ? Requirements : 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<Method, Requirements extends RequirementRecord> = [
+    Exclude<MethodRequirements<Method>, RequirementsOf<Requirements> | Scope.Scope>
+] extends [never] ? Method : MethodHasUndeclaredServiceRequirements;
+type SupportedMethod<Method, Requirements extends RequirementRecord> = Method extends GenericMethodDescriptor<AnyMethod> ? Requirements extends readonly [] ? Method : GenericMethodWithDeclaredRequirementsIsUnsupported : Method extends AnyMethod ? HasDistinctCallSignatures<Method> extends true ? GenericOrStructurallyOverloadedMethodsAreUnsupported : Method extends (...arguments_: infer Arguments) => infer Result ? ((...arguments_: Arguments) => Result) extends Method ? OrdinaryMethodProof<Method, Requirements> : GenericOrStructurallyOverloadedMethodsAreUnsupported : GenericOrStructurallyOverloadedMethodsAreUnsupported : ServiceMembersMustBeMethods;
+export type MethodProof<Methods extends MethodInventory, Requirements extends RequirementRecord> = {
+    readonly [Name in keyof Methods]: SupportedMethod<Methods[Name], Requirements>;
+};
+export {};
+//# sourceMappingURL=method-proof.d.ts.map

package/dist/method-proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-proof.d.ts","sourceRoot":"","sources":["../src/method-proof.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,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEnF,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,MAAM,IAAI,MAAM,SAAS,CAAC,GAAG,UAAU,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC,GAC1I,YAAY,GACZ,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,MAAM,EAAE,YAAY,SAAS,iBAAiB,IAAI;IAC1E,OAAO,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;CAC/E,SAAS,CAAC,KAAK,CAAC,GACd,MAAM,GACN,sCAAsC,CAAC;AAE1C,KAAK,eAAe,CAAC,MAAM,EAAE,YAAY,SAAS,iBAAiB,IAClE,MAAM,SAAS,uBAAuB,CAAC,SAAS,CAAC,GAC9C,YAAY,SAAS,SAAS,EAAE,GAC/B,MAAM,GACN,kDAAkD,GACnD,MAAM,SAAS,SAAS,GACvB,yBAAyB,CAAC,MAAM,CAAC,SAAS,IAAI,GAC7C,oDAAoD,GACpD,MAAM,SAAS,CAAC,GAAG,UAAU,EAAE,MAAM,SAAS,KAAK,MAAM,MAAM,GAC9D,CAAC,CAAC,GAAG,UAAU,EAAE,SAAS,KAAK,MAAM,CAAC,SAAS,MAAM,GACpD,mBAAmB,CAAC,MAAM,EAAE,YAAY,CAAC,GACzC,oDAAoD,GACrD,oDAAoD,GACtD,2BAA2B,CAAC;AAEjC,MAAM,MAAM,WAAW,CAAC,OAAO,SAAS,eAAe,EAAE,YAAY,SAAS,iBAAiB,IAAI;IAClG,QAAQ,EAAE,IAAI,IAAI,MAAM,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC;CAC9E,CAAC"}

package/dist/method-proof.js

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

package/dist/method-proof.js.map

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

package/dist/requirement-proof.d.ts

@@ -0,0 +1,11 @@
+import type { Context, Scope } from "effect";
+import type { RequirementRecord } from "./service-requirements.ts";
+interface ScopeCannotBeDeclaredAsAServiceRequirement {
+    readonly _serviceDefinitionError: "Scope.Scope is caller-owned and cannot be declared as a service requirement";
+}
+type ProveRequirement<Requirement> = Requirement extends Context.Service.Any ? Context.Service.Identifier<Requirement> extends Scope.Scope ? ScopeCannotBeDeclaredAsAServiceRequirement : Requirement : never;
+export type RequirementProof<Requirements extends RequirementRecord> = {
+    readonly [Index in keyof Requirements]: ProveRequirement<Requirements[Index]>;
+};
+export {};
+//# sourceMappingURL=requirement-proof.d.ts.map

package/dist/requirement-proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement-proof.d.ts","sourceRoot":"","sources":["../src/requirement-proof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,UAAU,0CAA0C;IACnD,QAAQ,CAAC,uBAAuB,EAAE,6EAA6E,CAAC;CAChH;AAED,KAAK,gBAAgB,CAAC,WAAW,IAAI,WAAW,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG,GACzE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,SAAS,KAAK,CAAC,KAAK,GAC1D,0CAA0C,GAC1C,WAAW,GACZ,KAAK,CAAC;AAET,MAAM,MAAM,gBAAgB,CAAC,YAAY,SAAS,iBAAiB,IAAI;IACtE,QAAQ,EAAE,KAAK,IAAI,MAAM,YAAY,GAAG,gBAAgB,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;CAC7E,CAAC"}

package/dist/requirement-proof.js

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

package/dist/requirement-proof.js.map

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

package/dist/service-requirements.d.ts

@@ -0,0 +1,5 @@
+import type { Context, Effect, Scope } from "effect";
+export type RequirementRecord = ReadonlyArray<Context.Service.Any>;
+export type RequirementsOf<Requirements extends RequirementRecord> = Context.Service.Identifier<Requirements[number]>;
+export type ServiceRequirements<Requirements extends RequirementRecord, Success, Failure = never, CallerScope extends Scope.Scope = never> = Effect.fn.Return<Success, Failure, RequirementsOf<Requirements> | CallerScope>;
+//# sourceMappingURL=service-requirements.d.ts.map

package/dist/service-requirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-requirements.d.ts","sourceRoot":"","sources":["../src/service-requirements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;AAEnE,MAAM,MAAM,cAAc,CAAC,YAAY,SAAS,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;AAEtH,MAAM,MAAM,mBAAmB,CAC9B,YAAY,SAAS,iBAAiB,EACtC,OAAO,EACP,OAAO,GAAG,KAAK,EACf,WAAW,SAAS,KAAK,CAAC,KAAK,GAAG,KAAK,IACpC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,CAAC,YAAY,CAAC,GAAG,WAAW,CAAC,CAAC"}

package/dist/service-requirements.js

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

package/dist/service-requirements.js.map

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

package/package.json

@@ -1,14 +1,59 @@
 {
   "name": "@shivaedev/effect-service",
-  "version": "0.0.0",
-  "description": "Name reservation. The first release is published from https://github.com/ShivaeDev/platform.",
+  "version": "0.1.0",
+  "description": "Declared Effect services with scoped initialization and bound dependencies",
+  "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShivaeDev/platform.git",
     "directory": "packages/effect-service"
   },
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-service#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/node": "24.10.1",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "effect": "4.0.0-rc.112",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vitest": "4.1.9"
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "check": "biome check .",
+    "test": "vitest run",
+    "test:package": "node scripts/test-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "typecheck:compat": "tsc6 --noEmit",
+    "ready": "pnpm check && pnpm typecheck && pnpm typecheck:compat && pnpm test && pnpm build && pnpm test:package"
   }
-}
+}

package/src/define-service.ts

@@ -0,0 +1,65 @@
+import { Context, Effect, Layer, Record } from "effect";
+import type { AnyMethod, GenericMethodDescriptor } from "./generic-method.ts";
+import type { InitializerProof } from "./initializer-proof.ts";
+import type { MethodEntry, MethodInventory, MethodProof, MethodRecord, RuntimeMethodInventory } from "./method-proof.ts";
+import type { RequirementProof } from "./requirement-proof.ts";
+import type { RequirementRecord, RequirementsOf } from "./service-requirements.ts";
+
+type BoundMethod<Method, Requirements> = Method extends (
+	...arguments_: infer Arguments
+) => Effect.Effect<infer Success, infer Failure, infer Residual>
+	? (...arguments_: Arguments) => Effect.Effect<Success, Failure, Exclude<Residual, Requirements>>
+	: never;
+
+type PublicMethod<Entry, Requirements> = Entry extends GenericMethodDescriptor<infer Method> ? Method : BoundMethod<Entry, Requirements>;
+
+type ServiceShape<Methods extends MethodInventory, Requirements extends RequirementRecord> = Readonly<{
+	[Name in keyof Methods]: PublicMethod<Methods[Name], RequirementsOf<Requirements>>;
+}>;
+
+interface ServiceDefinition<
+	Identifier extends string,
+	Requirements extends RequirementRecord,
+	Initializer extends Effect.Effect<unknown, unknown, unknown>,
+	Methods extends MethodInventory,
+> {
+	readonly id: Identifier;
+	readonly initialize: Initializer & InitializerProof<Initializer, RequirementsOf<Requirements>>;
+	readonly methods: (state: Effect.Success<Initializer>) => Methods & MethodProof<NoInfer<Methods>, Requirements>;
+	readonly requires: Requirements & RequirementProof<Requirements>;
+}
+
+interface RuntimeDefinition<State> {
+	readonly id: string;
+	readonly initialize: Effect.Effect<State, unknown, unknown>;
+	readonly methods: (state: State) => RuntimeMethodInventory;
+	readonly requires: RequirementRecord;
+}
+
+type DefinedService<Identifier extends string, Shape, Failure, Requirements> = Context.Service<Identifier, Shape> & {
+	readonly layer: Layer.Layer<Identifier, Failure, Requirements>;
+};
+
+export function defineService<
+	const Identifier extends string,
+	const Requirements extends RequirementRecord,
+	const Initializer extends Effect.Effect<unknown, unknown, unknown>,
+	const Methods extends MethodInventory,
+>(
+	definition: ServiceDefinition<Identifier, Requirements, Initializer, Methods>,
+): DefinedService<Identifier, ServiceShape<Methods, Requirements>, Effect.Error<Initializer>, RequirementsOf<Requirements>>;
+export function defineService<State>(definition: RuntimeDefinition<State>): 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_: ReadonlyArray<never>) => Effect.provide(method(...arguments_), declared);
+			});
+		}),
+	);
+	return Object.assign(service, { layer });
+}

package/src/generic-method.ts

@@ -0,0 +1,33 @@
+import type { Effect } from "effect";
+
+export type AnyMethod = (...arguments_: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>;
+
+export interface GenericMethodDescriptor<Method extends AnyMethod> {
+	readonly _tag: "GenericMethod";
+	readonly method: Method;
+}
+
+type Same<Left, Right> = (<Value>() => Value extends Left ? 1 : 2) extends <Value>() => Value extends Right ? 1 : 2 ? true : false;
+
+export type HasDistinctCallSignatures<Method> = Method extends {
+	(...arguments_: infer FirstArguments): infer FirstResult;
+	(...arguments_: infer LastArguments): infer LastResult;
+}
+	? Same<FirstArguments, LastArguments> extends true
+		? Same<FirstResult, LastResult> extends true
+			? false
+			: true
+		: true
+	: false;
+
+export interface GenericOrStructurallyOverloadedMethodsAreUnsupported {
+	readonly _serviceDefinitionError: "generic and structurally overloaded methods are unsupported";
+}
+
+type MarkedMethod<Method extends AnyMethod> =
+	HasDistinctCallSignatures<Method> extends true ? GenericOrStructurallyOverloadedMethodsAreUnsupported : GenericMethodDescriptor<Method>;
+
+export function genericMethod<Method extends AnyMethod>(method: Method): MarkedMethod<Method>;
+export function genericMethod(method: AnyMethod): unknown {
+	return { _tag: "GenericMethod", method };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { defineService } from "./define-service.ts";
+export { genericMethod } from "./generic-method.ts";
+export type { ServiceRequirements } from "./service-requirements.ts";

package/src/initializer-proof.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<Initializer, Requirements> =
+	Initializer extends Effect.Effect<unknown, unknown, infer Residual>
+		? [Exclude<Residual, Requirements | Scope.Scope>] extends [never]
+			? Initializer
+			: InitializerHasUndeclaredServiceRequirements
+		: never;

package/src/method-proof.ts

@@ -0,0 +1,57 @@
+import type { Effect, Scope } from "effect";
+import type {
+	AnyMethod,
+	GenericMethodDescriptor,
+	GenericOrStructurallyOverloadedMethodsAreUnsupported,
+	HasDistinctCallSignatures,
+} from "./generic-method.ts";
+import type { RequirementRecord, RequirementsOf } from "./service-requirements.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<Method> = Method extends (...arguments_: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, infer Requirements>
+	? Requirements
+	: 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<Method, Requirements extends RequirementRecord> = [
+	Exclude<MethodRequirements<Method>, RequirementsOf<Requirements> | Scope.Scope>,
+] extends [never]
+	? Method
+	: MethodHasUndeclaredServiceRequirements;
+
+type SupportedMethod<Method, Requirements extends RequirementRecord> =
+	Method extends GenericMethodDescriptor<AnyMethod>
+		? Requirements extends readonly []
+			? Method
+			: GenericMethodWithDeclaredRequirementsIsUnsupported
+		: Method extends AnyMethod
+			? HasDistinctCallSignatures<Method> extends true
+				? GenericOrStructurallyOverloadedMethodsAreUnsupported
+				: Method extends (...arguments_: infer Arguments) => infer Result
+					? ((...arguments_: Arguments) => Result) extends Method
+						? OrdinaryMethodProof<Method, Requirements>
+						: GenericOrStructurallyOverloadedMethodsAreUnsupported
+					: GenericOrStructurallyOverloadedMethodsAreUnsupported
+			: ServiceMembersMustBeMethods;
+
+export type MethodProof<Methods extends MethodInventory, Requirements extends RequirementRecord> = {
+	readonly [Name in keyof Methods]: SupportedMethod<Methods[Name], Requirements>;
+};

package/src/requirement-proof.ts

@@ -0,0 +1,16 @@
+import type { Context, Scope } from "effect";
+import type { RequirementRecord } from "./service-requirements.ts";
+
+interface ScopeCannotBeDeclaredAsAServiceRequirement {
+	readonly _serviceDefinitionError: "Scope.Scope is caller-owned and cannot be declared as a service requirement";
+}
+
+type ProveRequirement<Requirement> = Requirement extends Context.Service.Any
+	? Context.Service.Identifier<Requirement> extends Scope.Scope
+		? ScopeCannotBeDeclaredAsAServiceRequirement
+		: Requirement
+	: never;
+
+export type RequirementProof<Requirements extends RequirementRecord> = {
+	readonly [Index in keyof Requirements]: ProveRequirement<Requirements[Index]>;
+};

package/src/service-requirements.ts

@@ -0,0 +1,12 @@
+import type { Context, Effect, Scope } from "effect";
+
+export type RequirementRecord = ReadonlyArray<Context.Service.Any>;
+
+export type RequirementsOf<Requirements extends RequirementRecord> = Context.Service.Identifier<Requirements[number]>;
+
+export type ServiceRequirements<
+	Requirements extends RequirementRecord,
+	Success,
+	Failure = never,
+	CallerScope extends Scope.Scope = never,
+> = Effect.fn.Return<Success, Failure, RequirementsOf<Requirements> | CallerScope>;