@owlmeans/context 0.1.18-rc.3 → 0.1.18-rc.31

package/README.md

@@ -1,95 +1,300 @@
 # @owlmeans/context
 
-Lightweight dependency injection and service lifecycle management for fullstack OwlMeans applications.
-
-## Overview
-
-- Context holds services, modules, and resources; passed top-down through the app
-- Services are registered by alias and retrieved via `context.service(alias)`
-- Supports layered contexts (System → Global → Service → Entity → User) for multi-tenant apps
-- Route constants (`ROOT`, `HOME`, `GUEST`, `BASE`) are used by the module system across all packages
+Lightweight dependency injection and service lifecycle for fullstack OwlMeans applications. An app
+uses it to author its own services (`createService`, `createLazyService`), to type its context and
+config, and to look up services, resources and entrypoints at runtime. An app almost never calls
+`makeBasicContext` or `makeBasicConfig` itself — it builds its context with the layer factory
+(`makeContext` from `@owlmeans/server-app` or `@owlmeans/web-panel`, `makeClientContext` from
+`@owlmeans/client-context`) and its config with `config()` from `@owlmeans/config` or the layer
+config package. Protocol declarations live in `@owlmeans/entrypoint`; data access contracts live in
+`@owlmeans/resource`.
 
 ## Installation
 
 ```bash
-bun add @owlmeans/context
+bun add @owlmeans/context@^0.1.18-rc.31
 ```
 
+## Concepts
+
+- **Context** — the DI container: three flat registries (services, resources, entrypoints) keyed
+  by alias, plus a middleware table. One context is built per process by one factory; there is no
+  child context and nothing is stored for re-creation.
+- **Contextual** — any object carrying `alias`, `registerContext` and `assertCtx`. It binds to
+  exactly one context, the first one that registers it.
+- **Service** — a contextual with an initialization state. `createService` gets an eager `init()`
+  run during `context.init()`; `createLazyService` gets `lazyInit()` started on first lookup.
+  Both expose `ready()`.
+- **Stage** — `ContextStage.Configuration` → `Loading` (after `configure()`) → `Ready` (after
+  `init()` resolves). `waitForConfigured()` / `waitForInitialized()` resolve at those points.
+- **Middleware** — a hook keyed by `MiddlewareType` (`Config` / `Context`) and `MiddlewareStage`,
+  applied at fixed points of the lifecycle (see Usage 4).
+- **`append*` mixin** — an idempotent function that registers a service, resource or middleware on
+  a context, optionally adds a typed accessor, and returns the same context. Layer factories are
+  compositions of these.
+
 ## Usage
 
-Creating and registering a service:
+### 1. Author a service
 
-```typescript
+`createService` wraps a partial implementation with `alias`, `initialized`, `init`, `ready` and the
+contextual helpers. Inside methods, `service.assertCtx()` returns the context it was registered in.
+
+```ts
 import { createService } from '@owlmeans/context'
+import type { InitializedService } from '@owlmeans/context'
+import type { AppConfig, AppContext } from '../types.js'
+
+export const INVOICE_SERVICE = 'invoice'
 
