@akanjs/cli 3.0.0-alpha.102 → 3.0.0-alpha.104

package/guidelines/mcpRule/mcpRule.instruction.md

@@ -73,7 +73,7 @@ export const option = new AkanOption<ModulesOptions>().setMcp({
 ```
 
 ```typescript
-// <model>.signal.ts — every one of these is an MCP tool or prompt, with no `mcp:` option anywhere
+// <model>.signal.ts — every one of these is an MCP tool, with no `mcp:` option anywhere
 export class TaskSlice extends slice(
   srv.task,
   { guards: { root: Admin, get: SignedIn, cru: SignedIn } },
@@ -86,21 +86,26 @@ export class TaskSlice extends slice(
   }),
 ) {}
 
-export class TaskEndpoint extends endpoint(srv.task, ({ mutation, prompt }) => ({
+export class TaskEndpoint extends endpoint(srv.task, ({ mutation }) => ({
   startTask: mutation(cnst.Task, { guards: [SignedIn] })
     .param("taskId", ID)
     .exec(async function (taskId) {
       return await this.taskService.startTask(taskId);
     }),
-  reviewTask: prompt({ guards: [SignedIn] })
-    .param("taskId", ID)
-    .exec(async function (taskId) {
-      const task = await this.taskService.getTask(taskId);
-      return [Msg.user(`Review this task and suggest next steps.`), Msg.resource(`akan://task/${taskId}`, task)];
-    }),
 })) {}
 ```
 
+```tsx
+// page/task/[taskId]/_index.tsx — the screen, published to agents as the prompt `reviewTask`
+export default page()
+  .param("taskId", ID, { desc: "The task to review." })
+  .prompt("reviewTask", "Review this task and suggest next steps.")
+  .render(async ({ taskId }) => {
+    const { taskView } = await fetch.viewTask(taskId);
+    return <Task.Zone.View view={taskView} />;
+  });
+```
+
 ## Refusals And Wire Behaviour
 - **`mcp: false` is read first**, because it is the one answer nobody had to derive — somebody stated it. Its
   reason says "HTTP still serves it", because that is the sentence that stops the next reader treating it as a lock.
@@ -111,16 +116,13 @@ export class TaskEndpoint extends endpoint(srv.task, ({ mutation, prompt }) => (
   **`light<Model>` read** — it returns the same document as `<Model>` under the same guards, in a shape trimmed
   for a page's payload, so publishing both put two entries per model in a listing an agent pays for every turn
   and gave it nothing but the word "light" to choose between them.
-  A `prompt` refuses two more, because its `arguments` is one string per name with no schema beside it: a **list
-  argument**, which could never carry a second value, and **any `Any` argument** — a tool leaves that out of its
-  schema, and a prompt has no schema to leave it out of.
 - **The boot log sizes the catalogue and says which signals it went to** — `MCP catalogue: tools=48 … · listing
   214KB` and `MCP catalogue cost: user 27/71KB · file 6/22KB · …`, heaviest first. Read it before narrowing
   anything: the number is nobody's intuition, because MCP has no shared component section and forbids a `$ref`
   across entries, so **every entry inlines the full schema of every model it mentions** and a listing is re-sent
   whole to every agent that connects, before its first turn. Past 100KB it says so as a `warn`.
-- **Every refusal is named in the boot log**: one `warn` per endpoint plus a `MCP catalogue: tools=… prompts=…`
-  count. Read that line first when a tool you expected is missing — and it is the *only* place the answer exists,
+- **Every refusal is named in the boot log**: one `warn` per endpoint plus a `MCP catalogue: tools=…
+  resourceTemplates=…` count, and a `MCP page prompts: N (…)` line once the RSC worker has listed the pages. Read that line first when a tool you expected is missing — and it is the *only* place the answer exists,
   because there is no absent opt-in to notice. The API explorer badges the same rule per endpoint (`MCP` /
   `MCP refused`), from the same shared implementation the catalogue runs.
 - **An `Any` argument is left out of the published schema** rather than described as `{}` — it tells a model
@@ -146,7 +148,8 @@ export class TaskEndpoint extends endpoint(srv.task, ({ mutation, prompt }) => (
   doubling of what every model-returning tool costs a model. `option.setMcp({ legacyTextBlock: false })` — or
   `AKAN_MCP_LEGACY_TEXT=false` — leaves a one-line pointer in the text block instead, for a deployment whose
   clients read the structured half. A scalar return is unaffected: it has no structured half to point at, so it
-  ships as the value itself either way.
+  ships as the value itself either way. `resources/read` is unaffected too: `ReadResourceResult` has no
+  `structuredContent`, so a resource's text is its only channel and always carries the serialized value.
 - **A request schema asks for a relation's id, and a response schema names a nested model.** `serialize` sends a
   relation field as its id and the server never converts an object back, so publishing the related model's shape
   asked an agent for what the document layer cannot take. On the response side every entry inlines the transitive
@@ -213,9 +216,9 @@ export class TaskEndpoint extends endpoint(srv.task, ({ mutation, prompt }) => (
   which is in force, and warns when it is off.
 - **A `resources/read` uri that does not decode** — a stray `%` — is `Unknown resource`, not a server failure.
 - **A caller's own mistake is reported as one** and never as a server failure: an argument that is missing,
-  unparseable or **undeclared** comes back as `isError` naming it — `additionalProperties: false` travels in the
+  unparseable, outside its `enumOf`, or **undeclared** comes back as `isError` naming it — `additionalProperties: false` travels in the
   published schema and nothing on the wire enforces it — and so does a document that is not there, as
-  `No <model> found for the arguments given.` A `prompt`, having no `isError` to carry a refusal, answers `-32602`.
+  `No <model> found for the arguments given.` A prompt, having no `isError` to carry a refusal, answers `-32602`.
   Only a real failure logs a stack; an agent can drive the rest at will.
 - **Three revisions are spoken**: the modern `2026-07-28` and the legacy `2025-11-25` / `2025-06-18`, which are
   wire-identical over the POST-only surface this implements — a client whose proposal is not listed is told to
@@ -225,7 +228,7 @@ export class TaskEndpoint extends endpoint(srv.task, ({ mutation, prompt }) => (
 - **A modern-era request mirrors `MCP-Protocol-Version` and `Mcp-Method` into headers** (plus `Mcp-Name` when the
   body names one), and one that leaves a mirror out is refused just like one that contradicts the body: a gateway
   rule keyed on a header never fires for the request that omitted it. Legacy requests are not checked. Capabilities
-  are derived from the catalogue, so a server with no prompts does not advertise `prompts`.
+  are derived from the catalogue; `prompts` is advertised when the build serves pages, since prompts are theirs.
 - **An expired, wrongly-audienced or unverifiable bearer token is refused up front**, so an agent is told to
   authenticate rather than that the tool does not exist. The signature is checked through `auth.verify`, which the
   module that mints the tokens supplies (`libs/shared` does, from the app's signing secret); without a verifier the
@@ -313,23 +316,41 @@ delegates to lives in `akanjs/server` (`OAuthAuthorize`, `OAuthToken`, `OAuthReg
   derived fallback is seeded from the app, environment and repo names and forges an admin token for anyone who
   knows them. `AKAN_ALLOW_DERIVED_JWT_SECRET=1` accepts that risk explicitly.
 
-## `prompt()`
-**`prompt()`** is invoked by the *user* — a client renders it as a slash command — not chosen by the model. `exec`
-returns `PromptMessage[]`, or a bare string that is wrapped into one user message; build them with `Msg.user` /
-`Msg.assistant` / `Msg.link` / `Msg.resource` / `Msg.image` / `Msg.imageOf`. It takes `.param()` and `.search()`
-only, because `prompts/get` sends a flat string map. **An embedded payload is masked by the model you name** —
-`Msg.resource(uri, task, { model: cnst.LightTask })`, or `Msg.mask(cnst.LightTask, task)` for one piece of an
-assembly. Taking the model as an argument is what makes a `{ ...doc }` spread maskable, since that and `toJSON()`
-arrive with the class already gone; a value with no model named whose `hidden`/`secret` fields are populated is
-**refused**, one level into a plain object too. **A `prompt` is also mounted as a
-plain HTTP `GET` whether or not you enabled MCP**, because that route is what lets a web UI preview one — and it
-is in your OpenAPI document like any other `GET`, answering the one fixed `PromptMessage[]` shape. MCP exposure
-gates the catalogue, not the surface, so guard it
-like any other read — and a prompt declaring no
-`guards` at all is named in the boot log, while an explicit `[Public]` is a decision and stays quiet. Every `Msg` builder takes
-optional `annotations` last (`audience`, `priority` 0..1, `lastModified`) — give the instruction a high `priority`
-and its attachments a low one, or a client with a full window drops blocks by position and keeps the attachment
-over the ask.
+## Page Prompts — `page().prompt()`
+**A prompt is a screen.** There is no `prompt()` on `endpoint()`: the page file declares it —
+`page().param("projectId", ID, { desc: "The project to brief." }).prompt("briefProjectTickets", "Brief the ticket
+board of one project.").render(…)` — and that is the whole surface. `prompts/list` is every page carrying
+`.prompt()`; its `.param()` stages are the required arguments and its `.search()` stages the optional ones, a list
+argument is comma-separated on the wire and its description says so, and an `ID`/`Int`/`enumOf` value is checked by
+the page's own declaration. **`prompts/get` runs the page's body** — root layouts, layouts, then the page's
+`.render()` — in the RSC worker under the caller's bearer token, the way a tab would open it. Nothing is rendered:
+the JSX comes back as an element tree nobody walks, no client component runs, and the screen's data footprint is
+exactly the `fetch.*` queries its body made, with the arguments it made them with. The answer is the description as
+the first message (priority 1), one embedded `resource` per query masked by that endpoint's return model and
+addressed by the `akan://` uri the tool answers to (`akan://<toolKey>?args` for a custom read) — one document read
+in two shapes, a layout's `project` beside the page's `lightProject`, travels once as the larger — and a closing
+`Tools for this screen: …` line naming the published tools of the modules the screen fetched from, minus the reads
+whose answers are attached above and filtered to what this caller may see — which is how a model reading a ticket
+board is handed the ticket tools and not three hundred. Lists are cut to `promptBudget` (60,000 characters;
+`option.setMcp({ promptBudget })`, `AKAN_MCP_PROMPT_BUDGET`), largest first, and the cut is said: `Attached the
+first 20 of 341 rows of \`ticketListInProject\`; call it for the rest.` Only lists are cut — a single document rides
+whole, so the budget is what the lists are trimmed to fit under, not a ceiling a screen of large documents cannot
+pass. A layout's own queries (a project selector's `projectListInOrg`) are part of every screen under it and are
+attached too. **No argument fallback**: a required argument left out answers one message — `No projectId was named for
+"briefProjectTickets". Find it with \`projectListBySearch\`, then run this prompt again with projectId=<id>.` —
+and runs nothing, because a prompt cannot re-run itself and context filled in on a guess would never be used. A
+page that redirects (`getSelf({ unauthorize })`), or whose `fetch.*` a guard refuses with 401/403, answers the 401
+credential challenge when the call carried no token and `This screen is not available to the signed-in account.`
+when it did — the same sentence for both, so a refused id is never confirmed to exist; `router.notFound()` and a
+404 from a query are `No screen exists for these arguments.`; anything else the body throws is `The page failed to
+load.`, with the cause in the server log only. **The description is the only instruction.** `<Agent.Guide>` is for the in-page agent, whose
+levers are the screen's controls, and is never read here, where the levers are the API — so write the description
+in English, in the API's vocabulary, and put a computed rule (the legal status transitions) into it as a static
+table the model combines with the attached state. Names match `^[A-Za-z0-9_-]{1,64}$` and are unique across pages;
+two pages claiming one name fail the listing. An API-only build (`web: false`) publishes no prompts, and the
+in-page chat lists none of them: its `/` menu is its six built-in commands. Pick which screens to publish by this
+rule: a page taking no arguments is the most useful prompt, since MCP has no completion — one taking an id is for
+when the id is already in hand.
 
 ## Progress Reporting
 **`McpProgress.report(n, { total, message })`** reports progress from anywhere inside a call, a service or adapter
@@ -399,8 +420,8 @@ the same guards.** What stays closed is closed because no agent has a reason to
 ## Writing `instructions`
 
 `*.abstract.md` and `<Agent.Guide>` never reach an MCP client. Exactly three texts do: `instructions`, every
-published entry's `.desc()`, and a `prompt()`. All three are English, whatever the users speak — the reader is a
-model, and the catalogue is built once in one `language` and cached by clients.
+published entry's `.desc()`, and a page's `.prompt()` description. All three are English, whatever the users speak
+— the reader is a model, and the catalogue is built once in one `language` and cached by clients.
 
 - **`instructions` is the workflow.** Five to eight sentences, in this order: what the app is and what its nouns
   mean; **which tool to call first** and which ids the rest take; how a name becomes an id; what a write confirms
@@ -419,9 +440,10 @@ model, and the catalogue is built once in one `language` and cached by clients.
 - **`.desc()` is the reason to pick one tool** — what it returns and when to use it, two clauses. An id argument's
   `.desc()` names the tool that returns it (`From projectInOrg`). The generated CRUD borrows the model's `.of()`
   label and `.desc()`, which is the only text those entries can carry.
-- **`prompt()` is a workflow the user invokes** as a slash command, not one the model chooses — a weekly report,
-  an onboarding check. Put the ask in `Msg.user` at a high `priority` and the attachments in `Msg.resource` masked
-  by their `Light` model at a low one.
+- **A page prompt is a workflow the user invokes** as a slash command, not one the model chooses — a weekly
+  report, an onboarding check. Its instruction is the `.prompt()` description alone and its attachments are what
+  the screen fetched, masked by their return models — so to change what a prompt hands the model, change what the
+  screen loads, and keep the description to the ask.
 
 ## Verifying An App
 

package/guidelines/ssrRule/ssrRule.instruction.md

@@ -84,19 +84,21 @@ whole detail surface renders server-side wherever a route uses the `View` direct
 sections actually need:
 
 ```tsx
-export default async function Page({ params: { orgId } }: PageProps) {
-  const { taskInitInOrg, taskListInOrg } = fetch.initTaskInOrg(orgId);
-  const { orgView } = fetch.viewOrg(orgId);
-  return (
-    <>
-      <Org.Zone.Header view={orgView} />
-      <Task.Zone.Card init={taskInitInOrg} />
-      <Load.Stream of={taskListInOrg} fallback={<Loading.Skeleton active />}>
-        {(taskList) => taskList.map((task) => <Task.Unit.Row key={task.id} task={task} />)}
-      </Load.Stream>
-    </>
-  );
-}
+export default page()
+  .param("orgId", ID)
+  .render(async ({ orgId }) => {
+    const { taskInitInOrg, taskListInOrg } = fetch.initTaskInOrg(orgId);
+    const { orgView } = fetch.viewOrg(orgId);
+    return (
+      <>
+        <Org.Zone.Header view={orgView} />
+        <Task.Zone.Card init={taskInitInOrg} />
+        <Load.Stream of={taskListInOrg} fallback={<Loading.Skeleton active />}>
+          {(taskList) => taskList.map((task) => <Task.Unit.Row key={task.id} task={task} />)}
+        </Load.Stream>
+      </>
+    );
+  });
 ```
 
 Both queries leave immediately — splitting the result never serializes them — and each section renders behind its

package/guidelines/workspaceOnboarding/workspaceOnboarding.instruction.md

@@ -5,7 +5,8 @@
 - `apps/<app>/lib/<model>` holds database-backed domain modules, `lib/_<service>` service modules, and
   `lib/__scalar/<scalar>` reusable value types. Module abstracts sit beside the code as `<name>.abstract.md`.
 - `apps/<app>/page` holds server-side file-routed pages: `<routeName>.tsx` serves `/routeName`, a directory's
-  `_index.tsx` serves that directory, `_layout.tsx` nests a layout, and `[modelId]` is a dynamic segment.
+  `_index.tsx` serves that directory, `_layout.tsx` nests a layout, and `[modelId]` is a dynamic segment. Each route
+  file is one chain — `export default page()…render()`, or `layout()` / `rootLayout()` in a `_layout.tsx`.
 
 The file roles inside a module — which file owns persistence, business logic, state, and each UI shape — are in
 the convention set above under **Domain Module Conventions**.
@@ -258,6 +259,6 @@ core framework. The core framework gives you the composition points below; wire
 - **Auto-generated CRUD and `serve()` service methods / lifecycle hooks do not receive session context.** If an
   operation needs the acting user, expose a custom endpoint that takes it via `.with(CurrentUserId)` — never trust a
   client-supplied user id.
-- **SSR auth-gated pages: guard at the layout.** Check the session in the `_layout.tsx` loader and redirect when it is
-  absent, so nested pages never render for signed-out users.
+- **SSR auth-gated pages: guard at the layout.** Check the session inside the `_layout.tsx` chain's `.render()` and
+  redirect when it is absent, so nested pages never render for signed-out users.
 

package/guidelines/workspaceRecipes/workspaceRecipes.instruction.md

@@ -186,11 +186,11 @@ export class TaskFilter extends from(cnst.Task, (filter) => ({
   })),
 }))
 
