@owlmeans/route 0.1.18-rc.3 → 0.1.18-rc.30

package/README.md

@@ -1,78 +1,246 @@
 # @owlmeans/route
 
-Route model factory and type definitions for OwlMeans modules.
+The route declaration vocabulary for OwlMeans entrypoints. An app imports it in its shared contract
+package, next to `@owlmeans/entrypoint`, to state for each entrypoint the URL segment, parent,
+HTTP method, app type (backend or frontend) and transport identifier. It is not a
+router and serves nothing: server binding is `@owlmeans/server-route` / `@owlmeans/server-app`,
+client binding is `@owlmeans/client-route` / `@owlmeans/client-entrypoint`, UI routing is
+`@owlmeans/router`. Application code usually reads addresses through the entrypoint accessors
+(`path()`, `mount()`, `address()`) rather than through this package's `./utils`.
 
-## Overview
-
-- `route()` creates a `CommonRouteModel` used as the first argument to `module()`
-- `frontend()` / `backend()` / `socket()` helpers set the route's `AppType` and parent
-- `RouteMethod` enum covers HTTP verbs; `RouteProtocols` covers `http`/`ws`
-- This package is a dependency of `@owlmeans/module` — you rarely use it directly unless defining module-level routes
+A `RouteDeclaration` is plain, immutable data: its `path` is the segment the route contributes under
+its parent, and it is never rewritten. Where the route actually answers — the full path, the mount
+under a service base, the host and scheme — is computed on demand from the declaration plus the
+context that asks, so the same declaration serves a server and a browser alike.
 
 ## Installation
 
 ```bash
-bun add @owlmeans/route
+bun add @owlmeans/route@^0.1.18-rc.29
 ```
 
+## Concepts
+
+- **Declaration** — the `RouteDeclaration` a `route()` call produces: `alias`, `path` (the segment
+  under `parent`), `type`, `method`, `protocol`, opaque `protocolOptions`, and service coordinates.
+- **Model** — `RouteModel` is `{ route: RouteDeclaration }` and nothing more. `protocol()` and
+  `openProtocol()` from `@owlmeans/entrypoint` take it as their first argument.
+- **Marker** — `backend()`, `frontend()` and `socket()` return `Partial<RouteOptions>` that set the
+  app type and built-in protocol; a transport package may provide another marker.
+- **Parent** — a route nests under another entrypoint. Pass the parent protocol object
+  (`parent: storyProtocols.base`); the declaration stores only its alias.
+- **Service** — `service` names the configured service (`cfg.services`) that answers the route.
+  Without it the route belongs to the asking context's own service or the default one of its type.
+- **Protocol** — `RouteProtocols` contains the built-in HTTP and WebSocket identifiers. A backend
+  transport package may supply another string identifier and owns its opaque option data.
+
 ## Usage
 
-Define routes for modules (typically via `@owlmeans/server-app` re-exports):
+### A backend protocol tree
 
-```typescript
-import { route, frontend, backend, socket, RouteMethod } from '@owlmeans/route'
-import { module } from '@owlmeans/module'
+Aliases stay private to the declaration module; the exported value is a tree of protocol objects.
 
-// Backend REST route
-const createRoute = module(
-  route('story-create', '/stories', backend('api', RouteMethod.POST))
-)
+```ts
+import { contract, protocol } from '@owlmeans/entrypoint'
+import { backend, route, RouteMethod } from '@owlmeans/route'
+import { DEFAULT_GUARD } from '@owlmeans/auth-common'
+import { InvoiceSchema, CreateInvoiceBodySchema } from './schemas.js'
 
-// Frontend client route nested under parent
-const storyRoute = module(
-  route('story-view', '/stories/:id', frontend('app'))
-)
+const aliases = {
+  base: 'my-app:api:invoice:base',
+  list: 'my-app:api:invoice:list',
+  create: 'my-app:api:invoice:create',
+} as const
 