-export const makeIamService = (alias: string = IAM_SERVICE) => {
-  const service = createService<IamService>(alias, {
-    getEntityAdminConfig: async (entityId) => {
-      const ctx = service.assertCtx<Config, Context>()
-      return ctx.service<KeycloakService>(KC_SERVICE).getConfig(entityId)
-    }
+export interface InvoiceService extends InitializedService {
+  total: (projectId: string) => Promise<number>
+}
+
+export const makeInvoiceService = (alias: string = INVOICE_SERVICE): InvoiceService => {
+  const service: InvoiceService = createService<InvoiceService>(alias, {
+    total: async projectId => {
+      const ctx = service.assertCtx<AppConfig, AppContext>()
+      const { items } = await ctx.invoices().list({ projectId })
+
+      return items.reduce((sum, invoice) => sum + invoice.amount, 0)
+    },
   })
+
   return service
 }
 ```
 
-Registering and retrieving services from context:
+A custom initializer is the third argument. It receives the service and returns the async function
+`context.init()` runs — and it must set `initialized` itself:
 
-```typescript
-const context = makeBasicContext(config)
-context.registerService(makeIamService())
+```ts
+export const makeReminderService = (alias: string = 'reminder'): ReminderService =>
+  createService<ReminderService>(alias, { staleAfter: () => STALE_AFTER_MS }, service => async () => {
+    // open connections, start timers, read config — then mark the service usable
+    service.initialized = true
+  })
+```
+
+### 2. Register it through an `append*` mixin
+
+The mixin registers the service, adds a typed accessor and returns the same context. The app's
+factory calls the factory of the layer below and then its own mixins.
+
+```ts
+import type { BasicConfig, BasicContext } from '@owlmeans/context'
+import { makeContext as makeServerContext } from '@owlmeans/server-app'
+
+export interface WithInvoiceService {
+  invoice: () => InvoiceService
+}
+
+export const appendInvoiceService = <C extends BasicConfig, T extends BasicContext<C>>(
+  ctx: T, alias: string = INVOICE_SERVICE
+): T & WithInvoiceService => {
+  const context = ctx as T & WithInvoiceService
+  if (!context.hasService(alias)) {
+    context.registerService(makeInvoiceService(alias))
+  }
+  context.invoice = () => context.service(alias)
+
+  return context
+}
 
+export const makeContext = <C extends AppConfig, T extends AppContext<C>>(cfg: C): T => {
+  const context = makeServerContext<C, T>(cfg)
+  appendInvoiceService<C, T>(context)
+
+  return context
+}
+
+const context = makeContext(config)
 await context.configure().init()
 
-const iamService = context.service<IamService>(IAM_SERVICE)
+await context.invoice().total(projectId)
 ```
 
-## API
+### 3. Look things up
 
-### `createService<S>(alias, implementation): S`
+`service`, `resource` and `entrypoint` throw a `SyntaxError` when the alias is not registered; use
+the `has*` predicates for optional collaborators. Entrypoints are looked up by the shared protocol
+declaration, which also supplies request and response types.
 
-Creates a service registered under `alias`. Inside method implementations, call `service.assertCtx()` to get the current context.
+```ts
+import { projectProtocols } from 'my-app-common'
 
-### `createLazyService<S>(alias, implementation): S`
+const project = await context.entrypoint(projectProtocols.get).call({
+  params: { id },
+})
 
-Like `createService` but initialized on first access via `lazyInit()`.
+const policy = context.hasService(RELEASE_POLICY)
+  ? context.service<ReleasePolicy>(RELEASE_POLICY)
+  : null
 
-### `appendContextual(alias, obj): Contextual`
+const cache = context.resource<Resource<ProjectRecord>>(PROJECT_CACHE)
+```
 
-Wraps a plain object as a contextual entity (adds `registerContext`, `assertCtx`, etc.).
+### 4. Lazy services and lifecycle hooks
 
-### `assertContext(ctx, location?): T`
+A lazy service starts `lazyInit()` the first time `context.service(alias)` returns it and does not
+wait for it, so its methods await `ready()` first:
 
-Asserts that a context is defined; throws if not.
+```ts
+import { createLazyService } from '@owlmeans/context'
+import type { GateService } from '@owlmeans/entrypoint'
+
+export const makeProjectGate = (alias: string = PROJECT_GATE): GateService => {
+  const service: GateService = createLazyService<GateService>(alias, {
+    assert: async (req, _res, params) => {
+      await service.ready()
+      const ctx = service.assertCtx<AppConfig, AppContext>()
+      // ... check req.auth against params using ctx resources
+    },
+  })
+
+  return service
+}
+```
 
-### `makeBasicContext<C>(cfg): BasicContext<C>`
+Middlewares run at fixed points:
+
+| When | Type / stage |
+|------|--------------|
+| `configure()` | `Config` / `Configuration` |
+| `init()`, before services | `Context` / `Configuration` |
+| after every eager `service.init()` | `Config` / `Loading` |
+| after every `resource.init()` | `Context` / `Loading` |
+| after the stage becomes `Ready` (not awaited) | `Context` / `Ready` |
+
+`Context` / `Loading` is the moment services are initialized but nothing has started listening yet —
+the place to mount a raw server route:
+
+```ts
+import { MiddlewareStage, MiddlewareType } from '@owlmeans/context'
+
+export const appendHealthEndpoint = <C extends AppConfig, T extends AppContext<C>>(context: T): T => {
+  context.registerMiddleware({
+    type: MiddlewareType.Context,
+    stage: MiddlewareStage.Loading,
+    apply: async ctx => {
+      const server = (ctx as unknown as T).getApiServer().server
+      server.route({ method: 'GET', url: '/healthz', handler: async () => ({ ok: true }) })
+    },
+  })
 
-Creates a context from a config object. Rarely used directly — prefer the higher-level `makeContext` from `@owlmeans/server-app` or `@owlmeans/client-context`.
+  return context
+}
+```
 
-### Enums
+Work that needs the whole context ready without blocking the factory hangs off
+`waitForInitialized()`:
 
-```typescript
-enum Layer { System, Global, Service, Entity, User }
-enum AppType { Backend, Frontend }
-enum ContextStage { Configuration, Loading, Ready }
+```ts
+context.waitForInitialized().then(async () => {
+  context.service<DevService>(DEV_SERVICE).setMetadataFactory(metadataFactory)
+})
 ```
 
-### Route Constants
+### 5. A plain contextual object
 
-```typescript
-ROOT   // intermediate base route
-HOME   // default/home route
-GUEST  // unauthenticated area
-BASE   // authenticated area
-CRASH  // error fallback screen
+`appendContextual` turns any object into something a context can register — the basis of custom
+resources and entrypoints:
+
+```ts
+import { appendContextual } from '@owlmeans/context'
+import type { BasicResource } from '@owlmeans/context'
+
+const resource = appendContextual<BasicResource>('project-cache', {
+  init: async () => { /* warm up */ },
+})
+
+context.registerResource(resource)
 ```
 
-## Related Packages
+## API
 
-- [`@owlmeans/config`](../config) — configuration builder used with context
-- [`@owlmeans/server-context`](../server-context) — server-side context extension
-- [`@owlmeans/client-context`](../client-context) — client-side context extension
+### Functions
+
+| Symbol | Kind | Purpose |
+|--------|------|---------|
+| `makeBasicContext<C>(cfg)` | function | Build the bare container; wrapped by every layer factory |
+| `makeBasicConfig<C>(type, service, cfg?)` | function | Build a `BasicConfig` with `ready: false`, empty `services`, `records`, `debug` |
+| `createService<S>(alias, service, init?)` | function | Service initialized eagerly by `context.init()` |
+| `createLazyService<S>(alias, service, init?)` | function | Service initialized on first `context.service(alias)` |
+| `appendContextual<T>(alias, obj)` | function | Add `alias`, `registerContext`, `assertCtx` to an object |
+| `assertContext(ctx, location?)` | function | Return `ctx` or throw `SyntaxError` naming `location` |
+
+### `BasicContext<C>` members
+
+| Member | Purpose |
+|--------|---------|
+| `cfg`, `config` | Config object; `config` is a promise resolving after configuration |
+| `stage` | Current `ContextStage` |
+| `configure()`, `init()` | Run the lifecycle; `init()` resolves once the context is `Ready` |
+| `waitForConfigured()`, `waitForInitialized()` | Promises for those two points |
+| `registerService`, `registerResource`, `registerEntrypoint`, `registerEntrypoints`, `registerMiddleware` | Registration; a repeated alias replaces the earlier entry |
+| `service(alias)`, `resource(alias)`, `entrypoint(protocol \| alias)` | Lookup; throws `SyntaxError` when missing or (eager service) not initialized |
+| `hasService`, `hasResource`, `hasEntrypoint` | Presence checks by alias |
+| `entrypoints()` | Every registered entrypoint |
+
+### Constants and enums
+
+| Symbol | Kind | Purpose |
+|--------|------|---------|
+| `AppType` | enum | `Backend`, `Frontend` |
+| `ContextStage` | enum | `Configuration`, `Loading`, `Ready` |
+| `MiddlewareType` | enum | `Config`, `Context` |
+| `MiddlewareStage` | enum | `Configuration`, `Loading`, `Ready` |
+| `CONFIG_RECORD` | const | Config key holding `ConfigRecord[]` (`'records'`) |
+| `EMPTY_ENTITY`, `EMPTY_PROFILE` | const | Placeholders for an unset organization entity or profile |
+| `ROOT` | const | Intermediate base route alias |
+| `HOME` | const | Default final route alias |
+| `GUEST` | const | Intermediate area without authentication |
+| `BASE` | const | Intermediate area requiring authentication |
+| `CRASH` | const | Fallback error screen alias |
+
+### Types
+
+| Symbol | Kind | Purpose |
+|--------|------|---------|
+| `BasicConfig` | interface | `ready`, `service`, `alias?`, `type`, `services?`, `records?`, `debug?` |
+| `ConfigRecord` | interface | Free-form config record with `id` and optional `recordType` |
+| `BasicContext<C>` | interface | The container (members above) |
+| `Contextual` | interface | `ctx?`, `alias`, `registerContext`, `assertCtx` |
+| `Service` | interface | Contextual with `initialized`, `init?`, `lazyInit?`, `ready?` |
+| `InitializedService` | interface | Service with required `init` and `ready` |
+| `LazyService` | interface | Service with required `lazyInit` and `ready` |
+| `InitMethod<S>` | interface | `(service) => () => Promise<void>` custom initializer |
+| `BasicResource` | interface | Contextual with optional `init` |
+| `BasicEntrypoint` | interface | Contextual marked `_entrypoint: true` |
+| `EntrypointReference<T>` | interface | `{ alias, entrypointType? }` — what a protocol declaration satisfies for typed lookup |
+| `Middleware` | interface | `type`, `stage`, `apply(context, args?)` |
+
+## Common pitfalls
+
+- Pass protocol declarations to `context.entrypoint(...)`, never alias strings — the declaration
+  carries the request and response types.
+- Build one context per process with one factory; do not create child contexts or reuse a service
+  object in a second context — it stays bound to the first one.
+- A custom `init` passed to `createService` must set `service.initialized = true`, or
+  `context.service(alias)` throws "is not initialized".
+- `context.service(alias)` on a lazy service does not wait for `lazyInit()`; methods await
+  `service.ready()` before touching state.
+- Registering an alias twice silently replaces the earlier entry — guard `append*` mixins with
+  `has*` so they stay idempotent.
+- `Context` / `Ready` middlewares are not awaited by `init()`; do not rely on them having finished.
+- Keep the organization `entitySlug` on the wire; resolve the stable `entityId` inside the context
+  before persisting relations or calling third parties.
+
+## Related packages
+
+- [`@owlmeans/config`](../config) — the application config built on `BasicConfig`
+- [`@owlmeans/entrypoint`](../entrypoint) — protocol declarations looked up through `context.entrypoint`
+- [`@owlmeans/resource`](../resource) — the resource contract registered through `registerResource`
+- [`@owlmeans/server-context`](../server-context) — server-side context layer
+- [`@owlmeans/client-context`](../client-context) — client-side context layer
 - [`@owlmeans/server-app`](../server-app) — top-level server context factory
+- [`@owlmeans/web-panel`](../web-panel) — top-level browser context factory
 
 <!-- owlmeans:agent-guidance:start -->
 ## Agent guidance
@@ -99,7 +304,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills
+npx @owlmeans/agent-skills@^0.1.18-rc.35
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,16 +1,16 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/context",
-  "version": "0.1.18-rc.0",
-  "generatedAt": "2026-08-16T22:20:50.516Z",
+  "version": "0.1.18-rc.31",
+  "generatedAt": "2026-09-22T21:58:46.790Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {
       "kind": "skill",
-      "name": "context",
+      "name": "owlmeans-context",
       "category": "package-specific",
-      "file": "skills/context/SKILL.md",
-      "canonicalPath": ".agents/skills/context/SKILL.md"
+      "file": "skills/owlmeans-context/SKILL.md",
+      "canonicalPath": ".agents/skills/owlmeans-context/SKILL.md"
     }
   ]
 }

