vla 0.1.1 → 0.1.2

package/README.md

@@ -1,4 +1,6 @@
-# capsel
+# Vla
+
+_A smooth dutch dessert that goes with everything._
 
 A TypeScript data layer kernel for backend- and fullstack apps. Compatible with whatever framework or library you're using.
 
@@ -13,22 +15,29 @@ A TypeScript data layer kernel for backend- and fullstack apps. Compatible with
 - Tree shakeable
 - Memoziation for Repos
 - request-based context with AsyncLocalStorage
-- 🏗️ first-class context injection
+- first-class context injection
+- 🏗️ auto tracing
+- 🏗️ input validation
+- 🏗️ error handling
 - ...
 
 ## Why?
 
-Many fullstack frameworks lack structure and conventions on the backend side (data layer), but they have lots of good structure and conventions on the frontend side (presentation layer). They are still great frameworks and they all have their own strengths. This is where Capsel comes in. It aims to fill in the missing gap in the data layer, allowing you to write well-structured maintainable, scalable and testable code.
+Many fullstack frameworks lack structure and conventions on the backend side (data layer), but they have lots of good structure and conventions on the frontend side (presentation layer). They are still great frameworks and they all have their own strengths. This is where Vla comes in. It aims to fill in the missing gap in the data layer, allowing you to write well-structured maintainable, scalable and testable code.
 
 ## Usage
 
 ```ts
-import { createModule, Kernel } from "capsel"
+import { Kernel, Vla } from "vla"
 
-// Users
-const UserModule = createModule("User")
+// Create a Users module.
+// Modules are optional and helpful for larger apps.
+// Smaller apps might only need a single module.
+// You can use the provided `Vla.Action`, `Vla.Service` etc as shortcuts
+// instead of creating your own module
+const Users = Vla.createModule("Users")
 
-class ShowUserSettingsAction extends UserModule.Action {
+class ShowUserSettings extends Users.Action {
   users = this.inject(UserService)
 
   async handle(userId: string) {
@@ -40,10 +49,10 @@ class ShowUserSettingsAction extends UserModule.Action {
   }
 }
 
-class UserService extends UserModule.Service {
+class UserService extends Users.Service {
   repo = this.inject(UserRepo)
   billing = this.inject(BillingFacade)
-  ctx = this.inject(Context) // WIP unimplemented
+  session = this.inject(SessionFacade)
 
   async getSettings(userId: string) {
     await canViewProfile(userId)
@@ -57,31 +66,45 @@ class UserService extends UserModule.Service {
     }
   }
 
-  private canViewProfile(userId: string) {
+  private async canViewProfile(userId: string) {
     const isSameUser = this.ctx.currentUser.id !== userId
     if (!isSameUser) throw new Forbidden()
 
     // repo method calls are memoized
     const profile = await this.repo.findById(userId)
+    const currentUser = await this.session.currentUser()
     const isTeamAdmin =
-      this.ctx.currentUser.role === "admin" &&
-      this.ctx.currentUser.teamId === profile.teamId
+      currentUser.role === "admin" &&
+      currentUser.teamId === profile.teamId
 
     if (!isTeamAdmin) throw new Forbidden()
   }
 }
 
-class UserRepo extends UserModule.Repo {
+class SessionFacade extends Users.Service {
+  ctx = this.inject(ReqContext)
+  repo = this.inject(UserRepo)
+
+  async currentUser() {
+    const currentUserId = cookies.userId
+    const user = await this.repo.findById(currentUserId)
+    return user
+  }
+}
+
+class UserRepo extends Users.Repo {
+  db = this.inject(Database)
+
   findById = this.memo((id: string) => {
     // this method is memoized per request.
     // memoized methods can be called like any normal method, but
     // if it's called multiple times with the same args, it's only
     // executed once and the result is cached
-    return db.users.find({ id })
+    return this.db.users.find({ id })
   })
 
   async create(data: UserValues) {
-    const createdUser = await db.users.create({ data })
+    const createdUser = await this.db.users.create({ data })
 
     this.findById.prime(createUser.id).value(createdUser)
     // memoized methods support multiple utilities:
@@ -95,8 +118,21 @@ class UserRepo extends UserModule.Repo {
   }
 }
 
+class Database extends Vla.Resource {
+  static override unwrap = "db"
+  // Unwraps a property when injecting the resource:
+  // When another class injects the database with `this.inject(Database)`,
+  // the `unwrap` will cause that it doesn't return the instance of the
+  // Database class, but the `db` property of it.
+  // This prevents that you have to write stuff like `this.db.db.find()`
+
+  // `Resource` classes are singletons,
+  // so the client this will only be initialized once
+  db = new DbClient()
+}
+
 // Billing
-const BillingModule = createModule("Billing")
+const Billing = Vla.createModule("Billing")
 
 class BillingFacade extends Billing.Facade {
   repo = this.inject(BillingRepo)
@@ -113,10 +149,16 @@ class BillingRepo extends BillingModule.Repo {
   }
 }
 
+// Supports injecting context
+const ReqContext = Vla.createContext<{ cookies: Record<string, unknown> }>()
+
 const kernel = new Kernel()
-kernel.setGlobal() // global instance
+Vla.setGlobalInvokeKernel(kernel) // define as global instance
+
+// just an example. you should use a scoped context instead (see below)
+kernel.context(ReqContext, { cookies: req.cookies })
 
-const settings = await ShowUserSettingsAction.invoke(userId)
+const settings = await ShowUserSettings.invoke(userId)
 // -> { timezone: 'GMT+1', hasSubscription: true }
 ```
 
