@owlmeans/create-app 0.1.18-rc.17 → 0.1.18-rc.19

package/README.md

@@ -65,8 +65,9 @@ is present even with `--no-install`.
 `--bare` keeps the three workspaces, the config/context/entrypoint wiring, the layout, the nav
 skeleton and one Home screen, and drops every piece of example code — the `SessionItem` types and
 schemas, the api's `app/session/**` handlers and its static resource, the About and Session screens.
-`sources/common/src/entrypoints.ts` exports an empty `sharedEntrypoints` that the api and the web
-already spread, so the first feature is one declaration plus a handler and a screen.
+`sources/common/src/entrypoints.ts` exports an immutable `appEntrypoints` tree with an empty `api`
+branch and the web routes. The API and web bind those branches locally, so the first feature adds a
+declaration to the tree, then a handler and a screen binding.
 
 What bare removes and what it swaps in is declared in `template/_bare.json`, next to the
 `.bare.`-infixed variants it points at — not in the scaffolder's code.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owlmeans/create-app",
-  "version": "0.1.18-rc.17",
+  "version": "0.1.18-rc.19",
   "license": "MIT",
   "description": "Scaffold a fullstack OwlMeans Common app — common + api + web workspaces, shadcn UI navigation/layout, no auth, and a session-scoped in-memory resource, or --bare for the demo-free shell. Also usable programmatically via scaffold(). Deploys agent skills via @owlmeans/agent-skills by default.",
   "type": "module",
@@ -30,7 +30,7 @@
     "template"
   ],
   "dependencies": {
-    "@owlmeans/agent-skills": "^0.1.18-rc.14"
+    "@owlmeans/agent-skills": "^0.1.18-rc.15"
   },
   "devDependencies": {
     "@owlmeans/dep-config": "workspace:*",

package/template/README.bare.md

@@ -34,10 +34,10 @@ bun run dev
 1. **`sources/common/src/entrypoints.ts`** — declare the route as an OwlMeans *entrypoint* and
    give it an AJV filter. Both sides import this one declaration; neither re-declares the route.
 2. **`sources/api`** — register a resource in `src/context.ts` (widening `Context` in
-   `src/types.ts`), then `elevate()` the entrypoint with a handler in `src/entrypoints.ts`.
+   `src/types.ts`), then `bind()` the entrypoint with a handler in `src/entrypoints.ts`.
 3. **`sources/web`** — add a screen under `src/screens`, hang it off a frontend route in
    `src/entrypoints.ts`, list it in `src/nav.ts`, and call the backend with