package/agent-meta/skills/owlmeans-context/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: owlmeans-context
+description: How to use @owlmeans/context — the context every OwlMeans app looks things up on, context.service() and resource lookups, typed entrypoint protocol references, and entitySlug vs entityId addressing. Auto-invoked when importing from @owlmeans/context or obtaining a service, resource or entrypoint from a context.
+---
+<!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
+
+# Context lookups
+
+**Install:** `bun add @owlmeans/context@^0.1.18-rc.31`
+
+Use a protocol declaration directly when obtaining an entrypoint. The declaration supplies the
+registered entrypoint’s request and response types.
+
+```ts
+const project = await context.entrypoint(projectProtocols.get).call({
+  params: { id },
+})
+```
+
+Use `context.service(alias)` for registered services and context resource APIs for data access.
+Protocol declarations are shared immutable values; context registration receives local server or
+client entrypoints created with `bind()`, `bindAll()` or `bindScreen()`.
+
+Keep organization entity addressing on the wire as `entitySlug`. Resolve the stable `entityId`
+inside the context before persisting relations or calling third parties.

package/build/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAS,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,WAAW,QAAQ,OAAO,WAAW,MAAM,QAAQ,OAAO,CAAC,CAAC,CAAC,KAAG,CAazG,CAAA"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,WAAW,QAAQ,OAAO,WAAW,MAAM,QAAQ,OAAO,CAAC,CAAC,CAAC,KAAG,CAYzG,CAAA"}

package/build/config.js

@@ -1,9 +1,7 @@
-import { AppType, Layer } from './consts.js';
 export const makeBasicConfig = (type, service, cfg) => {
     const config = {
         ready: false,
         service,
-        layer: type === AppType.Frontend ? Layer.Service : Layer.System,
         type,
         debug: {},
         services: {},

package/build/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAG5C,MAAM,CAAC,MAAM,eAAe,GAAG,CAAwB,IAAa,EAAE,OAAe,EAAE,GAAgB,EAAK,EAAE;IAC5G,MAAM,MAAM,GAAG;QACb,KAAK,EAAE,KAAK;QACZ,OAAO;QACP,KAAK,EAAE,IAAI,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM;QAC/D,IAAI;QACJ,KAAK,EAAE,EAAE;QACT,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE,EAAE;QACX,GAAG,GAAG;KACF,CAAA;IAEN,OAAO,MAAM,CAAA;AACf,CAAC,CAAA"}
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,eAAe,GAAG,CAAwB,IAAa,EAAE,OAAe,EAAE,GAAgB,EAAK,EAAE;IAC5G,MAAM,MAAM,GAAG;QACb,KAAK,EAAE,KAAK;QACZ,OAAO;QACP,IAAI;QACJ,KAAK,EAAE,EAAE;QACT,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE,EAAE;QACX,GAAG,GAAG;KACF,CAAA;IAEN,OAAO,MAAM,CAAA;AACf,CAAC,CAAA"}

package/build/consts.d.ts

@@ -1,10 +1,3 @@
-export declare enum Layer {
-    System = "system",
-    Global = "global",
-    Service = "service",
-    Entity = "entity",
-    User = "user"
-}
 export declare enum AppType {
     Backend = "backend",
     Frontend = "frontend"
@@ -21,8 +14,7 @@ export declare enum ContextStage {
 export declare enum MiddlewareStage {
     Configuration = "configuration",
     Loading = "loading",
-    Ready = "ready",
-    Switching = "switching"
+    Ready = "ready"
 }
 export declare const CONFIG_RECORD = "records";
 export declare const EMPTY_ENTITY = "[UNDEFINED_ENTITY]";

package/build/consts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,oBAAY,KAAK;IACf,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED,oBAAY,OAAO;IACjB,OAAO,YAAY;IACnB,QAAQ,aAAa;CACtB;AAED,oBAAY,cAAc;IACxB,MAAM,WAAW;IACjB,OAAO,YAAY;CACpB;AAED,oBAAY,YAAY;IACtB,aAAa,kBAAkB;IAC/B,OAAO,YAAY;IACnB,KAAK,UAAU;CAChB;AAED,oBAAY,eAAe;IACzB,aAAa,kBAAkB;IAC/B,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,SAAS,cAAc;CACxB;AAED,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC,eAAO,MAAM,YAAY,uBAAuB,CAAA;AAChD,eAAO,MAAM,aAAa,wBAAwB,CAAA;AAGlD;;GAEG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B;;GAEG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B;;GAEG;AACH,eAAO,MAAM,KAAK,UAAU,CAAA;AAC5B;;GAEG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B;;GAEG;AACH,eAAO,MAAM,KAAK,UAAU,CAAA"}
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,oBAAY,OAAO;IACjB,OAAO,YAAY;IACnB,QAAQ,aAAa;CACtB;AAED,oBAAY,cAAc;IACxB,MAAM,WAAW;IACjB,OAAO,YAAY;CACpB;AAED,oBAAY,YAAY;IACtB,aAAa,kBAAkB;IAC/B,OAAO,YAAY;IACnB,KAAK,UAAU;CAChB;AAED,oBAAY,eAAe;IACzB,aAAa,kBAAkB;IAC/B,OAAO,YAAY;IACnB,KAAK,UAAU;CAChB;AAED,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC,eAAO,MAAM,YAAY,uBAAuB,CAAA;AAChD,eAAO,MAAM,aAAa,wBAAwB,CAAA;AAGlD;;GAEG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B;;GAEG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B;;GAEG;AACH,eAAO,MAAM,KAAK,UAAU,CAAA;AAC5B;;GAEG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B;;GAEG;AACH,eAAO,MAAM,KAAK,UAAU,CAAA"}

package/build/consts.js

@@ -1,11 +1,3 @@
-export var Layer;
-(function (Layer) {
-    Layer["System"] = "system";
-    Layer["Global"] = "global";
-    Layer["Service"] = "service";
-    Layer["Entity"] = "entity";
-    Layer["User"] = "user";
-})(Layer || (Layer = {}));
 export var AppType;
 (function (AppType) {
     AppType["Backend"] = "backend";
@@ -27,7 +19,6 @@ export var MiddlewareStage;
     MiddlewareStage["Configuration"] = "configuration";
     MiddlewareStage["Loading"] = "loading";
     MiddlewareStage["Ready"] = "ready";
-    MiddlewareStage["Switching"] = "switching";
 })(MiddlewareStage || (MiddlewareStage = {}));
 export const CONFIG_RECORD = 'records';
 export const EMPTY_ENTITY = '[UNDEFINED_ENTITY]';

package/build/consts.js.map

@@ -1 +1 @@
-{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAN,IAAY,KAMX;AAND,WAAY,KAAK;IACf,0BAAiB,CAAA;IACjB,0BAAiB,CAAA;IACjB,4BAAmB,CAAA;IACnB,0BAAiB,CAAA;IACjB,sBAAa,CAAA;AACf,CAAC,EANW,KAAK,KAAL,KAAK,QAMhB;AAED,MAAM,CAAN,IAAY,OAGX;AAHD,WAAY,OAAO;IACjB,8BAAmB,CAAA;IACnB,gCAAqB,CAAA;AACvB,CAAC,EAHW,OAAO,KAAP,OAAO,QAGlB;AAED,MAAM,CAAN,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,mCAAiB,CAAA;IACjB,qCAAmB,CAAA;AACrB,CAAC,EAHW,cAAc,KAAd,cAAc,QAGzB;AAED,MAAM,CAAN,IAAY,YAIX;AAJD,WAAY,YAAY;IACtB,+CAA+B,CAAA;IAC/B,mCAAmB,CAAA;IACnB,+BAAe,CAAA;AACjB,CAAC,EAJW,YAAY,KAAZ,YAAY,QAIvB;AAED,MAAM,CAAN,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,kDAA+B,CAAA;IAC/B,sCAAmB,CAAA;IACnB,kCAAe,CAAA;IACf,0CAAuB,CAAA;AACzB,CAAC,EALW,eAAe,KAAf,eAAe,QAK1B;AAED,MAAM,CAAC,MAAM,aAAa,GAAG,SAAS,CAAA;AAEtC,MAAM,CAAC,MAAM,YAAY,GAAG,oBAAoB,CAAA;AAChD,MAAM,CAAC,MAAM,aAAa,GAAG,qBAAqB,CAAA;AAElD,wBAAwB;AACxB;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAA;AAC1B;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAA;AAC1B;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAA;AAC5B;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAA;AAC1B;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAA"}
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAN,IAAY,OAGX;AAHD,WAAY,OAAO;IACjB,8BAAmB,CAAA;IACnB,gCAAqB,CAAA;AACvB,CAAC,EAHW,OAAO,KAAP,OAAO,QAGlB;AAED,MAAM,CAAN,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,mCAAiB,CAAA;IACjB,qCAAmB,CAAA;AACrB,CAAC,EAHW,cAAc,KAAd,cAAc,QAGzB;AAED,MAAM,CAAN,IAAY,YAIX;AAJD,WAAY,YAAY;IACtB,+CAA+B,CAAA;IAC/B,mCAAmB,CAAA;IACnB,+BAAe,CAAA;AACjB,CAAC,EAJW,YAAY,KAAZ,YAAY,QAIvB;AAED,MAAM,CAAN,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,kDAA+B,CAAA;IAC/B,sCAAmB,CAAA;IACnB,kCAAe,CAAA;AACjB,CAAC,EAJW,eAAe,KAAf,eAAe,QAI1B;AAED,MAAM,CAAC,MAAM,aAAa,GAAG,SAAS,CAAA;AAEtC,MAAM,CAAC,MAAM,YAAY,GAAG,oBAAoB,CAAA;AAChD,MAAM,CAAC,MAAM,aAAa,GAAG,qBAAqB,CAAA;AAElD,wBAAwB;AACxB;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAA;AAC1B;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAA;AAC1B;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAA;AAC5B;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAA;AAC1B;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAA"}

package/build/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAoE,MAAM,YAAY,CAAA;AAO7H,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,WAAW,OAAO,CAAC,KAAG,YAAY,CAAC,CAAC,CA6Q9E,CAAA"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EAAE,YAAY,EAC1B,MAAM,YAAY,CAAA;AAKnB,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,WAAW,OAAO,CAAC,KAAG,YAAY,CAAC,CAAC,CAuK9E,CAAA"}