-// 4. In page — Init the slice in an async Page and hand the init to a Zone.
-export default async function Page() {
+// 4. In page — init the slice inside the page chain's render and hand the init to a Zone.
+export default page().render(async () => {
   const [{ taskInitInTodo }] = await Promise.all([fetch.initTaskInTodo()]);
   return <Task.Zone.Card init={taskInitInTodo} sliceName="taskInTodo" />;
-}
+});
 ```
 
 The slice name in code uses camelCase (`inTodo`). In dictionary and components it becomes `"taskInTodo"`.
@@ -328,6 +328,71 @@ export const Insight = ({ sliceName }: { sliceName: string }) => {
 
 ---
 
+### Recipe 7: Migrating `page/` to the Route Chain
+
+A route file used to be a default function beside named exports (`pageConfig`, `head`, `generateHead`, `Loading`,
+`fonts`, …). It is now one chain, and the chain is also what publishes a screen to agents. The legacy shape still
+loads and logs one warning per file at boot (`… uses the legacy route shape …`); migrate file by file, then run
+`bun run akan typecheck <app>` and `bun run akan lint <app>`.
+
+```tsx
+// before — page/(user)/project/[projectId]/_index.tsx
+import { fetch, usePage } from "@apps/<app>/client";
+import type { PageConfig } from "akanjs/client";
+
+interface PageProps {
+  params: { projectId: string };
+  searchParams: { tab?: string };
+}
+export function generateHead({ params }: PageProps) {
+  return <title>{params.projectId}</title>;
+}
+export default async function Page({ params: { projectId }, searchParams }: PageProps) {
+  const { l } = usePage();
+  const { project } = await fetch.viewProject(projectId);
+  return <Project.Zone.View view={project} tab={searchParams.tab} />;
+}
+export const pageConfig = { transition: "stack" } satisfies PageConfig;
+
+// after
+import { fetch, usePage } from "@apps/<app>/client";
+import { ID } from "akanjs/base";
+import { page } from "akanjs/client";
+
+export default page()
+  .param("projectId", ID, { desc: "The project to show." })
+  .search("tab", String)
+  .config({ transition: "stack" })
+  .head(({ projectId }) => <title>{projectId}</title>)
+  .prompt("briefProject", "Brief one project: its status and what is due.")
+  .render(async ({ projectId, tab }) => {
+    const { l } = usePage();
+    const { project } = await fetch.viewProject(projectId);
+    return <Project.Zone.View view={project} tab={tab} />;
+  });
+```
+
+| Legacy export | Chain stage |
+|---|---|
+| `interface PageProps { params }` + `[x]` folder | `.param("x", ID \| String \| Int \| …)` — one per `[x]` segment, every one of them, in path order |
+| `searchParams.k` | `.search("k", Type)`; `[Type]` for a repeated key; the value arrives typed and optional |
+| `params.lang` | `lang` — on every route's `.render()`, `.head()`, `.metadata()` and `.loading()` with no stage; `.param("lang")` is refused |
+| `export const pageConfig = {…}` | `.config({…})` — `devOnly` stays a literal |
+| `export const head = <…/>` / `generateHead({ params })` | `.head(<…/>)` / `.head(({ x }) => <…/>)` |
+| `export const metadata` / `generateMetadata` | `.metadata({…})` / `.metadata((args) => …)` |
+| `export function Loading()` | `.loading((args) => …)` |
+| `export default async function Page({ params, searchParams })` | `.render(async ({ x, k }) => { …same body… })` — `async` only if it awaits |
+| `_layout.tsx`: `export default function Layout({ children })` | `layout().render(({ children }) => …)` |
+| `export function NotFound` / `export function Error` | `.notFound(fn)` / `.error(fn)` on `layout()` |
+| root `_layout.tsx`: `fonts`, `theme`, `manifest`, `reconnect`, `wsConnect`, `layoutStyle`, `gaTrackingId` | `rootLayout().fonts([…]).theme("dark").manifest({…}).reconnect(false).wsConnect(false).layoutStyle("web").gaTrackingId("G-…")` |
+| `prompt()` on `endpoint()` (removed) | `.prompt(name, description)` on the page that shows the same screen |
+
+Rules the loader and `akan sync` enforce: a chain module has no other export; `page()` belongs in a page file and
+`layout()` / `rootLayout()` in a `_layout.tsx`; a page names every `[x]` of its path, a layout may name a subset;
+`.param()` and `.prompt()` names are string literals; `import "./styles.css"` stays the first line of a root layout;
+`_overrides.tsx` is untouched. MCP: `prompts/get` now runs the page's body under the caller's token and hands the
+model the description, what the page fetched, and the tools of those modules — see `mcpRule`.
+
 ### Data Flow Summary
 
 For each business question, follow this chain:

package/incrementalBuilder.proc.js

@@ -3,7 +3,7 @@ import {
   CodegenLock,
   WorkspaceExecutor,
   AppExecutor
-} from "./index-qsq3q8fy.js";
+} from "./index-2tv3fdx4.js";
 import"./index-q0y2jq9j.js";
 import"./index-6wwzs1bc.js";
 import {

package/{index-p5neav9b.js → index-0vh9rgxz.js}

@@ -2,7 +2,7 @@
 import {
   AsyncDefaultExportDetector,
   resolveSsrPageEntriesForApp
-} from "./index-qsq3q8fy.js";
+} from "./index-2tv3fdx4.js";
 import {
   BarrelAnalyzer,
   createBarrelImportsPlugin,

package/{index-gq44bqjt.js → index-259dsnz3.js}

@@ -2,10 +2,10 @@
 import {
   runner,
   script
-} from "./index-znynzt5w.js";
+} from "./index-mak3cd28.js";
 import {
   LibExecutor
-} from "./index-qsq3q8fy.js";
+} from "./index-2tv3fdx4.js";
 import {
   LibSource,
   formatLibStatuses

package/{index-qsq3q8fy.js → index-2tv3fdx4.js}

@@ -947,6 +947,8 @@ class AsyncDefaultExportDetector {
       if (ts.isExportAssignment(statement)) {
         if (this.#isAsyncFunctionExpression(statement.expression))
           return true;
+        if (ts.isCallExpression(statement.expression))
+          return true;
         if (ts.isIdentifier(statement.expression))
           defaultIdentifier = statement.expression.text;
         continue;
@@ -1096,13 +1098,18 @@ async function writeGeneratedRootLayoutFile(opts) {
 void st;
 ` : `import "@apps/${opts.appName}/client";
 `;