@@ -124,23 +166,29 @@ const settings = await ShowUserSettingsAction.invoke(userId)
 
 ```tsx
 import { cache } from 'react'
-import { setCurrentKernelFn } from 'capsel'
+import { Vla } from 'vla'
 import { kernel } from '@/data/kernel'
 
 const kernel = new Kernel()
 
-// React's cache() will return a new scoped kernel for each request, giving
-// us a new scoped kernel per request without a middleware
-setCurrentKernelFn(cache(() => kernel.scoped()))
+// React's cache() will return a new scoped kernel for each request
+Vla.setInvokeKernelProvider(cache(() => {
+  return kernel
+    .scoped()
+    .context(ReqContext, {
+      // you can either use await cookies() here or await the promise in Vla
+      cookies: cookies()
+    })
+}))
 
 async function Layout() {
-  const settings = await ShowUserSettingsAction.invoke(userId)
+  const settings = await ShowUserSettings.invoke(userId)
 
   return <div><Page /></div>
 }
 
 async function Page() {
-  const settings = await ShowUserSettingsAction.invoke(userId)
+  const settings = await ShowUserSettings.invoke(userId)
   // it will not query the db twice. it will use the memoized db query
 
   return (
@@ -157,12 +205,12 @@ async function Page() {
 e.g. sveltekit
 
 ```ts
-import { runWithScope } from "capsel"
+import { Vla } from "vla"
 import type { Handle } from "@sveltejs/kit"
 import { kernel } from '@/data/kernel'
 
 export const handle: Handle = async ({ event, resolve }) => {
-  return runWithScope(kernel.scoped(), () => resolve(event))
+  return Vla.withKernel(kernel.scoped(), () => resolve(event))
 }
 
 import { kernel } from '@/data/kernel';
@@ -170,7 +218,7 @@ import type { PageServerLoad } from './$types';
 
 export const load: PageServerLoad = async ({ params }) => {
   return {
-    settings: await ShowUserSettingsAction.invoke(userId)
+    settings: await ShowUserSettings.invoke(userId)
   }
 }
 ```
@@ -178,15 +226,18 @@ export const load: PageServerLoad = async ({ params }) => {
 e.g. express
 
 ```ts
-import { runWithScope } from "capsel"
+import { Vla } from "vla"
 import { kernel } from '@/data/kernel'
 
 const app = express()
 
-express.use((req, res, next) => runWithScope(kernel.scoped(), () => next()))
+express.use((req, res, next) => {
+  const scope = kernel.scoped().context(CustomContext, { req })
+  return Vla.withKernel(scope, () => next())
+})
 
 app.get("/users/:id", async (req, res) => {
-  const settings = await ShowUserSettingsAction.invoke(req.params.id)
+  const settings = await ShowUserSettings.invoke(req.params.id)
   res.json({ data: settings })
 })
 ```
@@ -217,7 +268,13 @@ test("returns some user settings", async () => {
     ),
   )
 
-  await expect(ShowUserSettingsAction.withKernel(kernel).invoke("1")).resolves.toEqual({
+  // mock a context
+  kernel.bindValue(
+    ReqContext,
+    { cookies: { currentUserId: 1 }}
+  )
+
+  await expect(ShowUserSettings.withKernel(kernel).invoke("1")).resolves.toEqual({
     timezone: "faked",
     hasSubscription: true
   })
@@ -230,30 +287,31 @@ There aren't any docs yet. This section is just jotting down some notes for myse
 
 ### When to use modules?
 
-You don't need to create a module for each separate resource. Modules are meant for domain separation, not necessarily for resources. Smaller apps may just need a single `AppModule`. Start with a single AppModule and grow.
+You don't need to create a module for each separate resource. Modules are meant for domain separation, not necessarily for resources. A module can have multiple services, repositories and even multiple facades to separate resources from each other.
 
-A module can have multiple services, repositories and even multiple facades to separate resources from each other.
+Smaller apps may just need a single module for the whole app. You can use `Vla.Action`, `Vla.Repo`, `Vla.Service` etc as a shortcut.
 
 ### What's a facade, when to use it?
 
-Facades are meant as the internal public API to a module, for other modules. When one module wants to call something from another module, it should do so through a facade, and not by deeply calling a service or repository of a module. Even though this adds a layer of indirection, it lets you better differentiate between internal and external concerns of a module, and prevents code dependencies from becoming messy. If you use facades excessively often, your domain modelling could be improved.
+Facades are meant as the internal public API to a module, for other modules.
+
+When one module wants to use something from another module, it should do so by loading a facade, and not by deeply calling a service or repository of a module. Even though this adds a layer of indirection, it lets you better differentiate between internal and external concerns of a module, and prevents code dependencies from becoming messy. If you use facades excessively often, your domain modelling could be improved.
+
+Vla prevents that any module can deeply inject any arbitrary class from another module. It only allows injecting Resources and Facades from other modules.
 
 ### How should I structure files and folders?
 
-Roughly follow how capsel structures your code:
+Roughly follow how Vla structures your code:
 
 - Use separate folders for separate modules
 - Create a separate file for each Service, Repo, Facade, Action
-- You could also have all actions of a resource in a single file
-- If you further want to group files inside a module, do it either by resource (`user`, `post`, etc) or by type (`services`, `repos`, `actions`, etc). Start by having a flat hierarchy with all files of a module in a single folder, and separate into multiple folders once you feel it grew too much.
-
-If you use multiple modules, it's good to separate them into different folders. This allows you to see: if you're importing unproportionally many files from other folders, you have lots of cross-module dependencies, and your data modelling into modules could be improved. 
+- If you further want to group files inside a module, do it either by resource (`user`, `post`, etc) or by type (`services`, `repos`, `actions`, etc). Start by having a flat hierarchy with all files of a module in a single folder, and separate into multiple folders once you feel it grows too much.
 
-"How to structure code into files and folders" is often a question of how to manage code dependencies in a way that scales well. Capsel's structure already manages your code dependencies, so it makes sense to align your files and folders on capsel's structure.
+"How to structure code into files and folders" is often a question of how to manage code dependencies in a way that scales well. Vla's structure already manages your code dependencies, so it makes sense to align your files and folders on Vla's structure.
 
 ### Class scopes
 
-Capsel uses dependency injection to load and use classes in other classes. This means that Capsel creates class instances for you and caches them in different caches for different lifetimes. Whenever you call `inject()`, capsel checks the scope of the class and whether an instance is already cached.
+Vla uses dependency injection to load and use classes in other classes. This means that Vla creates class instances for you and caches them in different caches for different lifetimes. Whenever you call `inject()`, Vla checks the scope of the class and whether an instance is already cached.
 
 There are 3 different scopes:
 
@@ -264,8 +322,9 @@ There are 3 different scopes:
 Example:
 
 ```ts