-// WebSocket route
-const wsRoute = module(
-  route('story-ws', '/stories/stream', socket('api'))
-)
+const base = protocol(route(aliases.base, '/invoice', backend()), contract(), {
+  guards: DEFAULT_GUARD,
+})
+
+export const invoiceProtocols = {
+  base,
+  list: protocol(
+    route(aliases.list, '/', backend({ parent: base, method: RouteMethod.GET })),
+    contract(InvoiceSchema),
+  ),
+  create: protocol(
+    route(aliases.create, '/', backend({ parent: base, method: RouteMethod.POST })),
+    contract(CreateInvoiceBodySchema, InvoiceSchema),
+  ),
+} as const
 ```
 
-## API
+`invoiceProtocols.create` resolves to `/invoice` on the backend service, answering `POST`, and
+inherits the guard declared on `base`.
 
-### `route(alias, path, opts?): CommonRouteModel`
+### Path params, screens and default children
 
-Creates a route model. `opts` can be a `RouteOptions` object or the result of `frontend()`, `backend()`, or `socket()`.
+Path params use the `:name` form and are typed through `contract.request`. `frontend()` marks a
+screen; `default: true` marks the child screen shown at the parent's path.
 
-### `frontend(parent?, sticky?): Partial<RouteOptions>`
+```ts
+import { contract, openProtocol, protocol, typed } from '@owlmeans/entrypoint'
+import { backend, frontend, route, RouteMethod } from '@owlmeans/route'
+import type { ProjectParams, Project, RenameProject } from './types.js'
+import { ProjectParamsSchema, RenameProjectSchema } from './schemas.js'
 
-Returns options marking the route as frontend (`AppType.Frontend`), optionally with a parent alias.
+const aliases = {
+  base: 'my-app:api:project:base',
+  rename: 'my-app:api:project:rename',
+  web: 'my-app:web:project:base',
+  dashboard: 'my-app:web:project:dashboard',
+  overview: 'my-app:web:project:overview',
+} as const
 
-### `backend(parent?, method?): Partial<RouteOptions>`
+const base = openProtocol(route(aliases.base, '/project', backend()))
+const web = openProtocol(route(aliases.web, '/project/:projectId', frontend()))
 
-Returns options marking the route as backend (`AppType.Backend`), optionally with a parent alias and `RouteMethod`.
+export const projectProtocols = {
+  base,
+  rename: protocol(
+    route(aliases.rename, '/:id/rename', backend({ parent: base, method: RouteMethod.PATCH })),
+    contract.request(
+      { params: typed<ProjectParams>(ProjectParamsSchema), body: typed<RenameProject>(RenameProjectSchema) },
+      typed<Project>(),
+    ),
+  ),
+  web: {
+    base: web,
+    dashboard: openProtocol(route(aliases.dashboard, '/dashboard', frontend({ parent: web }))),
+    overview: openProtocol(route(aliases.overview, '/', frontend({ parent: web, default: true }))),
+  },
+} as const
+```
 
-### `socket(parent?): Partial<RouteOptions>`
+### Sockets, custom protocols and other services
 
-Returns options for a WebSocket route with `RouteProtocols.SOCKET`.
+`socket()` is `backend()` with a different protocol. A route pointed at another service carries
+`service`. Adapter packages may add their own protocol and opaque `protocolOptions`; route does not
+define their semantics.
 
-### `RouteMethod`
+```ts
+import { contract, openProtocol, protocol, typed } from '@owlmeans/entrypoint'
+import { route, socket } from '@owlmeans/route'
+import type { ProjectParams, StoryUpdate } from './types.js'
+import { ProjectParamsSchema } from './schemas.js'
 
-```typescript
-enum RouteMethod { GET, POST, PATCH, PUT, DELETE }
+const aliases = {
+  updates: 'my-app:api:update:base',
+  story: 'my-app:api:update:story',
+} as const
+
+const updates = openProtocol(route(aliases.updates, '/update'))
+
+export const storyProtocols = {
+  updates,
+  // WebSocket subscription under /update
+  story: protocol(
+    route(aliases.story, '/story/:id', socket({ parent: updates })),
+    contract.request({ params: typed<ProjectParams>(ProjectParamsSchema) }, typed<StoryUpdate>()),
+  ),
+} as const
 ```
 
-### `RouteProtocols`
+### Reading where a route answers
+
+Once protocols are registered on a context, the entrypoint accessors answer address questions. The
+`./utils` helpers are the same functions over a bare declaration.
+
+```ts
+import { AppType } from '@owlmeans/context'
+import { service } from '@owlmeans/config'
+import { resolveAddress, resolveMount } from '@owlmeans/route/utils'
+import { invoiceProtocols } from 'my-app-common'
+
+// Config side: the service the backend routes resolve against
+const cfg = service({ service: 'my-app-api', type: AppType.Backend, host: 'localhost', port: 8080, base: 'api' }, baseCfg)
 
-```typescript
-enum RouteProtocols { WEB = 'http', SOCKET = 'ws' }
+// Runtime side, through the registered entrypoint
+const entrypoint = context.entrypoint(invoiceProtocols.create)
+entrypoint.path()    // '/invoice'
+entrypoint.mount()   // '/api/invoice'
+entrypoint.address() // { host: 'localhost', port: 8080, base: 'api', secure: true, protocol: 'http' }
+entrypoint.isLocal() // true inside the my-app-api process
+
+// Same answers from a declaration
+const declaration = invoiceProtocols.create.route.route
+resolveMount(context, declaration)
+resolveAddress(context, declaration)
 ```
 
-## Related Packages
+## API
+
+### `@owlmeans/route`
+
+| Symbol | Kind | Purpose |
+|--------|------|---------|
+| `route(alias, path, opts?)` | function | Build a `RouteModel`; `opts` is `RouteOptions` or a parent alias string |
+| `createRoute(alias, path, opts?)` | function | Build the bare `RouteDeclaration` (parent reference collapsed to its alias) |
+| `makeRouteModel(declaration)` | function | Wrap a declaration as `{ route }` |
+| `backend(opts?, method?)` | function | Mark `AppType.Backend`; `opts` is options, a parent alias or `null`; `method` is a `RouteMethod` or more options |
+| `frontend(opts?, default?)` | function | Mark `AppType.Frontend`; `default` is a boolean flag or more options |
+| `socket(opts?, secondary?)` | function | `backend()` with `protocol: RouteProtocols.SOCKET` |
+| `service(alias, opts?)` | function | Set `service` on `opts` (mutated and returned) |
+| `rtype(type, opts?)` | function | Set an arbitrary `AppType`; the primitive behind `backend()` / `frontend()` |
+| `normalizePath(path)` | function | Trim whitespace and one leading and trailing `/` |
+| `RouteMethod` | enum | `GET = 'get'`, `POST = 'post'`, `PATCH = 'patch'`, `PUT = 'put'`, `DELETE = 'delete'` |
+| `RouteProtocols` | enum | Generic built-ins: `WEB = 'http'`, `SOCKET = 'ws'` |
+| `SEP` | const | Path separator `'/'` |
+| `PARAM` | const | Path param prefix `':'` |
+| `BasicRoute` | interface | `type`, `service?`, `host?`, `port?`, `base?`, `internalHost?`, `internalPort?` |
+| `RouteDeclaration` | interface | `BasicRoute` + `alias`, `path`, `parent?`, `default?`, `method?`, `protocol?`, transport-owned `protocolOptions?`, `secure?`, `timeout?` |
+| `RouteOptions` | interface | `Partial<RouteDeclaration>` whose `parent` is a `RouteParent` |
+| `RouteParent` | type | `string \| EntrypointReference` |
+| `RouteModel` | interface | `{ route: RouteDeclaration }` |
+| `RouteAddress` | interface | `{ host, port?, base?, secure, protocol }` |
+| `CommonServiceRoute` | interface | A service entry: `BasicRoute` + `service`, `home?`, `default?` |
+| `ResolvedServiceRoute` | interface | A service entry that names its `host` |
+
+### `@owlmeans/route/utils`
+
+The first six take `(context, declaration)`; the other four are pure and take no context.
+
+| Symbol | Kind | Purpose |
+|--------|------|---------|
+| `resolvePath(context, route)` | function | Every ancestor's segment, then this one |
+| `resolveMount(context, route)` | function | Service `base` + the full path |
+| `resolveService(context, route)` | function | The named service, else the default of the route's type, else the first of that type |
+| `resolveAddress(context, route)` | function | The `RouteAddress`; a hop over the service's internal host is never TLS |
+| `isLocalRoute(context, route)` | function | Does the route belong to the context's own service |
+| `getParentRoute(context, route)` | function | The parent declaration, with parentship-cycle detection |
+| `overrideParams(route, overrides?, filter?)` | function | Fill only blank fields of `route` from `overrides`; mutates, returns nothing |
+| `prependBase(route, path)` | function | `path` prefixed with `route.base` when set |
+| `isServiceRoute(obj?)` | type guard | Is `obj` a `CommonServiceRoute` with a known `AppType` |
+| `isServiceRouteResolved(route)` | type guard | Does the service entry name a host |
+| `CreateRouteSignature<R>` | interface | Call signature shared by `route()` and `createRoute()` |
+
+## Common pitfalls
+
+- Pass the parent protocol object in route options, never an exported alias string. Keep aliases
+  private to the declaration module and export a `*Protocols` tree.
+- The positional marker forms (`backend(parent, method)`, `frontend(parent, true)`) accept a parent
+  only as an alias string: a protocol object in first position is spread into the options and
+  overwrites the child's alias. Pass protocols as `{ parent }`.
+- `path` is only this route's segment. Do not repeat the parent's path in it; `resolvePath()` joins
+  the chain.
+- Custom transport options are opaque here. Validate them through the package that owns the
+  protocol.
+- Do not pass a context to the pure `./utils` helpers: `overrideParams(ctx, decl)` writes route
+  fields into the context object instead of resolving anything.
+- A mis-wired tree (no `cfg.services`, a service without a host, a parentship cycle) throws
+  `SyntaxError` when an address is resolved. Fix the config; do not catch it.
+- `transportAlias` and `EntrypointTransport` live in `@owlmeans/entrypoint`, not here. A route only
+  names its protocol.
+
+## Related packages
 
-- [`@owlmeans/module`](../module) — `module()` takes a `CommonRouteModel` as first argument
-- [`@owlmeans/server-app`](../server-app) — re-exports `route` as `broute` (backend) alongside `route`
+- [`@owlmeans/entrypoint`](../entrypoint) — `protocol()` / `openProtocol()` consume a `RouteModel` and
+  expose `path()`, `mount()`, `address()`, `isLocal()`
+- [`@owlmeans/context`](../context) — `AppType`, `EntrypointReference` and the registry the address helpers walk
+- [`@owlmeans/config`](../config) — `service()` declares the service entries routes resolve against
+- [`@owlmeans/server-route`](../server-route) — server-side route model; re-exported by
+  [`@owlmeans/server-app`](../server-app) as `broute`
+- [`@owlmeans/client-route`](../client-route) — marks a route as client-side and extracts its params
+- [`@owlmeans/socket`](../socket) — the SOCKET transport contracts
 
 <!-- owlmeans:agent-guidance:start -->
 ## Agent guidance
@@ -82,7 +250,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.33
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/route",
-  "version": "0.1.18-rc.0",
-  "generatedAt": "2026-08-16T22:20:50.511Z",
+  "version": "0.1.18-rc.30",
+  "generatedAt": "2026-09-22T17:39:02.537Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/route/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: route
-description: How to use @owlmeans/route — route() helper for declaring URL paths, frontend() marker for React routes, RouteMethod enum, and route model types. Auto-invoked when importing route helpers or defining a module's URL path.
+description: How to use @owlmeans/route — transport-neutral route declarations, frontend/backend/socket markers, HTTP methods, extensible protocol identifiers, and address helpers. Auto-invoked when importing route helpers or defining an entrypoint's URL path.
 user-invocable: false
 ---
 <!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
@@ -8,43 +8,97 @@ user-invocable: false
 # @owlmeans/route
 
 **Layer:** Core
-**Install:** `"@owlmeans/route": "^0.1.18-rc.0"` in `dependencies`
+**Install:** `"@owlmeans/route": "^0.1.18-rc.30"` in `dependencies`
 
 ## Key Exports
 
 | Export | Description |
 |--------|-------------|
-| `route(alias, path, options?)` | Define a route — path is relative to `parent` |
-| `frontend(options?)` | Mark a route as a React page (web only) |
-| `RouteMethod` | enum of GET, POST, PUT, DELETE, PATCH |
-| `Route` types | Resolved route shape |
-| Constants | Default route aliases |
+| `route(alias, path, options?)` | Build a route model — `path` is the segment contributed under `parent` |
+| `frontend(options?, default?)` | Mark a route as a React page (web only) |
+| `backend(options?, method?)` | Mark a route as a backend endpoint |
+| `socket(options?, secondary?)` | A backend route answering over `RouteProtocols.SOCKET` |
+| `service(alias, options?)` | Point a route at a named service |
+| `RouteMethod` | enum of GET, POST, PUT, PATCH, DELETE |
+| `RouteProtocols` | built-in WEB (`http`) and SOCKET (`ws`) identifiers |
+| `RouteProtocol` | a built-in or package-owned transport identifier |
+| `rtype(type, options?)` | The primitive `frontend()` / `backend()` are built from |
+| `createRoute(alias, path, opts?)` / `makeRouteModel(decl)` | The declaration and its wrapper, when you need them apart |
+| `BasicRoute` | `{ type, service?, host?, port?, base?, internalHost?, internalPort? }` |
+| `RouteDeclaration` | The immutable declaration `route()` produces |
+| `RouteOptions` | `Partial<RouteDeclaration>` — what the marker helpers return |
+| `RouteModel` | `{ route }` — the model wrapping a declaration |
+| `RouteAddress` | `{ host, port, base, secure, protocol }` — where a route answers |
+| `CommonServiceRoute` / `ResolvedServiceRoute` | A service entry, and one that knows its host |
+| `normalizePath(path)`, `SEP`, `PARAM` | Path primitives |
+
+## Declaration and model
+
+`route()` returns a `RouteModel` that does nothing but **wrap an immutable `RouteDeclaration`**. The
+declaration is plain data an application ships in its contract package: `path` stays the segment this
+route contributes under its parent and is never rewritten, and the model carries no state of its own.
+Where the route answers is worked out on demand, against the context that asks — which is what lets
+the same declaration serve a client and a server at once.
+
+## Protocol ownership
+
+A route names the protocol it answers on, and an application binds one by registering a transport
+service under `transportAlias(protocol)`. So the protocol is what decides whether a call travels as
+an HTTP request, a socket frame or a package-owned transport — the call site never says. Both
+`transportAlias` and `EntrypointTransport` are exported by `@owlmeans/entrypoint`; this package only
+stores an opaque protocol identifier and `protocolOptions`. The package defining a custom protocol
+owns its marker, option type, validation and transport; the generic route package does not describe
+that transport's implementation semantics.
 
 ## Subpath Exports
 
-- `./utils` — path manipulation helpers
+`./utils` holds two kinds of helper, and their signatures differ. The six that answer *where* a
+route lives take `(context, declaration)`, because that is a question about the asking context. The
+other four are pure functions over a declaration or a service entry and take **no context**.
+Passing one to them resolves nothing: `overrideParams(ctx, decl)` writes route fields straight into
+the context object instead.
+
+| Helper | Signature | Answers |
+|--------|-----------|---------|
+| `resolvePath` | `(context, route)` | Every ancestor's segment, then this one |
+| `resolveMount` | `(context, route)` | `base` + the full path — what a server mounts and a client requests |
+| `resolveService` | `(context, route)` | The service the declaration answers on: the one it names, else the default of its app type, else the first of that type |
+| `resolveAddress` | `(context, route)` | The `RouteAddress`; a hop over a service's INTERNAL host is never TLS |
+| `isLocalRoute` | `(context, route)` | Does the route belong to the service the asking context IS? |
+| `getParentRoute` | `(context, route)` | The parent declaration, with parentship-cycle detection |
+| `overrideParams` | `(route, overrides?, filter?)` | Fill in **only the blank** fields of `route` from `overrides`; `filter` narrows it to the listed keys. Mutates `route` and returns nothing |
+| `prependBase` | `(route, path)` | `path` prefixed with `route.base`, or `path` when there is no base |
+| `isServiceRoute` | `(obj?)` | Type guard: is this a service entry (`type` + `service`, `type` a known `AppType`)? |
+| `isServiceRouteResolved` | `(route)` | Type guard: does that service entry name a host? |
+
+Application code rarely calls these directly — `@owlmeans/entrypoint` exposes them as `path()`,
+`mount()`, `service()`, `address()` and `isLocal()` on the entrypoint itself.
 
 ## Usage
 
 ```typescript
 import { route, frontend, RouteMethod } from '@owlmeans/route'