-  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedLayout from ${JSON.stringify(inheritedSourceSpecifier)};
-` : `const inheritedLayout = {};
+  const inheritedLabel = inheritedSourceAbsPath ? path4.relative(opts.appCwdPath, inheritedSourceAbsPath) : "";
+  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedModule from ${JSON.stringify(inheritedSourceSpecifier)};
+const inheritedLayout = resolveRouteModule(inheritedModule as never, ${JSON.stringify(inheritedLabel)}).module as LayoutModule;
+` : `const inheritedLayout: LayoutModule = {};
 `;
   const prefix = routePrefixForSegments(opts.boundary.segments);
-  const userImport = sourceSpecifier ? `import UserLayout, * as userLayout from ${JSON.stringify(sourceSpecifier)};
-` : `const UserLayout = ({ children }) => children;
-const userLayout = {};
+  const userLabel = opts.boundary.sourceAbsPath ? path4.relative(opts.appCwdPath, opts.boundary.sourceAbsPath) : "";
+  const userImport = sourceSpecifier ? `import * as userModule from ${JSON.stringify(sourceSpecifier)};
+const userLayout = resolveRouteModule(userModule as never, ${JSON.stringify(userLabel)}).module as LayoutModule;
+const UserLayout = userLayout.default as (props: LayoutProps) => ReactNode | Promise<ReactNode>;
+` : `const UserLayout = ({ children }: LayoutProps) => children;
+const userLayout: LayoutModule = {};
 `;
   const isAsyncUserLayout = opts.boundary.sourceAbsPath ? await AsyncDefaultExportDetector.detect(opts.boundary.sourceAbsPath) : false;
   const userLayoutElement = "<UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>";
