better-effect 0.2.0 → 0.4.0

package/README.md

@@ -1,336 +1,272 @@
 # better-effect
 
-Lightweight Effect-inspired primitives built around [`better-result`](https://www.npmjs.com/package/better-result).
+**Effect-like dependency safety for better-result.**
 
-`better-effect` focuses on a small set of ideas that are useful in application code without bringing in a full effect runtime:
+Type your errors with `better-result`. Typecheck the rest of your application wiring with `better-effect`.
 
-- **Service** — contextual dependency access with `yield*`
-- **Layer** — declarative composition of live/test environments
-- **Resource** — safe acquire/use/release lifecycle
-- **DI adapters** — dependency resolution is delegated to an external container instead of being reimplemented by the library
-
-The goal is not to recreate Effect. The goal is to provide a small, composable layer on top of `better-result`.
-
-## Installation
+Use Services directly inside `Effect.gen`, compose implementations into application environments, and let TypeScript catch missing dependencies before your application starts — while keeping Promises, `better-result`, and your DI backend.
 
 ```bash
 bun add better-effect better-result
 ```
 
-If you want the ITI adapter:
-
-```bash
-bun add iti
-```
-
-## Service
-
-A service is a class that also acts as its own dependency token.
+## TypeScript knows what your application needs
 
 ```ts
 import { Result } from 'better-result'
-import { Service } from 'better-effect'
+import { Effect, Layer, Runtime, Service } from 'better-effect'
 
-export class Database extends Service<Database>() {
-  findUser(email: string) {
-    return Promise.resolve({
-      id: '1',
-      email
-    })
+class Database extends Service<Database>() {
+  findUser(id: string) {
+    // ...
   }
 }
 
-export class UserRepository extends Service<UserRepository>() {
-  findByEmail(email: string) {
-    return Result.gen(async function* () {
+class UserRepository extends Service<UserRepository>() {
+  findUser(id: string) {
+    return Effect.gen(async function* () {
       const database = yield* Database
 
-      const user = await database.findUser(email)
-
-      return Result.ok(user)
+      return Result.ok(await database.findUser(id))
     })
   }
 }
-```
 
-There are no string tokens:
+const UserRepositoryLive = Layer.make(UserRepository, () => new UserRepository())
 
-```ts
-const database = yield * Database
+await Runtime.make(UserRepositoryLive, backend)
+//                 ^^^^^^^^^^^^^^^^^^
+// Type error: Database is required but not provided
 ```
 
-The class itself is the identity used by the resolver, and the result is inferred as `Database`.
+`UserRepository` used `Database`, so `Database` became part of its environment requirements.
 
-### Why classes are tokens
+No dependency list was written manually.
 
-Using constructors directly avoids duplicated identifiers such as:
+Provide it and the environment becomes complete:
 
 ```ts
-Service<AuthService>()('authService')
-```
-
-and prevents string-key collisions or typos.
+const DatabaseLive = Layer.make(Database, () => new Database())
 
-Conceptually:
+const AppLive = Layer.merge(DatabaseLive, UserRepositoryLive)
 
-```text
-yield* AuthService
-        │
-        ▼
-ServiceRuntime
-        │
-        ▼
-ServiceResolver
-        │
-        ▼
-AuthService instance
+const runtime = await Runtime.make(AppLive, backend)
 ```
 
-## Layer
-
-A Layer describes which implementations form an application environment.
+And the contract does not disappear after startup.
 
-It does **not** implement dependency resolution. That remains the responsibility of the configured backend.
+A Runtime also knows which Services exist in its environment:
 
 ```ts
-import { Layer } from 'better-effect'
+await runtime.run(() =>
+  Effect.gen(async function* () {
+    const database = yield* Database
 
-export const DatabaseLive = Layer.scoped(
-  Database,
-  async () => {
-    const database = new Database()
-
-    await database.connect()
-
-    return database
-  },
-  (database) => database.close()
+    return Result.ok(database)
+  })
 )
-
-export const UserRepositoryLive = Layer.make(UserRepository, () => new UserRepository())
-
-export const AppLive = Layer.merge(DatabaseLive, UserRepositoryLive)
 ```
 
-The core Layer API intentionally stays small:
+If a program asks that Runtime for a Service its environment does not provide, TypeScript rejects the call.
 
-```ts
-Layer.make(Service, acquire)
-Layer.succeed(Service, instance)
-Layer.scoped(Service, acquire, release)
-Layer.merge(...layers)
-Layer.override(base, ...overrides)
+```text
+yield* Database
+      │
+      ▼
+program requires Database
+      │
+      ▼
+Layer provides Database?
+      │
+   no ├──────────► TypeScript error
+      │
+     yes
+      ▼
+Runtime can execute it
 ```
 
-### Test environments
+We call this **typechecked wiring**.
 
-Layers make implementation replacement explicit:
+The Services your code uses, the implementations your Layers provide, and the programs your Runtime executes participate in the same type-level contract.
 
-```ts
-const DatabaseTest = Layer.succeed(Database, new InMemoryDatabase())
+---
 
-const AppTest = Layer.override(AppLive, DatabaseTest)
-```
+## Why better-effect?
 
-## ITI adapter
+`better-result` already gives TypeScript applications an excellent model for typed failures.
 
-`better-effect` does not depend on ITI in its core. ITI is just one possible backend.
+But typed errors are only one part of a growing application.
 
-```ts
-import { buildLayer } from 'better-effect'
+Eventually you also need to answer:
 
-import { ItiLayerBackend } from 'better-effect/iti'
+- What does this service depend on?
+- Did the application provide every dependency?
+- Can this program run in this environment?
+- How do I replace implementations in tests?
+- Who owns this database connection?
+- When should this resource be released?
 
-const runtime = await buildLayer(AppLive, new ItiLayerBackend())
+Those problems are often discovered through container errors, startup failures, test setup, or manual composition-root maintenance.
 
-try {
-  await main()
-} finally {
-  await runtime.dispose()
-}
-```
+Effect has powerful ideas for solving them.
 
-This keeps application code independent from the DI container.
+`better-effect` explores a smaller path:
 
-A different backend can implement the same resolver/backend contracts without changing Services or Layers.
+**keep `better-result`, Promises and normal TypeScript — borrow the architectural ideas that make dependencies and resource lifetimes easier to reason about.**
 
-## Resource
+### Know your dependencies before runtime
 
-`Resource.acquireUseRelease()` handles local resource lifecycle while preserving typed `Result` errors.
+Services can be requested directly:
 
 ```ts
-import { Resource } from 'better-effect'
+const database = yield * Database
+```
 
-const result = await Resource.acquireUseRelease({
-  name: 'transaction',
+That access is also captured by the type system.
 
-  acquire: () => database.begin(),
+Layers know both what they provide and what their Services require. Incomplete environments can therefore fail during typechecking instead of application startup.
 
-  use: (transaction) => executeCommand(transaction),
+Runtime keeps that environment information and checks programs against it when they run.
 
-  release: (transaction) => transaction.close()
-})
-```
+### Compose application environments
 
-When `release` is omitted, `Resource` attempts to use the JavaScript explicit resource management protocol:
+Layers describe implementations without making your application code depend on a specific DI container.
 
 ```ts
-Symbol.asyncDispose
-Symbol.dispose
+const AppLive = Layer.merge(DatabaseLive, UserRepositoryLive, AuthServiceLive)
 ```
 
-### Error precedence
-
-If both `use` and `release` fail, the error produced by `use` is preserved.
+Testing can replace implementations explicitly:
 
-The precedence is:
-
-```text
-1. use failure
-2. release failure
-3. successful use value
+```ts
+const AppTest = Layer.override(AppLive, DatabaseTest)
 ```
 
-Acquisition exceptions, rejected promises, and unexpected failures are normalized through `better-result`.
+The environment contract remains typed after the override.
 
-## Service vs Layer vs Resource
+### Own resource lifetimes
 
-| Primitive       | Responsibility                                        |
-| --------------- | ----------------------------------------------------- |
-| `Service`       | Request a contextual dependency                       |
-| `Layer`         | Describe the implementations that form an environment |
-| `Resource`      | Manage a resource local to one operation              |
-| DI backend      | Resolve, cache and dispose service instances          |
-| `better-result` | Typed failures and generator control flow             |
+Some dependencies are values.
 
-## Complete example
+Others own connections, sessions, files or other resources.
 
-The repository contains a TODO API example under:
+`Layer.scoped`, `Layer.scopedGen`, `Effect.acquireRelease`, `Effect.add` and `Scope` make their lifetime explicit.
 
-```text
-examples/todo-api
+```ts
+const DatabaseLive = Layer.scoped(
+  Database,
+  () => Database.connect(),
+  (database) => database.close()
+)
 ```
 
-It demonstrates:
+Runtime owns the application lifetime and safely releases scoped resources when that lifetime ends.
 
-- Bun HTTP server
-- SQLite in memory with `Bun.SQL`
-- user login
-- session authentication
-- TODO CRUD
-- `Service` dependency access
-- Layer composition
-- scoped database lifecycle
-- `Resource.acquireUseRelease()`
-- ITI as the DI backend
+Resources acquired during an individual execution belong to that execution instead.
 
-Run it from the repository root:
+### Keep your runtime choices
 
-```bash
-bun examples/todo-api/index.ts
-```
+`better-effect` is not a replacement implementation of Effect.
 
-## Development
+It does not introduce a fiber runtime, scheduler, streams, queues or a public `Effect<A, E, R>` abstraction.
 
-Install dependencies:
+`Effect.gen` builds on `better-result` generator composition while carrying Service requirements through the TypeScript type system.
 
-```bash
-bun install
-```
+Dependency resolution stays behind a pluggable backend.
 
-Run tests:
+Your application can keep using ordinary Promises and existing libraries.
 
-```bash
-bun test
-```
+---
 
-Typecheck:
+## How it compares
 
-```bash
-bun run typecheck
-```
+|                               | better-result | better-effect       | Effect          |
+| ----------------------------- | ------------- | ------------------- | --------------- |
+| Typed success/failure         | ✓             | ✓ via better-result | ✓               |
+| Generator composition         | ✓             | ✓                   | ✓               |
+| Contextual Services           | —             | ✓                   | ✓               |
+| Dependency requirements       | —             | ✓                   | ✓               |
+| Checked environments          | —             | ✓                   | ✓               |
+| Scoped resource lifetimes     | —             | ✓                   | ✓               |
+| Pluggable external DI backend | —             | ✓                   | different model |
+| Fiber runtime                 | —             | —                   | ✓               |
+| Structured concurrency        | —             | —                   | ✓               |
+| Streams / queues / schedules  | —             | —                   | ✓               |
+| Full effect ecosystem         | —             | —                   | ✓               |
 
-Run the full quality gate:
+### Choose `better-result`
 
-```bash
-bun run check
-```
+When typed error handling and Result composition are enough.
 
-The project uses:
+### Add `better-effect`
 
-- Bun as package manager and test runner
-- TypeScript
-- tsdown for library builds
-- Oxlint
-- Oxfmt
-- publint
+When your Result-based application also needs contextual Services, typechecked application wiring, composable environments, or resource lifetime management.
 
-## Design principles
+### Choose Effect
 
-### Keep the core small
+When you want a complete effect system and its runtime, concurrency model, dependency model, resource management and broader ecosystem.
 
-`better-effect` should not grow into a second Effect runtime.
+`better-effect` is inspired by some of those ideas. It is intentionally not a reimplementation of the whole system.
 
-The core intentionally does not implement:
+---
 
-- fibers
-- schedules
-- streams
-- queues
-- a dependency graph runtime
-- a custom DI container
-- a custom Context
-- a custom Scope runtime
-- `Effect<A, E, R>`
+## Core ideas
 
-### Delegate instead of rebuilding
+### Typechecked wiring
 
-Dependency resolution, caching and container lifecycle belong to DI backends.
+**Service requirements → Layer completeness → Runtime validation**
 
-`better-effect` supplies the protocol and composition primitives.
+Use a Service and its requirement follows the program.
 
-### Preserve inference at public boundaries
+Build an incomplete environment and TypeScript tells you what is missing.
 
-Type safety is part of the API.
+Run a program against an incompatible Runtime and the mismatch remains visible at compile time.
 
-For example:
+### Composable environments
 
-```ts
-const auth = yield * AuthService
-// AuthService
-```
+**Layer → merge → override → DI backend**
 
-and:
+Describe application implementations independently from the container responsible for resolving them.
 
-```ts
-const database = await ServiceRuntime.resolve(Database)
-// Database
-```
+Compose production environments and replace selected implementations for tests.
 
-must preserve exact instance types.
+### Scoped lifetimes
 
-### Type erasure stays internal
+**Scope → scoped Layers → acquire/release → graceful Runtime disposal**
 
-Layers may store heterogeneous providers internally using erased types.
+Make ownership explicit for resources that need cleanup.
 
-The public constructors (`Layer.make`, `Layer.succeed`, `Layer.scoped`) are responsible for preserving the relationship between a Service token and its instance type.
+Application resources live with the Runtime. Execution resources live with the execution.
 
-## Current scope
+### better-result underneath
 
-The project is intentionally small and experimental.
+**Result → Result.gen → Effect.gen → pipe**
 
-The initial scope is:
+Keep `better-result` as the source of truth for typed successes, failures, short-circuiting
+and generator control flow. `Effect.gen` delegates to `Result.gen`; it adds only the
+phantom Service requirements that TypeScript needs to check the application environment.
+At runtime, an `EffectResult` is still a `better-result` Result; the requirements exist
+only in the type.
 
-```text
-Service
-Layer
-Resource
-DI adapters
-better-result integration
-```
+For a linear workflow, `pipe` composes the same kind of program without introducing a
+second Result model or a lazy Effect runtime:
 
-New abstractions should only be added when they solve a concrete problem without duplicating responsibilities already handled well by another library.
+```ts
+import { Effect, pipe } from 'better-effect'
+
+const program = pipe(
+  findUser(id),
+  Effect.map((user: User) => user.email),
+  Effect.andThen(loadPermissions),
+  Effect.mapError((cause: LoadUserError | PermissionError) => new ApplicationError({ cause }))
+)
+```
 
-## License
+The combinators keep the `better-result` semantics: `Effect.map` changes the success
+type, `Effect.mapError` changes the error type, and `Effect.andThen` only calls the next
+step after an `Ok`. The pipeline carries the requirements of every step, so Runtime
+still rejects it when its Layer does not provide every required Service.
 
-MIT
+Use `Effect.gen` for larger workflows with several intermediate values, branches or
+procedural logic. Use `pipe` for concise, linear composition; both are ways to compose
+`better-result` programs while keeping dependency checking in the `better-effect` layer.

package/dist/adapters/iti.d.mts

@@ -1,4 +1,4 @@
-import { r as LayerProvider, s as AnyServiceToken, t as LayerBackend } from "../backend-CNAls62W.mjs";
+import { V as AnyServiceToken, t as LayerBackend, v as LayerProvider } from "../index-BYQKfyeJ.mjs";
 //#region src/adapters/iti.d.ts
 declare class ItiLayerBackend implements LayerBackend {
   private container;

package/dist/adapters/iti.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"iti.d.mts","names":[],"sources":["../../src/adapters/iti.ts"],"mappings":";;cAMa,2BAA2B;UAC9B;mBAES;mBAEA;UAET;UAEA;EAgBR,SAAS,UAAU;EAsBnB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,aAAa,KAAK,YAAY,aAAa;EAUnF,cAAc"}
+{"version":3,"file":"iti.d.mts","names":[],"sources":["../../src/adapters/iti.ts"],"mappings":";;cAMa,2BAA2B;UAC9B;mBAES;mBAEA;UAET;UAEA;EAgBR,SAAS,UAAU;EAgBnB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,aAAa,KAAK,YAAY,aAAa;EAUnF,cAAc"}

package/dist/adapters/iti.mjs

@@ -1,4 +1,4 @@
-import { n as DuplicateServiceError, o as ServiceNotFoundError } from "../errors-CnvKqBpb.mjs";
+import { n as DuplicateServiceError, o as ServiceNotFoundError } from "../errors-DlHCwICc.mjs";
 import { createContainer } from "iti";
 //#region src/adapters/iti.ts
 var ItiLayerBackend = class {
@@ -18,7 +18,6 @@ var ItiLayerBackend = class {
 		if (this.registered.has(token)) throw new DuplicateServiceError(token);
 		const key = this.keyFor(token);
 		this.container = this.container.add({ [key]: provider.acquire });
-		if (provider.release) this.container = this.container.addDisposer({ [key]: provider.release });
 		this.registered.add(token);
 	}
 	resolve(token) {

package/dist/adapters/iti.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"iti.mjs","names":[],"sources":["../../src/adapters/iti.ts"],"sourcesContent":["import { createContainer } from 'iti'\n\nimport { DuplicateServiceError, type LayerBackend, type LayerProvider } from '../layer'\n\nimport { ServiceNotFoundError, type AnyServiceToken } from '../service'\n\nexport class ItiLayerBackend implements LayerBackend {\n  private container: any = createContainer()\n\n  private readonly keys = new WeakMap<AnyServiceToken, string>()\n\n  private readonly registered = new WeakSet<AnyServiceToken>()\n\n  private nextId = 0\n\n  private keyFor(token: AnyServiceToken): string {\n    const existing = this.keys.get(token)\n\n    if (existing) {\n      return existing\n    }\n\n    const name = token.name || 'Service'\n\n    const key = `better-effect:${name}:${this.nextId++}`\n\n    this.keys.set(token, key)\n\n    return key\n  }\n\n  register(provider: LayerProvider): void {\n    const token = provider.service\n\n    if (this.registered.has(token)) {\n      throw new DuplicateServiceError(token)\n    }\n\n    const key = this.keyFor(token)\n\n    this.container = this.container.add({\n      [key]: provider.acquire\n    })\n\n    if (provider.release) {\n      this.container = this.container.addDisposer({\n        [key]: provider.release\n      })\n    }\n\n    this.registered.add(token)\n  }\n\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>> {\n    if (!this.registered.has(token)) {\n      throw new ServiceNotFoundError(token)\n    }\n\n    const key = this.keyFor(token)\n\n    return this.container.get(key) as InstanceType<T> | PromiseLike<InstanceType<T>>\n  }\n\n  async disposeAll(): Promise<void> {\n    await this.container.disposeAll()\n  }\n}\n"],"mappings":";;;AAMA,IAAa,kBAAb,MAAqD;CACnD,YAAyB,gBAAgB;CAEzC,uBAAwB,IAAI,QAAiC;CAE7D,6BAA8B,IAAI,QAAyB;CAE3D,SAAiB;CAEjB,OAAe,OAAgC;EAC7C,MAAM,WAAW,KAAK,KAAK,IAAI,KAAK;EAEpC,IAAI,UACF,OAAO;EAKT,MAAM,MAAM,iBAFC,MAAM,QAAQ,UAEO,GAAG,KAAK;EAE1C,KAAK,KAAK,IAAI,OAAO,GAAG;EAExB,OAAO;CACT;CAEA,SAAS,UAA+B;EACtC,MAAM,QAAQ,SAAS;EAEvB,IAAI,KAAK,WAAW,IAAI,KAAK,GAC3B,MAAM,IAAI,sBAAsB,KAAK;EAGvC,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,KAAK,YAAY,KAAK,UAAU,IAAI,GACjC,MAAM,SAAS,QAClB,CAAC;EAED,IAAI,SAAS,SACX,KAAK,YAAY,KAAK,UAAU,YAAY,GACzC,MAAM,SAAS,QAClB,CAAC;EAGH,KAAK,WAAW,IAAI,KAAK;CAC3B;CAEA,QAAmC,OAA0D;EAC3F,IAAI,CAAC,KAAK,WAAW,IAAI,KAAK,GAC5B,MAAM,IAAI,qBAAqB,KAAK;EAGtC,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,OAAO,KAAK,UAAU,IAAI,GAAG;CAC/B;CAEA,MAAM,aAA4B;EAChC,MAAM,KAAK,UAAU,WAAW;CAClC;AACF"}
+{"version":3,"file":"iti.mjs","names":[],"sources":["../../src/adapters/iti.ts"],"sourcesContent":["import { createContainer } from 'iti'\n\nimport { DuplicateServiceError, type LayerBackend, type LayerProvider } from '../layer'\n\nimport { ServiceNotFoundError, type AnyServiceToken } from '../service'\n\nexport class ItiLayerBackend implements LayerBackend {\n  private container: any = createContainer()\n\n  private readonly keys = new WeakMap<AnyServiceToken, string>()\n\n  private readonly registered = new WeakSet<AnyServiceToken>()\n\n  private nextId = 0\n\n  private keyFor(token: AnyServiceToken): string {\n    const existing = this.keys.get(token)\n\n    if (existing) {\n      return existing\n    }\n\n    const name = token.name || 'Service'\n\n    const key = `better-effect:${name}:${this.nextId++}`\n\n    this.keys.set(token, key)\n\n    return key\n  }\n\n  register(provider: LayerProvider): void {\n    const token = provider.service\n\n    if (this.registered.has(token)) {\n      throw new DuplicateServiceError(token)\n    }\n\n    const key = this.keyFor(token)\n\n    this.container = this.container.add({\n      [key]: provider.acquire\n    })\n\n    this.registered.add(token)\n  }\n\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>> {\n    if (!this.registered.has(token)) {\n      throw new ServiceNotFoundError(token)\n    }\n\n    const key = this.keyFor(token)\n\n    return this.container.get(key) as InstanceType<T> | PromiseLike<InstanceType<T>>\n  }\n\n  async disposeAll(): Promise<void> {\n    await this.container.disposeAll()\n  }\n}\n"],"mappings":";;;AAMA,IAAa,kBAAb,MAAqD;CACnD,YAAyB,gBAAgB;CAEzC,uBAAwB,IAAI,QAAiC;CAE7D,6BAA8B,IAAI,QAAyB;CAE3D,SAAiB;CAEjB,OAAe,OAAgC;EAC7C,MAAM,WAAW,KAAK,KAAK,IAAI,KAAK;EAEpC,IAAI,UACF,OAAO;EAKT,MAAM,MAAM,iBAFC,MAAM,QAAQ,UAEO,GAAG,KAAK;EAE1C,KAAK,KAAK,IAAI,OAAO,GAAG;EAExB,OAAO;CACT;CAEA,SAAS,UAA+B;EACtC,MAAM,QAAQ,SAAS;EAEvB,IAAI,KAAK,WAAW,IAAI,KAAK,GAC3B,MAAM,IAAI,sBAAsB,KAAK;EAGvC,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,KAAK,YAAY,KAAK,UAAU,IAAI,GACjC,MAAM,SAAS,QAClB,CAAC;EAED,KAAK,WAAW,IAAI,KAAK;CAC3B;CAEA,QAAmC,OAA0D;EAC3F,IAAI,CAAC,KAAK,WAAW,IAAI,KAAK,GAC5B,MAAM,IAAI,qBAAqB,KAAK;EAGtC,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,OAAO,KAAK,UAAU,IAAI,GAAG;CAC/B;CAEA,MAAM,aAA4B;EAChC,MAAM,KAAK,UAAU,WAAW;CAClC;AACF"}

package/dist/{errors-CnvKqBpb.mjs → errors-DlHCwICc.mjs}

@@ -51,6 +51,10 @@ var LayerGeneratorYieldError = class extends Error {
 		this.name = "LayerGeneratorYieldError";
 	}
 };
+/**
+* @deprecated The public managed handle is `Runtime`; this error remains for
+* compatibility with low-level Layer integrations.
+*/
 var BuiltLayerDisposedError = class extends Error {
 	constructor() {
 		super("Cannot run a program using a disposed Layer");
@@ -60,4 +64,4 @@ var BuiltLayerDisposedError = class extends Error {
 //#endregion
 export { LayerRegistrationError as a, LayerGeneratorYieldError as i, DuplicateServiceError as n, ServiceNotFoundError as o, LayerDisposeError as r, ServiceRuntimeNotConfiguredError as s, BuiltLayerDisposedError as t };
 
-//# sourceMappingURL=errors-CnvKqBpb.mjs.map
+//# sourceMappingURL=errors-DlHCwICc.mjs.map

package/dist/{errors-CnvKqBpb.mjs.map → errors-DlHCwICc.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"errors-CnvKqBpb.mjs","names":[],"sources":["../src/service/errors.ts","../src/layer/errors.ts"],"sourcesContent":["import type { AnyServiceToken } from './types'\n\nexport class ServiceRuntimeNotConfiguredError extends Error {\n  constructor() {\n    super('No ServiceResolver is available in the current runtime context')\n\n    this.name = 'ServiceRuntimeNotConfiguredError'\n  }\n}\n\nexport class ServiceNotFoundError extends Error {\n  constructor(readonly service: AnyServiceToken) {\n    super(`Service \"${service.name}\" was not provided`)\n\n    this.name = 'ServiceNotFoundError'\n  }\n}\n","import type { ServiceClass } from '../service'\n\nexport class DuplicateServiceError extends Error {\n  constructor(readonly service: ServiceClass<any>) {\n    super(`Duplicate service \"${service.name}\"`)\n\n    this.name = 'DuplicateServiceError'\n  }\n}\n\nexport class LayerRegistrationError extends Error {\n  constructor(\n    readonly service: ServiceClass<any> | undefined,\n    readonly registrationCause: unknown,\n    readonly cleanupCause?: unknown\n  ) {\n    super(service ? `Failed to register service \"${service.name}\"` : 'Failed to build Layer', {\n      cause: registrationCause\n    })\n\n    this.name = 'LayerRegistrationError'\n  }\n}\n\nexport class LayerDisposeError extends Error {\n  constructor(readonly causes: readonly unknown[]) {\n    super(`Failed to dispose Layer (${causes.length} error${causes.length === 1 ? '' : 's'})`)\n\n    this.name = 'LayerDisposeError'\n  }\n}\n\nexport class LayerGeneratorYieldError extends Error {\n  constructor(readonly service: ServiceClass<any>) {\n    super(`Layer.gen(\"${service.name}\") yielded an unsupported value`)\n\n    this.name = 'LayerGeneratorYieldError'\n  }\n}\n\nexport class BuiltLayerDisposedError extends Error {\n  constructor() {\n    super('Cannot run a program using a disposed Layer')\n\n    this.name = 'BuiltLayerDisposedError'\n  }\n}\n"],"mappings":";AAEA,IAAa,mCAAb,cAAsD,MAAM;CAC1D,cAAc;EACZ,MAAM,gEAAgE;EAEtE,KAAK,OAAO;CACd;AACF;AAEA,IAAa,uBAAb,cAA0C,MAAM;CACzB;CAArB,YAAY,SAAmC;EAC7C,MAAM,YAAY,QAAQ,KAAK,mBAAmB;EAD/B,KAAA,UAAA;EAGnB,KAAK,OAAO;CACd;AACF;;;ACdA,IAAa,wBAAb,cAA2C,MAAM;CAC1B;CAArB,YAAY,SAAqC;EAC/C,MAAM,sBAAsB,QAAQ,KAAK,EAAE;EADxB,KAAA,UAAA;EAGnB,KAAK,OAAO;CACd;AACF;AAEA,IAAa,yBAAb,cAA4C,MAAM;CAErC;CACA;CACA;CAHX,YACE,SACA,mBACA,cACA;EACA,MAAM,UAAU,+BAA+B,QAAQ,KAAK,KAAK,yBAAyB,EACxF,OAAO,kBACT,CAAC;EANQ,KAAA,UAAA;EACA,KAAA,oBAAA;EACA,KAAA,eAAA;EAMT,KAAK,OAAO;CACd;AACF;AAEA,IAAa,oBAAb,cAAuC,MAAM;CACtB;CAArB,YAAY,QAAqC;EAC/C,MAAM,4BAA4B,OAAO,OAAO,QAAQ,OAAO,WAAW,IAAI,KAAK,IAAI,EAAE;EADtE,KAAA,SAAA;EAGnB,KAAK,OAAO;CACd;AACF;AAEA,IAAa,2BAAb,cAA8C,MAAM;CAC7B;CAArB,YAAY,SAAqC;EAC/C,MAAM,cAAc,QAAQ,KAAK,gCAAgC;EAD9C,KAAA,UAAA;EAGnB,KAAK,OAAO;CACd;AACF;AAEA,IAAa,0BAAb,cAA6C,MAAM;CACjD,cAAc;EACZ,MAAM,6CAA6C;EAEnD,KAAK,OAAO;CACd;AACF"}
+{"version":3,"file":"errors-DlHCwICc.mjs","names":[],"sources":["../src/service/errors.ts","../src/layer/errors.ts"],"sourcesContent":["import type { AnyServiceToken } from './types'\n\nexport class ServiceRuntimeNotConfiguredError extends Error {\n  constructor() {\n    super('No ServiceResolver is available in the current runtime context')\n\n    this.name = 'ServiceRuntimeNotConfiguredError'\n  }\n}\n\nexport class ServiceNotFoundError extends Error {\n  constructor(readonly service: AnyServiceToken) {\n    super(`Service \"${service.name}\" was not provided`)\n\n    this.name = 'ServiceNotFoundError'\n  }\n}\n","import type { ServiceClass } from '../service'\n\nexport class DuplicateServiceError extends Error {\n  constructor(readonly service: ServiceClass<any>) {\n    super(`Duplicate service \"${service.name}\"`)\n\n    this.name = 'DuplicateServiceError'\n  }\n}\n\nexport class LayerRegistrationError extends Error {\n  constructor(\n    readonly service: ServiceClass<any> | undefined,\n    readonly registrationCause: unknown,\n    readonly cleanupCause?: unknown\n  ) {\n    super(service ? `Failed to register service \"${service.name}\"` : 'Failed to build Layer', {\n      cause: registrationCause\n    })\n\n    this.name = 'LayerRegistrationError'\n  }\n}\n\nexport class LayerDisposeError extends Error {\n  constructor(readonly causes: readonly unknown[]) {\n    super(`Failed to dispose Layer (${causes.length} error${causes.length === 1 ? '' : 's'})`)\n\n    this.name = 'LayerDisposeError'\n  }\n}\n\nexport class LayerGeneratorYieldError extends Error {\n  constructor(readonly service: ServiceClass<any>) {\n    super(`Layer.gen(\"${service.name}\") yielded an unsupported value`)\n\n    this.name = 'LayerGeneratorYieldError'\n  }\n}\n\n/**\n * @deprecated The public managed handle is `Runtime`; this error remains for\n * compatibility with low-level Layer integrations.\n */\nexport class BuiltLayerDisposedError extends Error {\n  constructor() {\n    super('Cannot run a program using a disposed Layer')\n\n    this.name = 'BuiltLayerDisposedError'\n  }\n}\n"],"mappings":";AAEA,IAAa,mCAAb,cAAsD,MAAM;CAC1D,cAAc;EACZ,MAAM,gEAAgE;EAEtE,KAAK,OAAO;CACd;AACF;AAEA,IAAa,uBAAb,cAA0C,MAAM;CACzB;CAArB,YAAY,SAAmC;EAC7C,MAAM,YAAY,QAAQ,KAAK,mBAAmB;EAD/B,KAAA,UAAA;EAGnB,KAAK,OAAO;CACd;AACF;;;ACdA,IAAa,wBAAb,cAA2C,MAAM;CAC1B;CAArB,YAAY,SAAqC;EAC/C,MAAM,sBAAsB,QAAQ,KAAK,EAAE;EADxB,KAAA,UAAA;EAGnB,KAAK,OAAO;CACd;AACF;AAEA,IAAa,yBAAb,cAA4C,MAAM;CAErC;CACA;CACA;CAHX,YACE,SACA,mBACA,cACA;EACA,MAAM,UAAU,+BAA+B,QAAQ,KAAK,KAAK,yBAAyB,EACxF,OAAO,kBACT,CAAC;EANQ,KAAA,UAAA;EACA,KAAA,oBAAA;EACA,KAAA,eAAA;EAMT,KAAK,OAAO;CACd;AACF;AAEA,IAAa,oBAAb,cAAuC,MAAM;CACtB;CAArB,YAAY,QAAqC;EAC/C,MAAM,4BAA4B,OAAO,OAAO,QAAQ,OAAO,WAAW,IAAI,KAAK,IAAI,EAAE;EADtE,KAAA,SAAA;EAGnB,KAAK,OAAO;CACd;AACF;AAEA,IAAa,2BAAb,cAA8C,MAAM;CAC7B;CAArB,YAAY,SAAqC;EAC/C,MAAM,cAAc,QAAQ,KAAK,gCAAgC;EAD9C,KAAA,UAAA;EAGnB,KAAK,OAAO;CACd;AACF;;;;;AAMA,IAAa,0BAAb,cAA6C,MAAM;CACjD,cAAc;EACZ,MAAM,6CAA6C;EAEnD,KAAK,OAAO;CACd;AACF"}