-import { entrypoint } from '@owlmeans/entrypoint'
+import { contract, openProtocol, protocol, typed } from '@owlmeans/entrypoint'
 
 // Server route
-entrypoint(
+protocol(
   route(manager.back.project.create, '/create', {
     parent: manager.back.project.base,
     method: RouteMethod.POST,
-  })
+  }),
+  contract(typed<Project>()),
 )
 
 // Web route — frontend() marks it as a React page
-entrypoint(
+openProtocol(
   route(HOME, '/', frontend({ default: true, parent: BASE }))
 )
 ```
 
 ## Depends On
 
-- `@owlmeans/error` — route errors
-- `@owlmeans/i18n` — translatable errors
+- `@owlmeans/context` — `AppType`, and the entrypoint registry the address helpers walk
+
+That is the only dependency. The address helpers signal a mis-wired route tree by throwing
+`SyntaxError` — an unconfigured service, an unresolved host, a parentship cycle — so the process
+crashes on a wiring mistake instead of serving a wrong URL.

package/build/consts.d.ts

@@ -7,6 +7,11 @@ export declare enum RouteMethod {
 }
 export declare const SEP = "/";
 export declare const PARAM = ":";
+/**
+ * How a route is carried. The protocol picks the transport that answers it — an application binds
+ * one by registering a service under `transportAlias(protocol)` — so a caller writes `call()` and
+ * never learns which transport carried the work.
+ */
 export declare enum RouteProtocols {
     WEB = "http",
     SOCKET = "ws"

package/build/consts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,oBAAY,WAAW;IACrB,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,KAAK,UAAU;IACf,GAAG,QAAQ;IACX,MAAM,WAAW;CAClB;AAED,eAAO,MAAM,GAAG,MAAM,CAAA;AAEtB,eAAO,MAAM,KAAK,MAAM,CAAA;AAExB,oBAAY,cAAc;IACxB,GAAG,SAAS;IACZ,MAAM,OAAO;CACd"}
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,oBAAY,WAAW;IACrB,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,KAAK,UAAU;IACf,GAAG,QAAQ;IACX,MAAM,WAAW;CAClB;AAED,eAAO,MAAM,GAAG,MAAM,CAAA;AAEtB,eAAO,MAAM,KAAK,MAAM,CAAA;AAExB;;;;GAIG;AACH,oBAAY,cAAc;IACxB,GAAG,SAAS;IACZ,MAAM,OAAO;CACd"}

package/build/consts.js

@@ -8,6 +8,11 @@ export var RouteMethod;
 })(RouteMethod || (RouteMethod = {}));
 export const SEP = '/';
 export const PARAM = ':';
+/**
+ * How a route is carried. The protocol picks the transport that answers it — an application binds
+ * one by registering a service under `transportAlias(protocol)` — so a caller writes `call()` and
+ * never learns which transport carried the work.
+ */
 export var RouteProtocols;
 (function (RouteProtocols) {
     RouteProtocols["WEB"] = "http";

package/build/consts.js.map

@@ -1 +1 @@
-{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAN,IAAY,WAMX;AAND,WAAY,WAAW;IACrB,0BAAW,CAAA;IACX,4BAAa,CAAA;IACb,8BAAe,CAAA;IACf,0BAAW,CAAA;IACX,gCAAiB,CAAA;AACnB,CAAC,EANW,WAAW,KAAX,WAAW,QAMtB;AAED,MAAM,CAAC,MAAM,GAAG,GAAG,GAAG,CAAA;AAEtB,MAAM,CAAC,MAAM,KAAK,GAAG,GAAG,CAAA;AAExB,MAAM,CAAN,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,8BAAY,CAAA;IACZ,+BAAa,CAAA;AACf,CAAC,EAHW,cAAc,KAAd,cAAc,QAGzB"}
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAN,IAAY,WAMX;AAND,WAAY,WAAW;IACrB,0BAAW,CAAA;IACX,4BAAa,CAAA;IACb,8BAAe,CAAA;IACf,0BAAW,CAAA;IACX,gCAAiB,CAAA;AACnB,CAAC,EANW,WAAW,KAAX,WAAW,QAMtB;AAED,MAAM,CAAC,MAAM,GAAG,GAAG,GAAG,CAAA;AAEtB,MAAM,CAAC,MAAM,KAAK,GAAG,GAAG,CAAA;AAExB;;;;GAIG;AACH,MAAM,CAAN,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,8BAAY,CAAA;IACZ,+BAAa,CAAA;AACf,CAAC,EAHW,cAAc,KAAd,cAAc,QAGzB"}

package/build/helper.d.ts

@@ -1,8 +1,8 @@
 import { AppType } from '@owlmeans/context';
 import { RouteMethod } from './consts.js';
-import type { CommonRouteModel, RouteOptions } from './types.js';
+import type { RouteModel, RouteOptions } from './types.js';
 import type { CreateRouteSignature } from './utils/types.js';
-export declare const route: CreateRouteSignature<CommonRouteModel>;
+export declare const route: CreateRouteSignature<RouteModel>;
 export declare const normalizePath: (path: string) => string;
 export declare const rtype: (type: AppType, opts?: RouteOptions | string) => Partial<RouteOptions>;
 export declare const backend: (opts?: RouteOptions | string | null, method?: RouteOptions | RouteMethod) => Partial<RouteOptions>;

package/build/helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAuB,MAAM,aAAa,CAAA;AAE9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE5D,eAAO,MAAM,KAAK,EAAE,oBAAoB,CAAC,gBAAgB,CACT,CAAA;AAEhD,eAAO,MAAM,aAAa,SAAU,MAAM,KAAG,MAM5C,CAAA;AAED,eAAO,MAAM,KAAK,SAAU,OAAO,SAAS,YAAY,GAAG,MAAM,KAAG,OAAO,CAAC,YAAY,CAEvF,CAAA;AAED,eAAO,MAAM,OAAO,UAAW,YAAY,GAAG,MAAM,GAAG,IAAI,WAAW,YAAY,GAAG,WAAW,KAAG,OAAO,CAAC,YAAY,CAQtH,CAAA;AAED,eAAO,MAAM,OAAO,YAAa,MAAM,SAAS,OAAO,CAAC,YAAY,CAAC,KAAG,OAAO,CAAC,YAAY,CAI3F,CAAA;AAED,eAAO,MAAM,MAAM,UAAW,YAAY,GAAG,MAAM,GAAG,IAAI,cAAc,YAAY,KAAG,OAAO,CAAC,YAAY,CAM1G,CAAA;AAED,eAAO,MAAM,QAAQ,UAAW,YAAY,GAAG,MAAM,GAAG,IAAI,QAAQ,YAAY,GAAG,OAAO,KAAG,OAAO,CAAC,YAAY,CAQhH,CAAA"}
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAuB,MAAM,aAAa,CAAA;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE5D,eAAO,MAAM,KAAK,EAAE,oBAAoB,CAAC,UAAU,CACH,CAAA;AAEhD,eAAO,MAAM,aAAa,SAAU,MAAM,KAAG,MAM5C,CAAA;AAED,eAAO,MAAM,KAAK,SAAU,OAAO,SAAS,YAAY,GAAG,MAAM,KAAG,OAAO,CAAC,YAAY,CAEvF,CAAA;AAED,eAAO,MAAM,OAAO,UAAW,YAAY,GAAG,MAAM,GAAG,IAAI,WAAW,YAAY,GAAG,WAAW,KAAG,OAAO,CAAC,YAAY,CAQtH,CAAA;AAED,eAAO,MAAM,OAAO,YAAa,MAAM,SAAS,OAAO,CAAC,YAAY,CAAC,KAAG,OAAO,CAAC,YAAY,CAI3F,CAAA;AAED,eAAO,MAAM,MAAM,UAAW,YAAY,GAAG,MAAM,GAAG,IAAI,cAAc,YAAY,KAAG,OAAO,CAAC,YAAY,CAM1G,CAAA;AAED,eAAO,MAAM,QAAQ,UAAW,YAAY,GAAG,MAAM,GAAG,IAAI,QAAQ,YAAY,GAAG,OAAO,KAAG,OAAO,CAAC,YAAY,CAQhH,CAAA"}

package/build/helper.js.map

@@ -1 +1 @@
-{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"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"}

package/build/model.d.ts

@@ -1,5 +1,5 @@
-import type { CommonRoute, CommonRouteModel } from './types.js';
+import type { RouteDeclaration, RouteModel } from './types.js';
 import type { CreateRouteSignature } from './utils/types.js';
-export declare const makeRouteModel: (route: CommonRoute) => CommonRouteModel;
-export declare const createRoute: CreateRouteSignature<CommonRoute>;
+export declare const makeRouteModel: (route: RouteDeclaration) => RouteModel;
+export declare const createRoute: CreateRouteSignature<RouteDeclaration>;
 //# sourceMappingURL=model.d.ts.map

package/build/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAI5D,eAAO,MAAM,cAAc,UAAW,WAAW,KAAG,gBAOnD,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,oBAAoB,CAAC,WAAW,CAUzD,CAAA"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG5D,eAAO,MAAM,cAAc,UAAW,gBAAgB,KAAG,UAAyB,CAAA;AAElF,eAAO,MAAM,WAAW,EAAE,oBAAoB,CAAC,gBAAgB,CAY9D,CAAA"}

package/build/model.js

@@ -1,19 +1,14 @@
-import { resolve } from './utils/route.js';
 import { AppType } from '@owlmeans/context';
-export const makeRouteModel = (route) => {
-    const model = {
-        route,
-        resolve: ctx => resolve(route)(ctx)
-    };
-    return model;
-};
+export const makeRouteModel = (route) => ({ route });
 export const createRoute = (alias, path, opts) => {
+    const options = typeof opts === 'string' ? { parent: opts } : opts;
+    const { parent, ...rest } = options ?? {};
     const route = {
         alias,
         type: AppType.Backend,
         path,
-        resolved: false,
-        ...(typeof opts === 'string' ? { parent: opts } : opts)
+        ...rest,
+        ...(parent == null ? {} : { parent: typeof parent === 'string' ? parent : parent.alias }),
     };
     return route;
 };

package/build/model.js.map

@@ -1 +1 @@
-{"version":3,"file":"model.js","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,OAAO,EAA6B,MAAM,mBAAmB,CAAA;AAEtE,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAkB,EAAoB,EAAE;IACrE,MAAM,KAAK,GAAqB;QAC9B,KAAK;QACL,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAA2C,CAAC;KAC5E,CAAA;IAED,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,WAAW,GAAsC,CAAC,KAAK,EAAE,IAAI,EAAE,IAAK,EAAE,EAAE;IACnF,MAAM,KAAK,GAAgB;QACzB,KAAK;QACL,IAAI,EAAE,OAAO,CAAC,OAAO;QACrB,IAAI;QACJ,QAAQ,EAAE,KAAK;QACf,GAAG,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;KACxD,CAAA;IAED,OAAO,KAAK,CAAA;AACd,CAAC,CAAA"}
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAE3C,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAuB,EAAc,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;AAElF,MAAM,CAAC,MAAM,WAAW,GAA2C,CAAC,KAAK,EAAE,IAAI,EAAE,IAAK,EAAE,EAAE;IACxF,MAAM,OAAO,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;IAClE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,IAAI,EAAE,CAAA;IACzC,MAAM,KAAK,GAAqB;QAC9B,KAAK;QACL,IAAI,EAAE,OAAO,CAAC,OAAO;QACrB,IAAI;QACJ,GAAG,IAAI;QACP,GAAG,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;KAC1F,CAAA;IAED,OAAO,KAAK,CAAA;AACd,CAAC,CAAA"}

package/build/types.d.ts

@@ -1,35 +1,60 @@
-import type { AppType, BasicContext, BasicConfig } from '@owlmeans/context';
+import type { AppType, EntrypointReference } from '@owlmeans/context';
 import type { RouteProtocols, RouteMethod } from './consts';
-export interface CommonRoute extends BasicRoute {
+/** A built-in or package-owned transport identifier. */
+export type RouteProtocol = RouteProtocols | (string & {});
+export interface BasicRoute {
+    type: AppType;
+    service?: string;
+    host?: string;
+    port?: number;
+    base?: string;
+    internalHost?: string;
+    internalPort?: number;
+}
+/**
+ * The plain, declarative half of a route — what a `route()` call produces and what an application
+ * ships in its contract package. It is never rewritten: `path` stays the segment this route
+ * contributes under its parent, and the address is worked out on demand against a context.
+ */
+export interface RouteDeclaration extends BasicRoute {
     alias: string;
     path: string;
     parent?: string;
     default?: boolean;
     method?: RouteMethod;
-    protocol?: RouteProtocols;
+    protocol?: RouteProtocol;
     secure?: boolean;
+    /** Transport-owned declaration data. The package defining `protocol` owns and validates it. */
+    protocolOptions?: unknown;
+    /** How long a caller waits for an answer, in milliseconds, when the transport supports it. */
+    timeout?: number;
 }
 export interface CommonServiceRoute extends BasicRoute {
     home?: string;
     service: string;
     default?: boolean;
 }
-export interface BasicRoute {
-    type: AppType;
-    service?: string;
-    host?: string;
-    port?: number;
-    base?: string;
-    resolved: boolean;
-}
 export interface ResolvedServiceRoute extends CommonServiceRoute {
     host: string;
-    resolved: true;
 }
-export interface CommonRouteModel {
-    route: CommonRoute;
-    resolve: <C extends BasicConfig, T extends BasicContext<C>>(context: T) => Promise<CommonRoute>;
+/** Where a route actually answers, once its service has been picked. */
+export interface RouteAddress {
+    host: string;
+    port?: number;
+    base?: string;
+    secure: boolean;
+    protocol: RouteProtocol;
+}
+/**
+ * The model wrapping a declaration. It carries no resolution state of its own — every address
+ * question is answered from the declaration plus the context that asks.
+ */
+export interface RouteModel {
+    route: RouteDeclaration;
 }
-export interface RouteOptions extends Partial<CommonRoute> {
+export type RouteParent = string | EntrypointReference;
+export interface RouteOptions extends Omit<Partial<RouteDeclaration>, 'parent'> {
+    /** A parent protocol is preferred in application declarations; strings remain adapter input. */
+    parent?: RouteParent;
 }
 //# sourceMappingURL=types.d.ts.map