-   `context.entrypoint(alias).call({ params, body })`.
+   `context.entrypoint(protocol).call({ params, body })`.
 
 See the [OwlMeans getting-started guide](https://github.com/owlmeans/common/blob/main/docs/getting-started.md)
 for a worked example of all three steps.

package/template/README.md

@@ -2,71 +2,8 @@
 
 __APP_DESCRIPTION__
 
-A minimal fullstack [OwlMeans Common](https://github.com/owlmeans/common) app, scaffolded with
-[`@owlmeans/create-app`](https://www.npmjs.com/package/@owlmeans/create-app).
+An OwlMeans application has shared protocol declarations in `sources/common`, server bindings in
+`sources/api`, and browser bindings/screens in `sources/web`. Contracts, request schemas, guards
+and gates are declared once in common; runtime packages bind them without changing the declaration.
 
-No authentication; session data lives in an **in-memory static resource** on the backend.
-
-## Workspaces
-
-```
-sources/
-├── common/   # shared entrypoints (routes), schemas and types — used by api AND web
-├── api/      # @owlmeans/server-app backend; session items in @owlmeans/static-resource
-└── web/      # @owlmeans/web-panel + shadcn UI: navigation, layout and screens
-```
-
-## Develop
-
-```sh
-bun install
-bun run dev
-```
-
-- API: http://localhost:3000
-- Web: http://localhost:3001
-
-Open the **Session** page and add/remove items — they are stored per browser session
-(a `sid` kept in `localStorage`) in an in-memory resource on the API. Restarting the API
-clears them; opening a different browser/incognito window gets an isolated session.
-
-> **Note:** The API runs over plain HTTP in dev (`cfg.security = { unsecure: true }` in
-> `sources/common/src/config.ts`). If you edit `sources/common`, restart `bun run dev` to
-> rebuild it before the API and web pick up the changes.
-
-## How it fits together
-
-1. **`sources/common`** declares the API routes as OwlMeans *entrypoints* (`session.list`,
-   `session.add`, `session.remove`) plus their AJV schemas and shared types.
-2. **`sources/api`** registers a `@owlmeans/static-resource` in its context and `elevate()`s
-   each entrypoint with a handler that does CRUD against it, keyed by the session id.
-3. **`sources/web`** `elevate()`s the same entrypoints to screen components and calls them with
-   `context.entrypoint(alias).call({ params, body })`.
-
-See [OwlMeans getting-started guide](https://github.com/owlmeans/common/blob/main/docs/getting-started.md)
-for a full walkthrough and the manual (non-scaffolded) version of this project.
-
-## Agent guidance
-
-Always-on project context lives in `AGENTS.md`, which every agent reads; `CLAUDE.md` is a thin
-bridge that imports it. It carries the four mandatory sections a real OwlMeans monorepo uses —
-**Git Workflow**, **Reporting**, **Memory**, **Self-Education** — plus a project-purpose
-placeholder the agent fills in on its first session.
-
-Project memory is a single shared graph store at `.agents/memory/` (index `MEMORY.md`), used by
-every agent — never write memory anywhere else.
-
-Reusable guidance is one skill per topic at `.agents/skills/<name>/SKILL.md` — the
-[Agent Skills](https://agentskills.io) standard location, read natively by Copilot and Codex.
-Claude Code reads them through the generated per-skill symlinks under `.claude/skills/`, which
-`sh .agents/scripts/link-skills.sh` (re)creates; the committed `SessionStart` hook runs it each
-session. Never author a file under `.claude/skills/`.
-
-Files carrying an `AUTO-GENERATED` banner are managed by
-[`@owlmeans/agent-skills`](https://www.npmjs.com/package/@owlmeans/agent-skills) — don't hand-edit
-them; write your own guidance as separate, un-bannered files. Refresh after adding or upgrading
-`@owlmeans/*` packages:
-
-```sh
-npx @owlmeans/agent-skills@^0.1.18-rc.12
-```
+Use `bun run build` from the project root to build every workspace.

package/template/_agents/skills/getting-started/SKILL.md

@@ -1,152 +1,45 @@
 ---
 name: getting-started
-description: How to build a fullstack OwlMeans Common app from scratch — the common/api/web three-workspace pattern, context bootstrap on server and web, shared entrypoints + elevate(), and a session-scoped in-memory resource with @owlmeans/static-resource. Use when starting a new OwlMeans project, wiring web↔api, or asked how the pieces fit together.
-user-invocable: true
+description: Start a protocol-first OwlMeans application with shared contracts, server entrypoints and browser entrypoints.
 metadata:
   scope: general
 ---
 <!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
 
-# Getting started with OwlMeans Common — fullstack app shape
+# Protocol-first application shape
 
-A minimal OwlMeans app is a **bun-workspace monorepo with three packages**:
-
-```
-sources/
-├── common/   # shared entrypoints (routes), AJV schemas, types, config — the single source of truth
-│             #   entrypoints.ts
-├── api/      # @owlmeans/server-app backend; handlers attached to the shared entrypoints
-│             #   context.ts, entrypoints.ts, app/<area>/*, index.ts
-└── web/      # @owlmeans/web-panel + shadcn UI; screens attached to the same entrypoints
-              #   context.ts, entrypoints.ts, nav.ts, layout/, screens/, render.tsx, index.tsx
-```
-
-Three workspaces is the whole shape — a backend that needs its own long-running worker or a second
-API adds a workspace beside them and shares the same `common`.
-
-The full, runnable walkthrough (scaffolded **and** manual) lives in the
-[OwlMeans getting-started guide](https://github.com/owlmeans/common/blob/main/docs/getting-started.md).
-To generate this exact project, use [[scaffolding]] (`npm create @owlmeans/app`). This skill is the
-mental model.
-
-## The core idea: one contract, two sides
-
-Declare each route once in `common` as an **entrypoint**, then `elevate()` it on each side:
-
-```ts
-// common/entrypoints.ts — declaration + validation, no implementation
-export const sessionEntrypoints = [
-  entrypoint(route(session.base, '/session')),
-  entrypoint(route(session.list, '/:sid/items', { parent: session.base, method: RouteMethod.GET }),
-    filter(params<SessionParams>(SessionParamsSchema))),
-  entrypoint(route(session.add, '/:sid/items', { parent: session.base, method: RouteMethod.POST }),
-    filter(params<SessionParams>(SessionParamsSchema, body<AddItemPayload>(AddItemSchema)))),
-]
-```
-
-```ts
-// api/entrypoints.ts — attach handlers
-elevate(sessionEntrypoints, session.list, handlers.list)
-export const appEntrypoints = [...entrypoints, ...sessionEntrypoints]   // `entrypoints` = framework defaults
-```
-
-```ts
-// web/entrypoints.ts — attach screen components, plus call-only elevation for backend routes
-const entrypoints = [...baseEntrypoints, ...sessionEntrypoints]   // `baseEntrypoints` from web-panel
-elevate(entrypoints, session.list)                                // callable from the client
-entrypoints.push(entrypoint(route(web.session, '/session', frontend({ parent: BASE })), handler(SessionScreen)))
-export const appEntrypoints = entrypoints
-```
-
-A route declaration is plain data: its `path` is the SEGMENT it contributes under its `parent`, and
-nothing ever rewrites it. `session.list` reads `/:sid/items` under `session.base`'s `/session`,
-under the api service's `base: 'api'` — so the address is `GET /api/session/:sid/items`, computed
-on demand by whoever asks. `elevate` is idempotent, so re-elevating an alias is allowed and guards
-given at elevation are added to the declared ones.
-
-Change a route or schema in `common` and both sides stay in sync. See [[entrypoint]], [[route]],
-[[server-app]], [[web-client]], [[web-panel]].
-
-## Shared config (where services live)
-
-`common/config.ts` registers both services so the web knows where the API is. `base: 'api'`
-prefixes API routes with `/api`:
+An OwlMeans application owns one shared protocol declaration and creates local entrypoints for each
+runtime. The declaration is never modified by a server or browser.
 
 ```ts
-const cfg = service({ type: AppType.Frontend, service: APP_WEB, host: 'localhost', port: 3001 })
-service({ type: AppType.Backend, service: APP_API, host: 'localhost', port: 3000, base: 'api' }, cfg)
-cfg.debug = { all: true }
-cfg.alias = APP
-cfg.security = { unsecure: true }   // local dev serves the API over plain HTTP
-export const commonConfig = cfg
+// common/src/entrypoints.ts
+export const sessionEntrypoints = {
+  list: protocol(
+    route(session.list, '/session', backend()),
+    contract.request({ query: typed<SessionQuery>(SessionQuerySchema) }, typed<Session[]>())
+  ),
+}
 ```
 
-api: `config(APP_API, commonConfig)` (+ `cfg.port`). web: `config(APP_WEB, commonConfig)`. See [[config]].
-
-## Backend bootstrap + in-memory data
-
 ```ts
-// api/context.ts
-const context = makeContext(cfg, true)          // from @owlmeans/server-app
-appendStaticResource(context, SESSION_ITEMS)    // @owlmeans/static-resource — in-memory, no DB
+// api/src/entrypoints.ts
+const api = handlers<Context>()
+export const appEntrypoints = [
+  ...frameworkEntrypoints,
+  bind(sessionEntrypoints.list, api.request(sessionEntrypoints.list, listSessions)),
+]
 ```
 
-Handlers use `handleRequest` / `handleBody` / `handleParams` (validated payload, then context, then
-req). Read/write `ctx.getStaticResource<T>(alias)` — the full resource contract
-(`get/load/list/count/create/update/save/delete/take/purge`), so the resource answers the whole
-question rather than the handler filtering afterwards:
-
 ```ts
-const { items } = await resource.list(
-  { sessionId: params.sid },
-  { sort: [{ field: 'createdAt', order: 'desc' }] }
-)
-```
-
-`list` returns `{ items, total }`; the in-memory backends are unpaged unless a `size` is asked for.
-`main(context, appEntrypoints)` starts the server. See [[static-resource]], [[server-app]],
-[[resource]].
-
-Swap `@owlmeans/static-resource` for [[mongo-resource]] / [[redis-resource]] when you need
-persistence — the handler shape is identical.
-
-## Web bootstrap (shadcn)
-
-`@owlmeans/web-panel`'s `PanelApp` is shadcn/Tailwind v4 (no MUI). The **app provides** the shadcn
-primitives at the `@` alias — `web-panel` references `@/lib/utils` and
-`@/components/ui/{alert,button,card,input,label,navigation-menu,progress}`; copy those into `src/`.
-Routing resolves itself from the active router plugin, so `PanelApp` takes no router prop —
-`render.tsx` is one line and `index.tsx` calls it:
-
-```tsx
-// render.tsx — import { render as basicRender } from '@owlmeans/web-client'
-basicRender(<PanelApp context={context} />)
-```
-
-`vite.config.ts` sets `@`→`src`, `@tailwindcss/vite`, and dedupes the owlmeans/react singletons.
-`index.css` is `@import "tailwindcss";` + a shadcn `@theme` token block (replaces `@owlmeans/owl-theme`).
-A parent `BASE` route renders the layout via `handler(MainLayout)`; `HOME` is its default child, declared `frontend({ default: true, parent: BASE })`.
-`index.tsx` calls `context.registerEntrypoints(appEntrypoints)` and `context.serviceRoute(...)` for
-each service, then renders.
-
-Screens address the backend through three explicit verbs on the entrypoint:
+// web/src/entrypoints.ts
+export const appEntrypoints = [
+  ...frameworkEntrypoints,
+  ...bindAll(sessionEntrypoints),
+]
 
-```tsx
-const items = await ctx.entrypoint<ClientEntrypoint<Item[]>>(session.list).call({ params: { sid } })
-const { value, outcome } = await ctx.entrypoint<ClientEntrypoint<Item>>(session.add).invoke({ body })
-const href = await ctx.entrypoint<ClientEntrypoint<string>>(web.about).url()
+const sessions = await context.entrypoint(sessionEntrypoints.list).call({ query: { sid } })
 ```
 
-`call` resolves to the VALUE and throws the reply's error; `invoke` gives `{ value, outcome }` when
-the outcome decides what happens next; `url` gives the address (`{ absolute: true }` forces a fully
-qualified one). A screen entrypoint answers `url()` and refuses `call()` — a screen is navigated to.
-See [[web-panel]], [[web-client]], [[shadcn-web]], [[client-entrypoint]].
-
-The screen keeps nothing in component state: `makeContext` registers a `@owlmeans/state` resource,
-the fetch writes what came back into it with `store.replace(items)`, and `useStoreList` renders the
-live subscription. See [[state]].
-
-## Authentication
-
-This shape is intentionally **auth-free**. To add it: `@owlmeans/server-auth` + `@owlmeans/client-auth`
-and `guard(...)` on entrypoints. See [[auth-protocol]], [[server-auth]], [[client-auth]].
+Use `schema<T>(...)` or `typed<T>(...)` at the contract boundary. Bind all route parents with their
+children. Keep organization entity values on the wire as `entitySlug`; database relations use
+`entityId` only.

package/template/_agents/skills/reuse-code/SKILL.md

@@ -57,7 +57,7 @@ other `@owlmeans/*` packages:
 
 ```json
 "dependencies": {
-  "@owlmeans/queue": "^0.1.18-rc.11"
+  "@owlmeans/queue": "^0.1.18-rc.12"
 }
 ```
 

package/template/sources/api/package.json

@@ -11,8 +11,8 @@
     "typecheck": "tsc -b"
   },
   "dependencies": {
-    "@owlmeans/server-app": "^0.1.18-rc.19",
-    "@owlmeans/static-resource": "^0.1.18-rc.10",
+    "@owlmeans/server-app": "^0.1.18-rc.21",
+    "@owlmeans/static-resource": "^0.1.18-rc.12",
     "__APP_SLUG__-common": "workspace:^"
   },
   "devDependencies": {

package/template/sources/api/src/entrypoints.bare.ts

@@ -1,5 +1,4 @@
-import { elevate, entrypoints } from '@owlmeans/server-app'
-import { sharedEntrypoints } from '__APP_SLUG__-common'
+import { entrypoints } from '@owlmeans/server-app'
 
-// Handlers bind to a protocol; a bare shell starts without any implementations.
-export const appEntrypoints = [...entrypoints, ...elevate(sharedEntrypoints, [])]
+// The bare shell has no API declarations yet. Bind new protocols here as they are added.
+export const appEntrypoints = [...entrypoints]

package/template/sources/api/src/entrypoints.ts

@@ -1,8 +1,13 @@
-import { elevate, entrypoints } from '@owlmeans/server-app'
-import { sessionEntrypoints } from '__APP_SLUG__-common'
+import { entrypoints } from '@owlmeans/server-app'
+import { bind } from '@owlmeans/server-entrypoint'
+import { appEntrypoints as protocols } from '__APP_SLUG__-common'
 import * as handlers from './app/session/index.js'
 
-// Each handler is already bound to its protocol; elevation materializes the local server entries.
-const sessionModules = elevate(sessionEntrypoints, [handlers.list, handlers.add, handlers.remove])
-
-export const appEntrypoints = [...entrypoints, ...sessionModules]
+/** Local server bindings for the shared session protocol tree. */
+export const appEntrypoints = [
+  ...entrypoints,
+  bind(protocols.api.session.base),
+  bind(protocols.api.session.list, handlers.list),
+  bind(protocols.api.session.add, handlers.add),
+  bind(protocols.api.session.remove, handlers.remove),
+]

package/template/sources/common/package.json

@@ -19,11 +19,11 @@
     "typecheck": "tsc -b"
   },
   "dependencies": {
-    "@owlmeans/config": "^0.1.18-rc.13",
-    "@owlmeans/entrypoint": "^0.1.18-rc.12",
-    "@owlmeans/error": "^0.1.18-rc.9",
-    "@owlmeans/resource": "^0.1.18-rc.10",
-    "@owlmeans/route": "^0.1.18-rc.10",
+    "@owlmeans/config": "^0.1.18-rc.15",
+    "@owlmeans/entrypoint": "^0.1.18-rc.14",
+    "@owlmeans/error": "^0.1.18-rc.11",
+    "@owlmeans/resource": "^0.1.18-rc.12",
+    "@owlmeans/route": "^0.1.18-rc.12",
     "ajv": "^8.17.1"
   },
   "devDependencies": {

package/template/sources/common/src/entrypoints.bare.ts

@@ -1,8 +1,14 @@
-import type { EntrypointProtocol } from '@owlmeans/entrypoint'
+import { openProtocol } from '@owlmeans/entrypoint'
+import { BASE, HOME } from '@owlmeans/context'
+import { frontend, route } from '@owlmeans/route'
 
-/**
- * The entrypoint declarations both sides share: the api elevates them with handlers, the web
- * elevates them with screens or just calls them. Routes resolve under the api service `base`
- * (`/api`), so an `entrypoint(route(alias, '/items', ...))` added here answers on `/api/items`.
- */
-export const sharedEntrypoints: EntrypointProtocol[] = []
+const webBase = openProtocol(route(BASE, '/', frontend()))
+
+/** The shared immutable protocol tree. Add API declarations below `api` as the shell grows. */
+export const appEntrypoints = {
+  api: {},
+  web: {
+    base: webBase,
+    home: openProtocol(route(HOME, '/', frontend({ default: true, parent: webBase }))),
+  },
+}

package/template/sources/common/src/entrypoints.ts

@@ -1,4 +1,4 @@
-import { contract, openProtocol, protocol, protocols, typed } from '@owlmeans/entrypoint'
+import { contract, openProtocol, protocol, typed } from '@owlmeans/entrypoint'
 import { route, RouteMethod, frontend } from '@owlmeans/route'
 import { AddItemSchema, ItemParamsSchema, SessionParamsSchema } from './schemas.js'
 import type { SessionItem } from './types.js'
@@ -22,8 +22,8 @@ const sessionBase = protocol(route(aliases.session.base, '/session'), contract()
 const webBase = openProtocol(route(aliases.web.base, '/', frontend()))
 
 /**
- * Shared entrypoint declarations. The api elevates these with handlers; the web
- * elevates them with screen components and calls them. Routes resolve under the
+ * Shared entrypoint declarations. The api materializes these with handlers; the web
+ * materializes them with screen components and calls them. Routes resolve under the
  * api service `base` (`/api`), so e.g. `session.list` → `GET /api/session/:sid/items`.
  */
 export const session = {
@@ -53,4 +53,8 @@ export const web = {
   about: openProtocol(route(aliases.web.about, '/about', frontend({ parent: webBase }))),
 }
 
-export const sessionEntrypoints = protocols(session)
+/** The shared immutable protocol tree. Runtime packages bind their own local handlers and screens. */
+export const appEntrypoints = {
+  api: { session },
+  web,
+}

package/template/sources/web/package.json

@@ -11,16 +11,16 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@owlmeans/client": "^0.1.18-rc.17",
-    "@owlmeans/client-config": "^0.1.18-rc.13",
-    "@owlmeans/client-context": "^0.1.18-rc.14",
-    "@owlmeans/client-entrypoint": "^0.1.18-rc.14",
-    "@owlmeans/client-i18n": "^0.1.18-rc.16",
-    "@owlmeans/entrypoint": "^0.1.18-rc.12",
-    "@owlmeans/route": "^0.1.18-rc.10",
-    "@owlmeans/state": "^0.1.18-rc.11",
-    "@owlmeans/web-client": "^0.1.18-rc.25",
-    "@owlmeans/web-panel": "^0.1.18-rc.33",
+    "@owlmeans/client": "^0.1.18-rc.19",
+    "@owlmeans/client-config": "^0.1.18-rc.15",
+    "@owlmeans/client-context": "^0.1.18-rc.16",
+    "@owlmeans/client-entrypoint": "^0.1.18-rc.16",
+    "@owlmeans/client-i18n": "^0.1.18-rc.18",
+    "@owlmeans/entrypoint": "^0.1.18-rc.14",
+    "@owlmeans/route": "^0.1.18-rc.12",
+    "@owlmeans/state": "^0.1.18-rc.13",
+    "@owlmeans/web-client": "^0.1.18-rc.27",
+    "@owlmeans/web-panel": "^0.1.18-rc.35",
     "@radix-ui/react-label": "^2.1.0",
     "@radix-ui/react-navigation-menu": "^1.2.14",
     "@radix-ui/react-progress": "^1.1.0",

package/template/sources/web/src/entrypoints.bare.ts

@@ -1,13 +1,13 @@
-import { BASE, bind, entrypoint, entrypoints as baseEntrypoints, frontend, handler, HOME, route } from '@owlmeans/web-panel'
-import { sharedEntrypoints } from '__APP_SLUG__-common'
+import { bindAll, bindScreen, entrypoints as baseEntrypoints, handler } from '@owlmeans/web-panel'
+import { appEntrypoints as protocols } from '__APP_SLUG__-common'
 import { MainLayout } from './layout/main.js'
 import { HomeScreen } from './screens/home.js'
 
-// Backend protocol declarations are materialized locally so each can be called from the browser.
-const entrypoints = [...baseEntrypoints, ...sharedEntrypoints.map(protocol => bind(protocol))]
-
-// Frontend layout + screens. BASE renders the shared layout; HOME is its default child.
-entrypoints.push(entrypoint(route(BASE, '/', frontend()), handler(MainLayout)))
-entrypoints.push(entrypoint(route(HOME, '/', frontend({ default: true, parent: BASE })), handler(HomeScreen)))
-
-export const appEntrypoints = entrypoints
+/** Local browser bindings for shared API and screen protocols. */
+export const appEntrypoints = [
+  ...baseEntrypoints,
+  ...bindAll(protocols.api),
+  // BASE renders the shared layout; HOME is its default child.
+  bindScreen(protocols.web.base, handler(MainLayout)),
+  bindScreen(protocols.web.home, handler(HomeScreen)),
+]

package/template/sources/web/src/entrypoints.ts

@@ -1,16 +1,16 @@
 import { bindAll, bindScreen, entrypoints as baseEntrypoints, handler } from '@owlmeans/web-panel'
-import { session, web } from '__APP_SLUG__-common'
+import { appEntrypoints as protocols } from '__APP_SLUG__-common'
 import { MainLayout } from './layout/main.js'
 import { AboutScreen } from './screens/about.js'
 import { HomeScreen } from './screens/home.js'
 import { SessionScreen } from './screens/session.js'
 
-const entrypoints = [...baseEntrypoints, ...bindAll(session)]
-
-// Frontend protocol declarations bind to renderers in the web project.
-entrypoints.push(bindScreen(web.base, handler(MainLayout)))
-entrypoints.push(bindScreen(web.home, handler(HomeScreen)))
-entrypoints.push(bindScreen(web.session, handler(SessionScreen)))
-entrypoints.push(bindScreen(web.about, handler(AboutScreen)))
-
-export const appEntrypoints = entrypoints
+/** Local browser bindings for shared API and screen protocols. */
+export const appEntrypoints = [
+  ...baseEntrypoints,
+  ...bindAll(protocols.api),
+  bindScreen(protocols.web.base, handler(MainLayout)),
+  bindScreen(protocols.web.home, handler(HomeScreen)),
+  bindScreen(protocols.web.session, handler(SessionScreen)),
+  bindScreen(protocols.web.about, handler(AboutScreen)),
+]

package/template/sources/web/src/index.css

@@ -5,7 +5,7 @@
  * scan by default — so the classes that exist ONLY inside @owlmeans/web-panel components
  * (the navigation shell, the footer) would never reach the stylesheet. This line adds them.
  */
-@source "../../../node_modules/@owlmeans/web-panel/build";
+@source "../../../node_modules/@owlmeans/web-panel/src";
 
 /*
  * shadcn / Tailwind v4 design tokens (new-york, neutral). The app owns these — they