@@ -1114,8 +1121,9 @@ const userLayout = {};
 ` : "";
   const layoutChild = isAsyncUserLayout ? "{layout}" : userLayoutElement;
   const layoutReturn = isAsyncUserLayout ? "layout" : userLayoutElement;
-  const source = opts.includeSystemProvider ? `import type { LayoutProps, PageProps } from "akanjs/client";
-import { loadFonts } from "akanjs/client";
+  const source = opts.includeSystemProvider ? `import type { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
+import { loadFonts, resolveRouteModule } from "akanjs/client";
+import type { ReactNode } from "react";
 import { System } from "akanjs/ui";
 import { env } from "@apps/${opts.appName}/env/env.client";
 import { allDictionary } from ${JSON.stringify(dictMacroSpecifier)};
@@ -1166,7 +1174,9 @@ ${layoutBinding}  return (
     </System.Provider>
   );
 }
-` : `import type { LayoutProps, PageProps } from "akanjs/client";
+` : `import type { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
+import { resolveRouteModule } from "akanjs/client";
+import type { ReactNode } from "react";
 ${inheritedImport}${userImport}
 export async function generateHead(props: PageProps) {
   if (userLayout.generateHead) return userLayout.generateHead(props);
@@ -3245,7 +3255,7 @@ class SysExecutor extends Executor {
 class AppExecutor extends SysExecutor {
   static #routeSourceValidator = null;
   static async#getRouteSourceValidator() {
-    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-ze6x894c.js")).RouteSourceValidator;
+    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-apyqw7wk.js")).RouteSourceValidator;
     return AppExecutor.#routeSourceValidator;
   }
   dist;
@@ -3419,7 +3429,8 @@ class AppExecutor extends SysExecutor {
           validator.validateOverridesSourceExports(routeSource, absPath);
         else {
           const info = validator.validateRouteSourceExports(routeSource, absPath, parsed.kind, {
-            rootLayout: isRootLayout
+            rootLayout: isRootLayout,
+            pattern: parsed.pattern
           });
           if (info.devOnly) {
             devOnlyKeys.add(key);

package/{index-yks023mb.js → index-4c9ykbfq.js}

@@ -3,22 +3,22 @@ import {
   GlobalConfig,
   CloudApi,
   AiSession
-} from "./index-c69j78kk.js";
+} from "./index-kn1h7p1x.js";
 import {
   PkgExecutor
-} from "./index-qsq3q8fy.js";
+} from "./index-2tv3fdx4.js";
 import {
   script
-} from "./index-znynzt5w.js";
+} from "./index-mak3cd28.js";
 import {
   ApplicationScript
-} from "./index-zz5jyd94.js";
+} from "./index-yecdrt9a.js";
 import {
   PackageScript
-} from "./index-7d6vny25.js";
+} from "./index-ws5e0j51.js";
 import {
   CloudRunner
-} from "./index-zxgr3s8s.js";
+} from "./index-yw4xj7pa.js";
 
 // pkgs/@akanjs/cli/cloud/cloud.script.ts
 import { Logger } from "akanjs/common";

package/{index-qkk27bk6.js → index-4edzf1gr.js}

@@ -1,12 +1,12 @@
 // @bun
 import {
   script
-} from "./index-znynzt5w.js";
+} from "./index-mak3cd28.js";
 import {
   AppExecutor,
   LibExecutor,
   ModuleExecutor
-} from "./index-qsq3q8fy.js";
+} from "./index-2tv3fdx4.js";
 import {
   compactDiagnostics,
   createPrimitiveWriteReport,
@@ -39,10 +39,10 @@ import {
   hasSignalFactoryEntry,
   insertSignalFactoryEntry,
   addFieldUiPolicyForType
-} from "./index-fc1bh0a7.js";
+} from "./index-gyd220p2.js";
 import {
   ModuleScript
-} from "./index-zmjppp25.js";
+} from "./index-8pm30m73.js";
 
 // pkgs/@akanjs/cli/primitive/primitive.script.ts
 import { capitalize } from "akanjs/common";

package/{index-yza7zkpt.js → index-600zhnve.js}

@@ -1,14 +1,14 @@
 // @bun
 import {
   AppExecutor
-} from "./index-qsq3q8fy.js";
+} from "./index-2tv3fdx4.js";
 import {
   jsonText,
   createWorkflowBaselineSummary,
   buildAkanModuleContextIndex,
   createWorkflowStepRegistry,
   toolingRolloutGate
-} from "./index-fc1bh0a7.js";
+} from "./index-gyd220p2.js";
 import {
   buildResourceList,
   codexMcpConfigPath,
@@ -19,33 +19,33 @@ import {
   upsertCodexMcpServerBlock,
   renderDoctorText,
   AkanContextAnalyzer
-} from "./index-gtmz74tj.js";
+} from "./index-ktb5njgy.js";
 import {
   CommandContainer,
   runner,
   script
-} from "./index-znynzt5w.js";
+} from "./index-mak3cd28.js";
 import {
   isPlaceholderAppId2
-} from "./index-1yxtbmbj.js";
+} from "./index-wt7qrtd4.js";
 import {
   Prompter
 } from "./index-h7yw2z9n.js";
 import {
   RepairRunner
-} from "./index-0amdxycf.js";
+} from "./index-fz5q3gd7.js";
 import {
   WorkflowRunner
-} from "./index-srdssqj7.js";
+} from "./index-7737gxcp.js";
 import {
   ModuleScript
-} from "./index-zmjppp25.js";
+} from "./index-8pm30m73.js";
 import {
   PrimitiveScript
-} from "./index-qkk27bk6.js";
+} from "./index-4edzf1gr.js";
 import {
   ScalarScript
-} from "./index-8p8p0cf8.js";
+} from "./index-rwg2aa4f.js";
 import {
   getMobileTargets
 } from "./index-47pj3aee.js";

package/{index-srdssqj7.js → index-7737gxcp.js}

@@ -20,13 +20,13 @@ import {
   renderWorkflowApply,
   renderWorkflowValidation,
   renderWorkflowRunArtifact
-} from "./index-fc1bh0a7.js";
+} from "./index-gyd220p2.js";
 import {
   AkanContextAnalyzer
-} from "./index-gtmz74tj.js";
+} from "./index-ktb5njgy.js";
 import {
   runner
-} from "./index-znynzt5w.js";
+} from "./index-mak3cd28.js";
 
 // pkgs/@akanjs/cli/workflow/workflow.runner.ts
 import { mkdir, readFile, writeFile } from "fs/promises";

package/{index-zmjppp25.js → index-8pm30m73.js}

@@ -4,14 +4,14 @@ import {
 } from "./index-q0y2jq9j.js";
 import {
   AiSession
-} from "./index-c69j78kk.js";
+} from "./index-kn1h7p1x.js";
 import {
   ModuleExecutor
-} from "./index-qsq3q8fy.js";
+} from "./index-2tv3fdx4.js";
 import {
   runner,
   script
-} from "./index-znynzt5w.js";
+} from "./index-mak3cd28.js";
 import {
   sourceFile,
   moduleSourcePaths,
@@ -19,10 +19,10 @@ import {
   createPassedPrimitiveReport,
   bilingualLabelForField,
   bilingualDescriptionForField
-} from "./index-fc1bh0a7.js";
+} from "./index-gyd220p2.js";
 import {
   PageScript
-} from "./index-hyywke0f.js";
+} from "./index-pnqbkf5p.js";
 import {
   Prompter
 } from "./index-h7yw2z9n.js";

package/{index-0amdxycf.js → index-fz5q3gd7.js}

@@ -5,13 +5,13 @@ import {
   writeGeneratedSyncState,
   createRepairReport,
   renderRepairReport
-} from "./index-fc1bh0a7.js";
+} from "./index-gyd220p2.js";
 import {
   AkanContextAnalyzer
-} from "./index-gtmz74tj.js";
+} from "./index-ktb5njgy.js";
 import {
   runner
-} from "./index-znynzt5w.js";
+} from "./index-mak3cd28.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
 var commandForShell = (command) => command.startsWith("akan ") ? `bun run ${command}` : command;

package/{index-fc1bh0a7.js → index-gyd220p2.js}

@@ -2,7 +2,7 @@
 import {
   AppExecutor,
   LibExecutor
-} from "./index-qsq3q8fy.js";
+} from "./index-2tv3fdx4.js";
 
 // pkgs/@akanjs/devkit/workflow/utils.ts
 var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `