cabloy 5.1.61 → 5.1.62

package/cabloy-docs/frontend/form-scene-to-page-meta-guide.md

@@ -0,0 +1,303 @@
+# Form Scene to Page Meta Guide
+
+This guide explains the cross-layer runtime path from `formScene` to `formMeta`, then to `pageMeta`, and finally to visible shell/tab state in Zova.
+
+Use this page when you want to understand one narrow question end to end:
+
+- where `formScene` comes from
+- how it becomes `formMeta`
+- how page-entry code uses that `formMeta`
+- how `formMeta` becomes part of `pageMeta`
+- how routed host / tabs / layout UI consume that state
+
+## Why this page exists
+
+The current frontend docs already explain the pieces of this story well:
+
+- [Form Guide](/frontend/form-guide) explains `formMeta` as form-scene input
+- [Zova Form Under the Hood](/frontend/zova-form-under-the-hood) explains form runtime orchestration
+- [Zova Form Source Reading Map](/frontend/zova-form-source-reading-map) explains where to read form internals
+- [Page Meta Guide](/frontend/page-meta-guide) explains how page meta is emitted and consumed
+- [Router Tabs Mechanism](/frontend/router-tabs-mechanism) and [Router Tabs Layout Integration](/frontend/router-tabs-layout-integration) explain how tabs store and display page/task state
+
+What those pages do not isolate directly is the one continuous cross-layer chain.
+
+That is the gap this page fills.
+
+## The shortest accurate mental model
+
+A practical mental model is:
+
+1. `formScene` is the semantic page/form scene input such as `view`, `create`, or `edit`
+2. `formMetaFromFormScene(...)` converts that scene into canonical runtime metadata
+3. page-entry controllers use `formMeta` to choose schema, data, and form behavior
+4. page-entry code pushes `{ pageTitle, pageDirty, formMeta }` through `$router.setPageMeta(...)`
+5. the router forwards that page meta into the active routed host
+6. `routerViewTabs` / `ModelTabs` store the metadata on the current tab item
+7. shell and nearby page-entry UI consume `formMeta.formScene` for visible create/edit/task state
+
+That means `formMeta` is not only a form-internal value. In the current Basic source, it also becomes routed-shell presentation state.
+
+## What this guide is not
+
+This page is a bridge page.
+
+It is **not**:
+
+- a replacement for [Form Guide](/frontend/form-guide)
+- a full form runtime deep dive instead of [Zova Form Under the Hood](/frontend/zova-form-under-the-hood)
+- a full page-meta guide instead of [Page Meta Guide](/frontend/page-meta-guide)
+- a full routed-host guide instead of [Router Tabs Mechanism](/frontend/router-tabs-mechanism)
+
+Its job is only to connect those layers into one readable path.
+
+## Source-confirmed reading path
+
+When reading this topic, use this order:
+
+1. `zova/src/suite-vendor/a-zova/modules/a-form/src/lib/utils.ts`
+2. `zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/page/entry/controller.tsx`
+3. `zova/src/suite/cabloy-basic/modules/basic-pageentry/src/component/blockPageEntry/controller.tsx`
+4. `zova/src/suite/cabloy-basic/modules/basic-pageentry/src/component/blockForm/controller.tsx`
+5. `zova/src/suite-vendor/a-zova/modules/a-router/src/bean/bean.router.ts`
+6. `zova/src/suite-vendor/a-zova/modules/a-routertabs/src/component/routerViewTabs/controller.tsx`
+7. `zova/src/suite-vendor/a-zova/modules/a-routertabs/src/model/tabs.ts`
+8. `zova/src/suite/a-home/modules/home-layoutadmin/src/component/layoutAdmin/render.tabs.tsx`
+9. `zova/src/suite/cabloy-basic/modules/basic-pageentry/src/component/blockToolbarRow/controller.tsx`
+
+That order moves from the scene/meta translation helper, to page-entry orchestration, to form runtime usage, to router forwarding, to tabs storage, and finally to visible shell/local UI consumption.
+
+## Runtime path by layer
+
+### 1. `formScene` becomes `formMeta`
+
+The canonical translation helper lives in:
+
+```text
+zova/src/suite-vendor/a-zova/modules/a-form/src/lib/utils.ts
+```
+
+The source-confirmed rules are:
+
+- `view` -> `{ formScene, formMode: 'view', editMode: undefined }`
+- `create` -> `{ formScene, formMode: 'edit', editMode: 'create' }`
+- `edit` -> `{ formScene, formMode: 'edit', editMode: 'update' }`
+
+This is the most important first step.
+
+A practical rule is:
+
+- treat `formScene` as the semantic scene input
+- treat `formMeta` as the canonical runtime metadata derived from that input
+
+The same helper file also exposes the reverse mapping through `formSceneFromFormMeta(formMeta)`.
+
+### 2. Page-entry controllers use `formMeta` to choose schema and data
+
+A generic resource-page entry path appears in:
+
+```text
+zova/src/suite-vendor/a-cabloy/modules/rest-resource/src/page/entry/controller.tsx
+```
+
+A stronger business-facing current Basic specimen appears in:
+
+```text
+zova/src/suite/cabloy-basic/modules/basic-pageentry/src/component/blockPageEntry/controller.tsx
+```
+
+In `blockPageEntry`, the controller:
+
+- derives `formScene`
+- computes `formMeta`
+- derives `schemaScene`
+- computes `formProvider`
+- computes `formSchema`
+- computes `formData`
+
+This is the key Zova-native meaning of `formMeta` at the page-entry layer:
+
+- it is the runtime selector for how the page-entry form should behave
+- it is not only a display flag
+
+### 3. `formMeta` enters the form runtime
+
+The clearest current Basic form-side specimen is:
+
+```text
+zova/src/suite/cabloy-basic/modules/basic-pageentry/src/component/blockForm/controller.tsx
+```
+
+This block passes the page-entry-owned values into `ZForm`, including:
+
+- `schemaScene`
+- `formMeta`
+- `formProvider`
+- `formScope`
+- `data`
+- `schema`
+
+This confirms an important boundary:
+
+- page-entry owns the scene/meta decision
+- `ZForm` consumes that runtime metadata for real form behavior
+
+### 4. Page-entry code emits `pageMeta`
+
+The strongest current Basic write path is still in:
+
+```text
+zova/src/suite/cabloy-basic/modules/basic-pageentry/src/component/blockPageEntry/controller.tsx
+```
+
+Representative behavior:
+
+- initialize shell/task state from loaded data
+- mark dirty on form change
+- clear dirty after submit
+- include `formMeta` in each page-meta write
+
+Representative pattern:
+
+```typescript
+setPageMeta(data: any | undefined, pageDirty?: boolean) {
+  if (!this.$pageRoute) return;
+  const pageTitle = data?.[this.$props.pageTitleKey];
+  this.$router.setPageMeta(this.$pageRoute, { pageTitle, pageDirty, formMeta: this.formMeta });
+}
+```
+
+This is the most important transition point in the whole chain:
+
+- `formMeta` stops being only a form runtime input
+- it becomes part of shell-facing routed work-item presentation
+
+### 5. The router forwards page meta to the active host
+
+The forwarding boundary lives in:
+
+```text
+zova/src/suite-vendor/a-zova/modules/a-router/src/bean/bean.router.ts
+```
+
+Its role is straightforward:
+
+- receive `setPageMeta(route, pageMeta)`
+- forward that update to registered router-view hosts
+
+This means the router bean is not the long-term owner of the metadata.
+
+It is the forwarding boundary from page code into routed-host ownership.
+
+### 6. `routerViewTabs` stores the metadata on the tab item
+
+The tabs host forwarding layer appears in:
+
+```text
+zova/src/suite-vendor/a-zova/modules/a-routertabs/src/component/routerViewTabs/controller.tsx
+```
+
+The actual storage owner appears in:
+
+```text
+zova/src/suite-vendor/a-zova/modules/a-routertabs/src/model/tabs.ts
+```
+
+This is the source-confirmed current Basic path for routed-shell state:
+
+- `routerViewTabs` forwards `setPageMeta(...)` into `ModelTabs`
+- `ModelTabs` resolves the routed work item and merges `pageMeta` onto it
+
+This matters because:
+
+- page meta is stored on the active routed work item
+- it is not stored on the route record itself
+
+### 7. Shell and nearby UI consume `formMeta.formScene`
+
+The clearest visible shell consumer is:
+
+```text
+zova/src/suite/a-home/modules/home-layoutadmin/src/component/layoutAdmin/render.tabs.tsx
+```
+
+This render path uses:
+
+- `pageMeta.pageTitle` for task title
+- `pageMeta.pageDirty` for asterisk/dirty signal
+- `pageMeta.formMeta.formScene` for create/edit task icons
+
+A second, more local consumer appears in:
+
+```text
+zova/src/suite/cabloy-basic/modules/basic-pageentry/src/component/blockToolbarRow/controller.tsx
+```
+
+That controller reads `$$pageEntry.formMeta.formScene` directly for permission/display filtering.
+
+This gives the clean end-to-end interpretation:
+
+- shell/tab UI can consume `formMeta` after it has been promoted into page meta
+- nearby page-entry UI can also consume `formMeta` directly before or alongside shell usage
+
+## A compact end-to-end trace
+
+The shortest end-to-end trace is:
+
+- page-entry decides `formScene`
+- `formMetaFromFormScene(formScene)` derives canonical form runtime metadata
+- page-entry uses `formMeta` to compute schema/data/runtime behavior
+- page-entry writes `{ pageTitle, pageDirty, formMeta }` through `$router.setPageMeta(...)`
+- router forwards the update
+- tabs model stores `pageMeta` on the active work item
+- layout renders title/dirty/icon state from `pageMeta.formMeta.formScene`
+
+That is the source-confirmed cross-layer path in the current Basic frontend.
+
+## What this path is not
+
+Keep these boundaries clear.
+
+### It is not only a form concern
+
+`formMeta` starts from form scene logic, but in the current Basic tabs-based shell it also becomes task-level shell state.
+
+### It is not route identity
+
+Do not confuse this chain with route-meta questions such as:
+
+- `tabKey`
+- `componentKey`
+- `keepAlive`
+
+Those are route/work-item identity concerns.
+
+This guide is about scene-derived presentation/runtime metadata after the routed item already exists.
+
+### It is not browser document-title handling
+
+If the requirement is browser title or SEO metadata only, that belongs in the SSR/meta path rather than this chain.
+
+For that boundary, see [SSR SEO Meta](/frontend/ssr-seo-meta).
+
+## Where to read next
+
+Use these next steps depending on your question:
+
+- if you want form authoring: [Form Guide](/frontend/form-guide)
+- if you want deeper form runtime internals: [Zova Form Under the Hood](/frontend/zova-form-under-the-hood)
+- if you want the form source file map: [Zova Form Source Reading Map](/frontend/zova-form-source-reading-map)
+- if you want page-meta authoring and semantics: [Page Meta Guide](/frontend/page-meta-guide)
+- if you want the action-visibility rule for `permissionHint.formScene` and `$$pageEntry.formMeta.formScene`, read [Permission, formScene, and Action Visibility Guide](/frontend/permission-formscene-action-visibility-guide)
+- if you want tabs-side host storage and visible shell behavior: [Router Tabs Mechanism](/frontend/router-tabs-mechanism) and [Router Tabs Layout Integration](/frontend/router-tabs-layout-integration)
+
+## Final takeaway
+
+The most accurate way to read this topic is:
+
+- `formScene` is the semantic input
+- `formMeta` is the derived runtime metadata
+- `pageMeta` is the shell-facing routed work-item presentation payload
+- tabs/layout render turns that payload into visible task-level state
+
+That is the source-confirmed `formScene -> formMeta -> pageMeta -> shell/tab state` path in the current Cabloy Basic frontend.

package/cabloy-docs/frontend/foundation.md

@@ -60,9 +60,11 @@ If you want a compact path from public architecture to source-level understandin
 8. [Model Architecture](/frontend/model-architecture)
 9. [Model State Guide](/frontend/model-state-guide)
 10. [Model Resource Owner Pattern](/frontend/model-resource-owner-pattern)
-11. [Using ModelResource in Your Module](/frontend/model-resource-usage-guide)
-12. [Resource Model Best Practices](/frontend/model-resource-best-practices)
-13. [Resource Model Cookbook](/frontend/model-resource-cookbook)
+11. [Rest Resource Under the Hood](/frontend/rest-resource-under-the-hood)
+12. [Rest Resource Source Reading Map](/frontend/rest-resource-source-reading-map)
+13. [Using ModelResource in Your Module](/frontend/model-resource-usage-guide)
+14. [Resource Model Best Practices](/frontend/model-resource-best-practices)
+15. [Resource Model Cookbook](/frontend/model-resource-cookbook)
 
 Use this order when you want to understand both the public mental model and the shortest source-reading routes without collapsing Zova back into generic Vue habits.
 
@@ -71,9 +73,11 @@ If your main goal is resource-oriented frontend design, the model-focused subpat
 1. [Model Architecture](/frontend/model-architecture)
 2. [Model State Guide](/frontend/model-state-guide)
 3. [Model Resource Owner Pattern](/frontend/model-resource-owner-pattern)
-4. [Using ModelResource in Your Module](/frontend/model-resource-usage-guide)
-5. [Resource Model Best Practices](/frontend/model-resource-best-practices)
-6. [Resource Model Cookbook](/frontend/model-resource-cookbook)
+4. [Rest Resource Under the Hood](/frontend/rest-resource-under-the-hood)
+5. [Rest Resource Source Reading Map](/frontend/rest-resource-source-reading-map)
+6. [Using ModelResource in Your Module](/frontend/model-resource-usage-guide)
+7. [Resource Model Best Practices](/frontend/model-resource-best-practices)
+8. [Resource Model Cookbook](/frontend/model-resource-cookbook)
 
 ## Why this matters for AI development
 

package/cabloy-docs/frontend/frontend-source-reading-roadmap.md

@@ -0,0 +1,249 @@
+# Frontend Source Reading Roadmap
+
+This page is a lightweight roadmap for reading the Cabloy Basic frontend source.
+
+Use it when your question is not yet “which exact runtime file should I open next?” but:
+
+- where should I start reading?
+- which topic cluster matches my question?
+- should I begin with an overview page, an under-the-hood page, or a source-reading map?
+
+## Why this page exists
+
+The current frontend docs now include:
+
+- broad overview pages
+- under-the-hood/runtime explanations
+- source-reading maps
+- many focused deep dives for specific runtime chains
+
+That is good for depth, but it also means readers can reach the “which page next?” problem before they reach the “which file next?” problem.
+
+This page solves that problem.
+
+It is a chooser, not another runtime explainer.
+
+## How to use this page
+
+Use this rule of thumb:
+
+- if you are new to the topic, start with an **overview** page
+- if you already understand the public concept and want runtime behavior, go to an **under-the-hood** page
+- if you already know the topic and want the shortest path through source files, go to a **source-reading map** page
+- if your question is very narrow and practical, go directly to the relevant **deep dive** page
+
+## Architecture spine: start here first
+
+If you need the shortest path into the frontend mental model, start with these pages:
+
+- [Introduction](/frontend/introduction)
+- [Foundation](/frontend/foundation)
+- [Reading Zova for Vue Developers](/frontend/reading-zova-for-vue-developers)
+- [Zova vs Vue 3 Comparison](/frontend/zova-vs-vue3-comparison)
+- [Zova Reactivity Under the Hood](/frontend/zova-reactivity-under-the-hood)
+- [Zova Source Reading Map](/frontend/zova-source-reading-map)
+
+A practical reading order is:
+
+1. Introduction
+2. Foundation
+3. Reading Zova for Vue Developers
+4. Zova Source Reading Map
+
+## Topic cluster: app shell and startup
+
+Start here when your question is about the root app host, startup, shell behaviors, or root composition.
+
+### Overview / concept pages
+
+- [App Startup Guide](/frontend/app-startup-guide)
+- [Behavior Guide](/frontend/behavior-guide)
+
+### Focused deep dives
+
+- [Zova App Guide](/frontend/zova-app-guide)
+- [Root Behaviors Guide](/frontend/root-behaviors-guide)
+
+### Best next step
+
+- if the question is “what is the root app host?” -> read [Zova App Guide](/frontend/zova-app-guide)
+- if the question is “how do app-wide behaviors wrap the routed tree?” -> read [Root Behaviors Guide](/frontend/root-behaviors-guide)
+
+## Topic cluster: routing and routed hosts
+
+Start here when your question is about route identity, routed hosts, tabs/stack, or task-level shell state.
+
+### Overview / concept pages
+
+- [Page Route Guide](/frontend/page-route-guide)
+- [Router Tabs Introduction](/frontend/router-tabs-introduction)
+- [Router Tabs Overview](/frontend/router-tabs-overview)
+
+### Under-the-hood / runtime pages
+
+- [A-Router Guide](/frontend/a-router-guide)
+- [Zova Router Under the Hood](/frontend/zova-router-under-the-hood)
+- [Router View Hosts Guide](/frontend/router-view-hosts-guide)
+- [Router Tabs Mechanism](/frontend/router-tabs-mechanism)
+
+### Focused deep dives
+
+- [Page Meta Guide](/frontend/page-meta-guide)
+- [Router Tabs vs Stack](/frontend/router-tabs-vs-stack)
+- [Router Stack Guide](/frontend/router-stack-guide)
+
+### Best next step
+
+- if the question is “how do routes become operational?” -> read [A-Router Guide](/frontend/a-router-guide)
+- if the question is “which host owns the routed page instance?” -> read [Router View Hosts Guide](/frontend/router-view-hosts-guide)
+- if the question is “what is the workbench meaning of router tabs?” -> read [Router Tabs Overview](/frontend/router-tabs-overview)
+- if the question is “how does tabs state work?” -> read [Router Tabs Mechanism](/frontend/router-tabs-mechanism)
+- if the question is “how should I choose between tabs and stack?” -> read [Router Tabs vs Stack](/frontend/router-tabs-vs-stack)
+
+## Topic cluster: forms
+
+Start here when your question is about `ZForm`, `formMeta`, page-entry forms, or form-driven shell state.
+
+### Overview / concept pages
+
+- [Form Guide](/frontend/form-guide)
+
+### Under-the-hood / runtime pages
+
+- [Zova Form Under the Hood](/frontend/zova-form-under-the-hood)
+- [Zova Form Source Reading Map](/frontend/zova-form-source-reading-map)
+
+### Focused deep dives
+
+- [Form Scene to Page Meta Guide](/frontend/form-scene-to-page-meta-guide)
+
+### Best next step
+
+- if the question is “how does form runtime work?” -> read [Zova Form Under the Hood](/frontend/zova-form-under-the-hood)
+- if the question is “how does `formScene` become shell-visible state?” -> read [Form Scene to Page Meta Guide](/frontend/form-scene-to-page-meta-guide)
+
+## Topic cluster: resources and ModelResource
+
+Start here when your question is about resource-driven CRUD pages, `ModelResource`, or route/resource/runtime assembly.
+
+### Overview / concept pages
+
+- [Model Resource Owner Pattern](/frontend/model-resource-owner-pattern)
+- [Using ModelResource in Your Module](/frontend/model-resource-usage-guide)
+
+### Under-the-hood / runtime pages
+
+- [Rest Resource Under the Hood](/frontend/rest-resource-under-the-hood)
+- [Rest Resource Source Reading Map](/frontend/rest-resource-source-reading-map)
+
+### Focused deep dives
+
+- [A-Model Under the Hood](/frontend/a-model-under-the-hood)
+- [ModelResource Internals Deep Dive](/frontend/model-resource-internals-deep-dive)
+- [Resource Entry Page Deep Dive](/frontend/resource-entry-page-deep-dive)
+- [Resource List Page Deep Dive](/frontend/resource-list-page-deep-dive)
+- [Filter to Query to Select Data Flow Guide](/frontend/filter-query-select-data-flow-guide)
+
+### Best next step
+
+- if the question is “why does the resource owner exist?” -> read [Model Resource Owner Pattern](/frontend/model-resource-owner-pattern)
+- if the question is “how does the owner itself work internally?” -> read [ModelResource Internals Deep Dive](/frontend/model-resource-internals-deep-dive)
+- if the question is “how does the entry page runtime fit together?” -> read [Resource Entry Page Deep Dive](/frontend/resource-entry-page-deep-dive)
+- if the question is “how does the list page runtime fit together?” -> read [Resource List Page Deep Dive](/frontend/resource-list-page-deep-dive)
+- if the question is “how does filter state become list data?” -> read [Filter to Query to Select Data Flow Guide](/frontend/filter-query-select-data-flow-guide)
+
+## Topic cluster: tables
+
+Start here when your question is about `ZTable`, schema-driven columns, row/bulk actions, or table runtime.
+
+### Overview / concept pages
+
+- [Table Guide](/frontend/table-guide)
+- [TableCell Authoring Cookbook](/frontend/table-cell-cookbook)
+
+### Under-the-hood / runtime pages
+
+- [Zova Table Under the Hood](/frontend/zova-table-under-the-hood)
+- [Zova Table Source Reading Map](/frontend/zova-table-source-reading-map)
+
+### Focused deep dives
+
+- [Table + Resource CRUD Cookbook](/frontend/table-resource-crud-cookbook)
+- [Table Action Visibility and Permission Flow Guide](/frontend/table-action-visibility-permission-flow-guide)
+- [Zova Table Controller Render Supplement](/frontend/zova-table-controller-render-supplement)
+
+### Best next step
+
+- if the question is “how does the table runtime work?” -> read [Zova Table Under the Hood](/frontend/zova-table-under-the-hood)
+- if the question is “how do row/bulk actions become visible or hidden?” -> read [Table Action Visibility and Permission Flow Guide](/frontend/table-action-visibility-permission-flow-guide)
+
+## Topic cluster: server data and lower-level shared runtime
+
+Start here when your question is about schema-driven server-data consumption, SDK/runtime loading, or lower-level metadata infrastructure.
+
+### Overview / concept pages
+
+- [Server Data](/frontend/server-data)
+- [SDK Guide](/frontend/sdk-guide)
+- [OpenAPI SDK Guide](/frontend/openapi-sdk-guide)
+- [API Schema Guide](/frontend/api-schema-guide)
+
+### Focused deep dives
+
+- [Generated Contract Consumption Specimen](/frontend/generated-contract-consumption-specimen)
+- [Generated Contract Consumption: List Branch](/frontend/generated-contract-consumption-list-branch)
+- [Generated Contract Consumption: Entry Branch](/frontend/generated-contract-consumption-entry-branch)
+- [Generated Contract Consumption Verify Playbook](/frontend/generated-contract-consumption-verify-playbook)
+- [Generated Contract Consumption Debug Checklist](/frontend/generated-contract-consumption-debug-checklist)
+- [A-OpenAPI Under the Hood](/frontend/a-openapi-under-the-hood)
+
+### Best next step
+
+- if the question is “how do I consume the server-data ladder?” -> read [Server Data](/frontend/server-data)
+- if the question is “what does generated contract consumption look like in one practical frontend path?” -> read [Generated Contract Consumption Specimen](/frontend/generated-contract-consumption-specimen), then choose the list or entry branch
+- if the question is “how do I prove or diagnose the generated-contract consumer path?” -> continue with [Generated Contract Consumption Verify Playbook](/frontend/generated-contract-consumption-verify-playbook) or [Generated Contract Consumption Debug Checklist](/frontend/generated-contract-consumption-debug-checklist)
+- if the question is “how does the lower-level OpenAPI/schema runtime work?” -> read [A-OpenAPI Under the Hood](/frontend/a-openapi-under-the-hood)
+
+## Topic cluster: SSR
+
+Start here when your question is about SSR orchestration, hydration, SEO meta, or SSR troubleshooting.
+
+### Overview / concept pages
+
+- [SSR Architecture Overview](/frontend/ssr-architecture-overview)
+- [SSR Overview](/frontend/ssr-overview)
+- [SSR Init Data](/frontend/ssr-init-data)
+- [SSR SEO Meta](/frontend/ssr-seo-meta)
+
+### Best next step
+
+- if the question is “which side owns this SSR behavior?” -> read [SSR Architecture Overview](/frontend/ssr-architecture-overview)
+- if the question is “is this document/meta or task-level shell state?” -> compare [SSR SEO Meta](/frontend/ssr-seo-meta) with [Page Meta Guide](/frontend/page-meta-guide)
+
+## Recent deep dives and maps
+
+If you already know the cluster and want the most focused next page, these are the most useful recent deep dives/maps:
+
+- [Root Behaviors Guide](/frontend/root-behaviors-guide)
+- [A-Router Guide](/frontend/a-router-guide)
+- [Router View Hosts Guide](/frontend/router-view-hosts-guide)
+- [Form Scene to Page Meta Guide](/frontend/form-scene-to-page-meta-guide)
+- [ModelResource Internals Deep Dive](/frontend/model-resource-internals-deep-dive)
+- [Resource Entry Page Deep Dive](/frontend/resource-entry-page-deep-dive)
+- [Resource List Page Deep Dive](/frontend/resource-list-page-deep-dive)
+- [Filter to Query to Select Data Flow Guide](/frontend/filter-query-select-data-flow-guide)
+- [Table Action Visibility and Permission Flow Guide](/frontend/table-action-visibility-permission-flow-guide)
+- [A-OpenAPI Under the Hood](/frontend/a-openapi-under-the-hood)
+
+## Final rule
+
+When in doubt:
+
+1. pick the cluster on this page
+2. read the overview page first
+3. move to the under-the-hood page
+4. only then move to the source-reading map or deep dive
+
+This roadmap is the chooser.
+
+The detailed runtime explanations still belong to the cluster-specific pages.