-class DatabasePool extends MyModule.Singleton {
-  // singletons are cached globally
+class DatabasePool extends MyModule.Resource {
+  // Resources are Singletons.
+  // Singletons are cached globally
   private dbPool: DbPool | null = null
 
   get dbPool() {
@@ -274,14 +333,12 @@ class DatabasePool extends MyModule.Singleton {
 }
 
 class Repo extends MyModule.Repo {
-  // repos are cached per request (`invoke`)
+  // repos are cached per request ("invoke" scope),
+  // so this map will be stateful for the current request scope
+  private cache = Map<string, User>()
 
-  // it will only create the db pool once and reuse it
-  // through the application's whole lifetime
   dbPool = this.inject(DatabasePool)
 
-  private cache = Map<string, User>()
-
   async findById(id: string) {
     const cached = this.cache.get(id)
     if (cached) return cached
@@ -293,8 +350,9 @@ class Repo extends MyModule.Repo {
 }
 
 class ServiceA extends MyModule.Service {
-  // it will use the same instance that ServiceB is also using
   repo = this.inject(Repo)
+  // This repo instance is exactly the same instance as in ServiceB,
+  // so they both share the same `.cache`
 
   async doSomething() {
     await this.repo.findById("1")
@@ -302,8 +360,9 @@ class ServiceA extends MyModule.Service {
 }
 
 class ServiceB extends MyModule.Service {
-  // it will use the same instance that ServiceA is also using
   repo = this.inject(Repo)
+  // This repo instance is exactly the same instance as in ServiceA,
+  // so they both share the same `.cache`
 
   async doOtherThing() {
     await this.repo.findById("1")
@@ -312,20 +371,21 @@ class ServiceB extends MyModule.Service {
 ```
 
 In this example:
-- The Database Pool will only be created once and will be reused forever
-- The Repo is stateful for each request. The Repo cache can be shared across all usages
-- The Services can both call the Repo and use the same instance
+- The `DatabasePool` will only be created once and will be reused forever
+- The `Repo` will be stateful for each request. A new instance will be created for each request, and reused for the lifetime of the request.
+- Both `ServiceA` and `ServiceB` will share the exact same `Repo` instance during a request.
 
 ### Overriding class scopes
 
 ```ts
-class FooClass extends MyModule.Class {
-  static scope = FooClass.SingletonScope
+class FooService extends MyModule.Service {
+  static scope = FooClass.ScopeTransient
+  // Services have a "invoke" scope by default. This overrides it to be
+  // "transient" instead. Transient classes get created separately for
+  // each usage and aren't cached at all.
 }
 ```
 
-You _can_ override the default scope of a Repo, Service, etc. But it's better to create a new BaseClass to not confuse things.
-
 ### Defining scope when injecting a class
 
 Example:
@@ -340,17 +400,18 @@ class FooService extends MyModule.Service {
 }
 ```
 
-This will use a transient version of the FooRepo only for the `FooService`. Meaning this service won't share the same cached version that other services might be using.
+This will use a transient version of the FooRepo only inside the `FooService`. Meaning this service won't share the same cached version that other services might be using.
 
-It's not something you'll likely need to use at all. But this shows how the scope defines how long the instance should be cached and shared.
+It's not something you'll likely need to use often. But this shows how the scope defines how long the instance should be cached and shared.
 
 ### Base classes
 
-Capsel gives you multiple base classes to choose from. You can use them as they are or extend them for your own custom base classes.
+Vla gives you multiple base classes with semantic names. You can use them as they are, or extend them for your own custom base classes.
+
+- `Action` for server-side entry points (scope: `transient`)
+- `Service` for reusable units of code (scope: `invoke`)
+- `Repo` for data access and external adapters (scope: `invoke`)
+- `Resource` for long-lived infrastructure clients such as database pools (scope: `singleton`)
+- `Facade` for the interface of a module for cross-module access (scope: `transient`)
 
-- `Class` is a generic class with scope `transient`
-- `Singleton` is a `Class` with scope `singleton`
-- `Service` is a `Class` with scope `invoke`
-- `Repo` is a `Memoizable(Class)` with scope `invoke`
-- `Facade` is a named alias for `Class`
-- `Action` is a special class with scope `transient`, where you implement a `handle()` function.
+Facades and Actions are similar in the way that they provide an interface into the module. The difference is that Actions are meant to be invoked from outside of a module, while Facades are meant to be called from inside of a module.

package/dist/index.d.mts

@@ -1,11 +1,43 @@
 //#region src/types.d.ts
 type Scope = "singleton" | "invoke" | "transient";
 type InstantiableClass<T> = new () => T;
-//#endregion
-//#region src/kernel.d.ts
 type Token<T = unknown> = InstantiableClass<T> & {
   readonly scope?: Scope;
+  readonly unwrap?: PropertyKey;
+};
+type UnwrapKey<TKey> = TKey extends {
+  readonly unwrap: infer K;
+} ? K extends PropertyKey ? K : never : never;
+type Resolved<TKey extends Token> = [UnwrapKey<TKey>] extends [never] ? InstanceType<TKey> : UnwrapKey<TKey> extends keyof InstanceType<TKey> ? InstanceType<TKey>[UnwrapKey<TKey>] : InstanceType<TKey>;
+type Layer = "service" | "repo" | "action" | "resource" | "context";
+type Visibility = "public" | "private" | "global" | "module";
+type ModuleClass<ModuleName extends string, LayerName extends Layer = Layer, TVisibility extends Visibility = Visibility> = InstantiableClass<unknown> & {
+  readonly __vla_layer: LayerName;
+  readonly __vla_module: ModuleName;
+  readonly __vla_visibility: TVisibility;
+  readonly scope: Scope;
+  readonly unwrap?: PropertyKey;
+  readonly parentLayers: readonly Layer[];
+};
+//#endregion
+//#region src/concerns/memo.d.ts
+type BaseCtor$1<T = object> = abstract new (...args: any[]) => T;
+type ArgsTuple = unknown[];
+type Memoized<Args extends ArgsTuple, R> = ((...args: Args) => R) & {
+  memoized: (...args: Args) => R;
+  fresh: (...args: Args) => R;
+  prime: (...args: Args) => {
+    value: (value: R) => void;
+  };
+  preload: (...args: Args) => R;
+  bust: (...args: Args) => void;
+  bustAll: () => void;
 };
+declare function Memoizable<TBase extends BaseCtor$1>(Base: TBase): ((abstract new (...args: any[]) => {
+  memo<Args extends ArgsTuple, R>(fn: (...args: Args) => R): Memoized<Args, R>;
+}) & TBase) & TBase;
+//#endregion
+//#region src/kernel/kernel.d.ts
 type Ctor<T = unknown> = InstantiableClass<T> & {
   readonly scope?: Scope;
 };
@@ -20,119 +52,256 @@ declare class Kernel {
   });
   private fork;
   private getBinding;
-  bind<T>(key: Token<T>, impl: Ctor<unknown>, scope?: Scope): void;
+  bind<TKey extends Token>(key: TKey, impl: Ctor<unknown>, scope?: Scope): void;
+  bindValue<TKey extends Token>(key: TKey, value: Resolved<TKey>, scope?: Scope): void;
+  context<TKey extends Token>(key: TKey, value: Resolved<TKey>): this;
   resolve<T>(key: Token<T>, scope?: Scope): T;
+  get<T>(key: Token<T>, scope?: Scope): T;
   scoped(): Kernel;
   create<T>(cls: Ctor<T>): T;
   private instantiate;
   private injectInto;
 }
 //#endregion
-//#region src/kernel-als.d.ts
-declare function runWithKernel<T>(scopedKernel: Kernel, fn: () => T): T;
+//#region src/classes/action.d.ts
+declare abstract class BaseAction {
+  static readonly __vla_layer: "action";
+  static readonly __vla_module: string;
+  static readonly __vla_visibility: "private";
+  static readonly scope: "transient";
+  static readonly parentLayers: readonly [];
+  abstract handle(...args: unknown[]): unknown | Promise<unknown>;
+  /** Executes the action with the arguments of the handler. */
+  static invoke<TAction extends BaseAction, TResult = ReturnType<TAction["handle"]>>(this: new () => TAction, ...args: Parameters<TAction["handle"]>): Promise<TResult>;
+  /**
+   * Helper to invoke an action with a kernel instance.
+   * @example
+   * ExampleAction.withKernel(kernel).invoke(...)
+   */
+  static withKernel<TAction extends BaseAction>(this: new () => TAction, kernel: Kernel): {
+    /** Executes the action with the arguments of the handler. */
+    invoke<TResult = ReturnType<TAction["handle"]>>(...args: Parameters<TAction["handle"]>): Promise<TResult>;
+  };
+}
 //#endregion
-//#region src/kernel-current.d.ts
-type CurrentKernelFn = () => Kernel;
-declare function setCurrentKernelFn(fnKernel: CurrentKernelFn): void;
+//#region src/kernel/scoped-als.d.ts
+declare function withKernel<T>(scopedKernel: Kernel, fn: () => T): T;
 //#endregion
-//#region src/kernel-global.d.ts
-declare function setGlobalKernel(kernel: Kernel): void;
+//#region src/kernel/scoped-global.d.ts
+declare function setGlobalInvokeKernel(kernel: Kernel): void;
 //#endregion
-//#region src/memo.d.ts
-type ArgsTuple = unknown[];
-type Memoized<Args extends ArgsTuple, R> = ((...args: Args) => R) & {
-  memoized: (...args: Args) => R;
-  fresh: (...args: Args) => R;
-  prime: (...args: Args) => {
-    value: (value: R) => void;
-  };
-  preload: (...args: Args) => R;
-  bust: (...args: Args) => void;
-  bustAll: () => void;
-};
+//#region src/kernel/scoped-provider.d.ts
+type CurrentKernelFn = () => Kernel | Promise<Kernel>;
+declare function setInvokeKernelProvider(fn: CurrentKernelFn): void;
 //#endregion
-//#region src/modules.d.ts
-declare const BRAND: unique symbol;
-type Layer = "facade" | "service" | "repo" | "action" | "other";
-type Branded<ModuleName extends string, LayerName extends Layer> = {
-  readonly [BRAND]: ClassBrand<ModuleName, LayerName>;
-};
-type Scoped = {
-  readonly scope: Scope;
-};
-type ModuleClass<ModuleName extends string, LayerName extends Layer = Layer> = InstantiableClass<unknown> & Branded<ModuleName, LayerName> & Scoped;
-type LayerOf<T> = T extends ModuleClass<string, infer L> ? L : never;
-type ForbiddenCrossModuleClass = ModuleClass<string, Exclude<Layer, "facade">>;
-type AllowedDependency<ModuleName extends string, Key> = Key extends ModuleClass<ModuleName, Layer> ? Key : Key extends ForbiddenCrossModuleClass ? `Cross-module ${Capitalize<LayerOf<Key>>} injection is not allowed. Use a Facade.` : Key;
-declare class ClassBrand<ModuleName extends string, LayerName extends Layer> {
-  readonly moduleName: ModuleName;
-  readonly layerName: LayerName;
-  constructor(moduleName: ModuleName, layerName: LayerName);
-}
+//#region src/concerns/devstable.d.ts
+type BaseCtor<T = object> = abstract new (...args: any[]) => T;
+declare function DevStable<TBase extends BaseCtor>(Base: TBase): ((abstract new (...args: any[]) => {
+  devStable<T>(key: string, init: () => T): T;
+}) & TBase) & TBase;
+//#endregion
+//#region src/factories/context.d.ts
+type VlaContext<TCtx extends Record<PropertyKey, unknown>> = ModuleClass<"VlaBuiltIn", "context"> & {
+  readonly unwrap: "value";
+  readonly scope: "invoke";
+  readonly __vla_visibility: "global";
+  readonly parentLayers: ["action", "service", "repo", "resource", "context"];
+} & (abstract new (...args: any[]) => {
+  value: TCtx;
+});
+/**
+ * Create a context that can be injected and accessed in all Actions, Services,
+ * Repos, Facades and Resources.
+ * @example
+ * const AppContext = createContext<{ userId: number }>()
+ * const scopedKernel = kernel.scoped().context(AppContext, { userId: 123 })
+ * ExampleAction.withKernel(scopedKernel).invoke()
+ */
+declare function createContext<TCtx extends Record<PropertyKey, unknown>>(): VlaContext<TCtx>;
+//#endregion
+//#region src/factories/module.d.ts
 declare function createModule<const ModuleName extends string>(moduleName: ModuleName): {
   Facade: (abstract new () => {
-    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<ModuleName, Layer> ? "service" extends infer T ? T extends "service" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
   }) & {
-    scope: Scope;
-    readonly [BRAND]: ClassBrand<ModuleName, "facade">;
-    InvokeScope: Scope;
-    TransientScope: Scope;
-    SingletonScope: Scope;
+    readonly __vla_module: ModuleName;
+    readonly __vla_layer: "service";
+    readonly __vla_visibility: "global";
+    readonly scope: Scope;
+    readonly parentLayers: readonly ["action", "service", "repo", "resource"];
+    ScopeInvoke: Scope;
+    ScopeTransient: Scope;
+    ScopeSingleton: Scope;
   };
   Service: (abstract new () => {
-    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<ModuleName, Layer> ? "service" extends infer T ? T extends "service" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
   }) & {
-    scope: Scope;
-    readonly [BRAND]: ClassBrand<ModuleName, "service">;
-    InvokeScope: Scope;
-    TransientScope: Scope;
-    SingletonScope: Scope;
+    readonly __vla_module: ModuleName;
+    readonly __vla_layer: "service";
+    readonly __vla_visibility: "module";
+    readonly scope: Scope;
+    readonly parentLayers: readonly ["action", "service"];
+    ScopeInvoke: Scope;
+    ScopeTransient: Scope;
+    ScopeSingleton: Scope;
   };
   Repo: (abstract new () => {
-    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<ModuleName, Layer> ? "repo" extends infer T ? T extends "repo" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
     memo<Args extends unknown[], R>(fn: (...args: Args) => R): Memoized<Args, R>;
   }) & {
-    scope: Scope;
-    readonly [BRAND]: ClassBrand<ModuleName, "repo">;
+    readonly __vla_module: ModuleName;
+    readonly __vla_layer: "repo";
+    readonly __vla_visibility: "module";
+    readonly scope: Scope;
+    readonly parentLayers: readonly ["action", "service", "repo"];
+    ScopeInvoke: Scope;
+    ScopeTransient: Scope;
+    ScopeSingleton: Scope;
   };
   Action: (abstract new () => {
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<ModuleName, Layer> ? "action" extends infer T ? T extends "action" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
     handle(...args: unknown[]): unknown | Promise<unknown>;
-    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
   }) & {
-    scope: Scope;
-    invoke<TAction extends {
-      handle(...args: unknown[]): unknown | Promise<unknown>;
-      inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
-    }, TResult = ReturnType<TAction["handle"]>>(this: new () => TAction, ...args: Parameters<TAction["handle"]>): TResult;
-    withKernel<TAction extends {
-      handle(...args: unknown[]): unknown | Promise<unknown>;
-      inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
-    }>(this: new () => TAction, kernel: Kernel): {
-      invoke<TResult = ReturnType<TAction["handle"]>>(...args: Parameters<TAction["handle"]>): TResult;
+    readonly __vla_module: ModuleName;
+    readonly __vla_layer: "action";
+    readonly __vla_visibility: "private";
+    readonly scope: "transient";
+    readonly parentLayers: readonly [];
+    invoke<TAction extends BaseAction, TResult = ReturnType<TAction["handle"]>>(this: new () => TAction, ...args: Parameters<TAction["handle"]>): Promise<TResult>;
+    withKernel<TAction extends BaseAction>(this: new () => TAction, kernel: Kernel): {
+      invoke<TResult = ReturnType<TAction["handle"]>>(...args: Parameters<TAction["handle"]>): Promise<TResult>;
     };
-    readonly [BRAND]: ClassBrand<ModuleName, "action">;
-    InvokeScope: Scope;
-    TransientScope: Scope;
-    SingletonScope: Scope;
   };
-  Singleton: (abstract new () => {
-    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+  Resource: (abstract new () => {
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<ModuleName, Layer> ? "resource" extends infer T ? T extends "resource" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
+    devStable<T>(key: string, init: () => T): T;
+  }) & {
+    readonly __vla_module: ModuleName;
+    readonly __vla_layer: "resource";
+    readonly __vla_visibility: "global";
+    readonly scope: Scope;
+    readonly parentLayers: readonly ["action", "service", "repo", "resource"];
+    ScopeInvoke: Scope;
+    ScopeTransient: Scope;
+    ScopeSingleton: Scope;
+  };
+  Memoizable: typeof Memoizable;
+  DevStable: typeof DevStable;
+};
+//#endregion
+//#region src/index.d.ts
+declare const Vla: {
+  createModule: typeof createModule;
+  createContext: typeof createContext;
+  withKernel: typeof withKernel;
+  setGlobalInvokeKernel: typeof setGlobalInvokeKernel;
+  setInvokeKernelProvider: typeof setInvokeKernelProvider;
+  Facade: (abstract new () => {
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<"Vla", Layer> ? "service" extends infer T ? T extends "service" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
+  }) & {
+    readonly __vla_module: "Vla";
+    readonly __vla_layer: "service";
+    readonly __vla_visibility: "global";
+    readonly scope: Scope;
+    readonly parentLayers: readonly ["action", "service", "repo", "resource"];
+    ScopeInvoke: Scope;
+    ScopeTransient: Scope;
+    ScopeSingleton: Scope;
+  };
+  Service: (abstract new () => {
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<"Vla", Layer> ? "service" extends infer T ? T extends "service" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
   }) & {
-    scope: Scope;
-    readonly [BRAND]: ClassBrand<ModuleName, "other">;
-    InvokeScope: Scope;
-    TransientScope: Scope;
-    SingletonScope: Scope;
+    readonly __vla_module: "Vla";
+    readonly __vla_layer: "service";
+    readonly __vla_visibility: "module";
+    readonly scope: Scope;
+    readonly parentLayers: readonly ["action", "service"];
+    ScopeInvoke: Scope;
+    ScopeTransient: Scope;
+    ScopeSingleton: Scope;
+  };
+  Repo: (abstract new () => {
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<"Vla", Layer> ? "repo" extends infer T ? T extends "repo" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
+    memo<Args extends unknown[], R>(fn: (...args: Args) => R): Memoized<Args, R>;
+  }) & {
+    readonly __vla_module: "Vla";
+    readonly __vla_layer: "repo";
+    readonly __vla_visibility: "module";
+    readonly scope: Scope;
+    readonly parentLayers: readonly ["action", "service", "repo"];
+    ScopeInvoke: Scope;
+    ScopeTransient: Scope;
+    ScopeSingleton: Scope;
+  };
+  Action: (abstract new () => {
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<"Vla", Layer> ? "action" extends infer T ? T extends "action" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
+    handle(...args: unknown[]): unknown | Promise<unknown>;
+  }) & {
+    readonly __vla_module: "Vla";
+    readonly __vla_layer: "action";
+    readonly __vla_visibility: "private";
+    readonly scope: "transient";
+    readonly parentLayers: readonly [];
+    invoke<TAction extends BaseAction, TResult = ReturnType<TAction["handle"]>>(this: new () => TAction, ...args: Parameters<TAction["handle"]>): Promise<TResult>;
+    withKernel<TAction extends BaseAction>(this: new () => TAction, kernel: Kernel): {
+      invoke<TResult = ReturnType<TAction["handle"]>>(...args: Parameters<TAction["handle"]>): Promise<TResult>;
+    };
   };
-  Class: (abstract new () => {
-    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+  Resource: (abstract new () => {
+    inject<TKey extends ModuleClass<string>>(key: TKey extends ModuleClass<string, infer TargetLayer extends Layer> ? TKey extends {
+      readonly parentLayers: readonly Layer[];
+    } ? TKey extends ModuleClass<"Vla", Layer> ? "resource" extends infer T ? T extends "resource" ? T extends TKey["parentLayers"][number] ? TKey : `A ${Capitalize<T>} is not allowed to inject a ${Capitalize<TargetLayer>}. Allowed parent layer: ${TKey["parentLayers"][number] extends Layer ? Capitalize<TKey["parentLayers"][number]> : never}` : never : never : TKey extends {
+      readonly __vla_visibility: "global" | "public";
+    } ? TKey : `Cross-module ${Capitalize<TargetLayer>} dependency is not allowed. Use a Facade or Resource.` : never : TKey, scope?: Scope): Resolved<TKey>;
+    devStable<T>(key: string, init: () => T): T;
   }) & {
-    scope: Scope;
-    readonly [BRAND]: ClassBrand<ModuleName, "other">;
-    InvokeScope: Scope;
-    TransientScope: Scope;
-    SingletonScope: Scope;
+    readonly __vla_module: "Vla";
+    readonly __vla_layer: "resource";
+    readonly __vla_visibility: "global";
+    readonly scope: Scope;
+    readonly parentLayers: readonly ["action", "service", "repo", "resource"];
+    ScopeInvoke: Scope;
+    ScopeTransient: Scope;
+    ScopeSingleton: Scope;
   };
+  Memoizable: typeof Memoizable;
+  DevStable: typeof DevStable;
 };
 //#endregion
-export { Kernel, createModule, runWithKernel, setCurrentKernelFn, setGlobalKernel };
+export { InstantiableClass, Kernel, Layer, ModuleClass, Resolved, Scope, Token, UnwrapKey, Visibility, Vla, createContext, createModule, setGlobalInvokeKernel, setInvokeKernelProvider, withKernel };

package/dist/index.mjs

@@ -1,7 +1,39 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import objectHash from "object-hash";
 
-//#region src/dependencies.ts
+//#region src/classes/context.ts
+var BaseContext = class {
+	static __vla_layer = "context";
+	static __vla_module = "VlaBuiltIn";
+	static __vla_visibility = "global";
+	static scope = "invoke";
+	static parentLayers = [
+		"action",
+		"service",
+		"repo",
+		"resource",
+		"context"
+	];
+	static unwrap = "value";
+};
+
+//#endregion
+//#region src/factories/context.ts
+/**
+* Create a context that can be injected and accessed in all Actions, Services,
+* Repos, Facades and Resources.
+* @example
+* const AppContext = createContext<{ userId: number }>()
+* const scopedKernel = kernel.scoped().context(AppContext, { userId: 123 })
+* ExampleAction.withKernel(scopedKernel).invoke()
+*/
+function createContext() {
+	class Context extends BaseContext {}
+	return Context;
+}
+
+//#endregion
+//#region src/lib/tokenizeDeps.ts
 var UnresolvedDependency = class {
 	constructor(token, scope) {
 		this.token = token;
@@ -11,13 +43,13 @@ var UnresolvedDependency = class {
 function tokenizedDependency(defaultClass, scope) {
 	return new UnresolvedDependency(defaultClass, scope);
 }
-function getInjectionPoint(v) {
+function getTokenizedDependency(v) {
 	if (v instanceof UnresolvedDependency) return v;
 	return null;
 }
 
 //#endregion
-//#region src/kernel.ts
+//#region src/kernel/kernel.ts
 var Kernel = class Kernel {
 	singletons = /* @__PURE__ */ new Map();
 	invokeCache = /* @__PURE__ */ new Map();
@@ -37,12 +69,39 @@ var Kernel = class Kernel {
 	bind(key, impl, scope = "transient") {
 		this.singletons.delete(key);
 		this.bindings.set(key, {
+			kind: "class",
 			impl,
 			scope
 		});
 	}
+	bindValue(key, value, scope = "singleton") {
+		this.singletons.delete(key);
+		this.bindings.set(key, {
+			kind: "value",
+			value,
+			scope
+		});
+	}
+	context(key, value) {
+		this.bindValue(key, value, "invoke");
+		return this;
+	}
 	resolve(key, scope) {
 		const binding = this.getBinding(key);
+		if (binding?.kind === "value") {
+			const requestedScope$1 = binding?.scope ?? scope ?? "singleton";
+			if (requestedScope$1 === "singleton") {
+				if (this.root.singletons.has(key)) return this.root.singletons.get(key);
+				this.root.singletons.set(key, binding.value);
+				return binding.value;
+			}
+			if (requestedScope$1 === "invoke" && !!this.parent) {
+				if (this.invokeCache.has(key)) return this.invokeCache.get(key);
+				this.invokeCache.set(key, binding.value);
+				return binding.value;
+			}
+			return binding.value;
+		}
 		const impl = binding?.impl ?? key;
 		const requestedScope = binding?.scope ?? scope ?? impl.scope;
 		if (requestedScope === "singleton") {
@@ -59,6 +118,16 @@ var Kernel = class Kernel {
 		}
 		return this.instantiate(impl);
 	}
+	get(key, scope) {
+		const dependency = this.resolve(key, scope);
+		if (this.getBinding(key)?.kind === "value") return dependency;
+		const unwrapKey = getUnwrapKey(key);
+		if (!unwrapKey) return dependency;
+		if (typeof dependency === "object" && dependency !== null || typeof dependency === "function") {
+			if (unwrapKey in dependency) return dependency[unwrapKey];
+		}
+		return dependency;
+	}
 	scoped() {
 		return this.fork();
 	}
@@ -73,53 +142,195 @@ var Kernel = class Kernel {
 	injectInto(instance) {
 		const obj = instance;
 		Object.entries(obj).map(([key, value]) => {
-			const injectionPoint = getInjectionPoint(value);
+			const injectionPoint = getTokenizedDependency(value);
 			if (!injectionPoint) return null;
 			return [key, injectionPoint];
 		}).filter((entry) => entry !== null).forEach(([key, injectionPoint]) => {
-			obj[key] = this.resolve(injectionPoint.token, injectionPoint.scope);
+			obj[key] = this.get(injectionPoint.token, injectionPoint.scope);
 		});
 	}
 };
+function getUnwrapKey(v) {
+	if (typeof v !== "function" || v === null) return void 0;
+	if (!("unwrap" in v)) return void 0;
+	const k = v.unwrap;
+	return typeof k === "string" || typeof k === "number" || typeof k === "symbol" ? k : void 0;
+}
 
 //#endregion
-//#region src/kernel-als.ts
+//#region src/kernel/scoped-als.ts
 const als = new AsyncLocalStorage();
-function runWithKernel(scopedKernel, fn) {
+function withKernel(scopedKernel, fn) {
 	return als.run(scopedKernel, fn);
 }
-function getAlsKernel() {
+function getAlsInvokeKernel() {
 	return als.getStore() ?? null;
 }
 
 //#endregion
-//#region src/kernel-current.ts
+//#region src/kernel/scoped-global.ts
+let globalKernel = null;
+function setGlobalInvokeKernel(kernel) {
+	globalKernel = kernel;
+}
+function getGlobalKernel() {
+	return globalKernel;
+}
+
+//#endregion
+//#region src/kernel/scoped-provider.ts
 let currentKernelFn = null;
-function setCurrentKernelFn(fnKernel) {
-	currentKernelFn = fnKernel;
+function setInvokeKernelProvider(fn) {
+	currentKernelFn = fn;
 }
-function getCurrentKernelFromFn() {
-	return currentKernelFn?.();
+async function getKernelProvider() {
+	return currentKernelFn ? await currentKernelFn() : void 0;
 }
 
 //#endregion
-//#region src/kernel-global.ts
-let globalKernel = null;
-function setGlobalKernel(kernel) {
-	globalKernel = kernel;
+//#region src/kernel/scoped-invoke.ts
+async function getInvokeKernel() {
+	return await getKernelProvider() ?? getAlsInvokeKernel() ?? getGlobalKernel()?.scoped() ?? new Kernel();
 }
-function getGlobalKernel() {
-	return globalKernel;
+
+//#endregion
+//#region src/classes/action.ts
+var BaseAction = class {
+	static __vla_layer = "action";
+	static __vla_module = "none";
+	static __vla_visibility = "private";
+	static scope = "transient";
+	static parentLayers = [];
+	/** Executes the action with the arguments of the handler. */
+	static async invoke(...args) {
+		return (await getInvokeKernel()).create(this).handle(...args);
+	}
+	/**
+	* Helper to invoke an action with a kernel instance.
+	* @example
+	* ExampleAction.withKernel(kernel).invoke(...)
+	*/
+	static withKernel(kernel) {
+		const ActionClass = this;
+		return { async invoke(...args) {
+			return kernel.scoped().create(ActionClass).handle(...args);
+		} };
+	}
+};
+
+//#endregion
+//#region src/classes/facade.ts
+var BaseFacade = class {
+	static __vla_layer = "service";
+	static __vla_module = "none";
+	static __vla_visibility = "global";
+	static scope = "transient";
+	static parentLayers = [
+		"action",
+		"service",
+		"repo",
+		"resource"
+	];
+	static ScopeInvoke = "invoke";
+	static ScopeTransient = "transient";
+	static ScopeSingleton = "singleton";
+};
+
+//#endregion
+//#region src/classes/repo.ts
+var BaseRepo = class {
+	static __vla_layer = "repo";
+	static __vla_module = "none";
+	static __vla_visibility = "module";
+	static scope = "invoke";
+	static parentLayers = [
+		"action",
+		"service",
+		"repo"
+	];
+	static ScopeInvoke = "invoke";
+	static ScopeTransient = "transient";
+	static ScopeSingleton = "singleton";
+};
+
+//#endregion
+//#region src/classes/resource.ts
+var BaseResource = class {
+	static __vla_layer = "resource";
+	static __vla_module = "none";
+	static __vla_visibility = "global";
+	static scope = "singleton";
+	static parentLayers = [
+		"action",
+		"service",
+		"repo",
+		"resource"
+	];
+	static ScopeInvoke = "invoke";
+	static ScopeTransient = "transient";
+	static ScopeSingleton = "singleton";
+};
+
+//#endregion
+//#region src/classes/service.ts
+var BaseService = class {
+	static __vla_layer = "service";
+	static __vla_module = "none";
+	static __vla_visibility = "module";
+	static scope = "invoke";
+	static parentLayers = ["action", "service"];
+	static ScopeInvoke = "invoke";
+	static ScopeTransient = "transient";
+	static ScopeSingleton = "singleton";
+};
+
+//#endregion
+//#region src/concerns/devstable.ts
+const VLA_DEV_STABLE_PREFIX = "__vla_dev_stable__";
+function isDevStableEnabled() {
+	if (process.env.VLA_DEV_STABLE === "1") return true;
+	return process.env.NODE_ENV !== "production";
+}
+function DevStable(Base) {
+	class DevStableBase extends Base {
+		devStable(key, init) {
+			if (!isDevStableEnabled()) return init();
+			const g = globalThis;
+			const fullKey = `${VLA_DEV_STABLE_PREFIX}${key}`;
+			if (!(fullKey in g)) g[fullKey] = init();
+			return g[fullKey];
+		}
+	}
+	return DevStableBase;
 }
 
 //#endregion
-//#region src/kernel-invoke.ts
-function getInvokeKernel() {
-	return getCurrentKernelFromFn() ?? getAlsKernel() ?? getGlobalKernel()?.scoped() ?? new Kernel();
+//#region src/concerns/injectable.ts
+function createInjectable() {
+	return function Injectable(Base) {
+		class InjectableBase extends Base {
+			inject(key, scope) {
+				const parentClass = this.constructor;
+				const parentModule = parentClass.__vla_module;
+				const parentLayer = parentClass.__vla_layer;
+				const targetKey = key;
+				const targetModule = targetKey.__vla_module;
+				const targetLayer = targetKey.__vla_layer;
+				const targetParentLayers = targetKey.parentLayers;
+				if (!targetParentLayers.includes(parentLayer)) throw new Error(`Layer ${parentLayer} is not allowed to inject ${targetLayer}. Allowed parent layers for ${targetLayer}: ${targetParentLayers.join(", ")}`);
+				if (targetModule !== parentModule) {
+					const targetVisibility = targetKey.__vla_visibility;
+					if (targetVisibility === "private" || targetVisibility === "module") throw new Error(`Cross-module ${targetLayer} dependency is not allowed. Use a Facade or Resource. (Tried to inject a ${targetLayer} from ${targetModule} into ${parentModule})`);
+				}
+				return tokenizedDependency(targetKey, scope ?? targetKey.scope);
+			}
+		}
+		return InjectableBase;
+	};
 }
 
 //#endregion
-//#region src/memo.ts
+//#region src/concerns/memo.ts
 function Memoizable(Base) {
 	class MemoizableBase extends Base {
 		memo(fn) {
@@ -165,67 +376,45 @@ function Memoizable(Base) {
 }
 
 //#endregion
-//#region src/modules.ts
-const BRAND = Symbol("_capsel_brand");
-var ClassBrand = class {
-	constructor(moduleName, layerName) {
-		this.moduleName = moduleName;
-		this.layerName = layerName;
-	}
-};
+//#region src/factories/module.ts
 function createModule(moduleName) {
-	function inject(key, scope) {
-		if (key[BRAND].moduleName !== moduleName && key[BRAND].layerName !== "facade") throw new Error(`Cross-module ${key[BRAND].layerName} dependency is not allowed. Use a Facade. (Tried to inject a ${key[BRAND].layerName} from ${key[BRAND].moduleName} into ${moduleName})`);
-		return tokenizedDependency(key, scope ?? key.scope);
-	}
-	class BaseClass {
-		static InvokeScope = "invoke";
-		static TransientScope = "transient";
-		static SingletonScope = "singleton";
-		inject = inject.bind(this);
-	}
-	class Facade extends BaseClass {
-		static [BRAND] = new ClassBrand(moduleName, "facade");
-		static scope = "transient";
-	}
-	class Service extends BaseClass {
-		static [BRAND] = new ClassBrand(moduleName, "service");
-		static scope = "invoke";
-	}
-	class Repo extends Memoizable(BaseClass) {
-		static [BRAND] = new ClassBrand(moduleName, "repo");
-		static scope = "invoke";
-	}
-	class Action extends BaseClass {
-		static [BRAND] = new ClassBrand(moduleName, "action");
-		static scope = "transient";
-		static invoke(...args) {
-			return getInvokeKernel().create(this).handle(...args);
-		}
-		static withKernel(kernel) {
-			const ActionClass = this;
-			return { invoke(...args) {
-				return kernel.scoped().create(ActionClass).handle(...args);
-			} };
-		}
+	const Injectable = createInjectable();
+	class Facade extends Injectable(BaseFacade) {
+		static __vla_module = moduleName;
+	}
+	class Service extends Injectable(BaseService) {
+		static __vla_module = moduleName;
+	}
+	class Repo extends Injectable(Memoizable(BaseRepo)) {
+		static __vla_module = moduleName;
 	}
-	class Singleton extends BaseClass {
-		static [BRAND] = new ClassBrand(moduleName, "other");
-		static scope = "singleton";
+	class Action extends Injectable(BaseAction) {
+		static __vla_module = moduleName;
 	}
-	class Class extends BaseClass {
-		static [BRAND] = new ClassBrand(moduleName, "other");
-		static scope = "transient";
+	class Resource extends Injectable(DevStable(BaseResource)) {
+		static __vla_module = moduleName;
 	}
 	return {
 		Facade,
 		Service,
 		Repo,
 		Action,
-		Singleton,
-		Class
+		Resource,
+		Memoizable,
+		DevStable
 	};
 }
 
 //#endregion
-export { Kernel, createModule, runWithKernel, setCurrentKernelFn, setGlobalKernel };
+//#region src/index.ts
+const Vla = {
+	...createModule("Vla"),
+	createModule,
+	createContext,
+	withKernel,
+	setGlobalInvokeKernel,
+	setInvokeKernelProvider
+};
+
+//#endregion
+export { Kernel, Vla, createContext, createModule, setGlobalInvokeKernel, setInvokeKernelProvider, withKernel };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "vla",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Data layer kernel for backend- and fullstack apps",
   "author": "Timo Mämecke <hello@timo.wtf>",
   "license": "MIT",
-  "homepage": "https://github.com/timomeh/capsel#readme",
+  "homepage": "https://github.com/timomeh/vla#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/timomeh/capsel.git"
+    "url": "git+https://github.com/timomeh/vla.git"
   },
   "bugs": {
-    "url": "https://github.com/timomeh/capsel/issues"
+    "url": "https://github.com/timomeh/vla/issues"
   },
   "exports": {
     ".": "./dist/index.mjs",