cabloy 5.1.60 → 5.1.62

package/cabloy-docs/.vitepress/config.mjs

@@ -23,6 +23,7 @@ const aiItems = [
   { text: 'Playbook: Backend Module', link: '/ai/playbook-backend-module' },
   { text: 'Playbook: Frontend Page', link: '/ai/playbook-frontend-page' },
   { text: 'Playbook: Contract Regeneration', link: '/ai/playbook-contract-regeneration' },
+  { text: 'Playbook: Module Removal', link: '/ai/playbook-module-removal' },
   { text: 'Playbook: Metadata Refresh', link: '/ai/playbook-metadata-refresh' },
   { text: 'CLI for Agents', link: '/ai/cli-for-agents' },
   { text: 'Rules and Config', link: '/ai/rules-and-config' },
@@ -37,6 +38,7 @@ const fullstackGroups = [
     items: [
       { text: 'Introduction', link: '/fullstack/introduction' },
       { text: 'Quickstart', link: '/fullstack/quickstart' },
+      { text: 'Suites and Modules', link: '/fullstack/suites-and-modules' },
     ],
   },
   {
@@ -50,12 +52,16 @@ const fullstackGroups = [
         link: '/fullstack/tutorial-3-frontend-metadata-sharing',
       },
       {
-        text: 'Tutorial 4: Backend Contract Sharing',
-        link: '/fullstack/tutorial-4-backend-contract-sharing',
+        text: 'Tutorial 4: Custom Form/Table Renderers for Level',
+        link: '/fullstack/tutorial-4-custom-level-renderers',
       },
       {
-        text: 'Tutorial 5: One Contract Surface, Four Uses',
-        link: '/fullstack/tutorial-5-one-contract-four-uses',
+        text: 'Tutorial 5: Backend Contract Sharing',
+        link: '/fullstack/tutorial-5-backend-contract-sharing',
+      },
+      {
+        text: 'Tutorial 6: One Contract Surface, Four Uses',
+        link: '/fullstack/tutorial-6-one-contract-four-uses',
       },
     ],
   },
@@ -75,6 +81,23 @@ const fullstackGroups = [
       },
       { text: 'Framework Performance', link: '/fullstack/framework-performance' },
       { text: 'Vona + Zova Integration', link: '/fullstack/vona-zova-integration' },
+      { text: 'Contract Loop Playbook', link: '/fullstack/contract-loop-playbook' },
+      {
+        text: 'Backend Metadata to Frontend Table Actions',
+        link: '/fullstack/backend-metadata-to-frontend-table-actions',
+      },
+      {
+        text: 'Backend Metadata to Frontend Table Actions Verify Playbook',
+        link: '/fullstack/backend-metadata-to-frontend-table-actions-verify-playbook',
+      },
+      {
+        text: 'Backend Metadata to Frontend Table Actions Debug Checklist',
+        link: '/fullstack/backend-metadata-to-frontend-table-actions-debug-checklist',
+      },
+      {
+        text: 'Backend Metadata to Frontend Table Actions Source Reading Map',
+        link: '/fullstack/backend-metadata-to-frontend-table-actions-source-reading-map',
+      },
       { text: 'Backend OpenAPI to Frontend SDK', link: '/fullstack/openapi-to-sdk' },
       {
         text: 'Frontend Metadata Back to Backend',
@@ -160,6 +183,19 @@ export default defineConfig({
             { text: 'Foundation', link: '/backend/foundation' },
             { text: 'Backend Essentials', link: '/backend/backend-essentials' },
             { text: 'Quickstart', link: '/backend/quickstart' },
+            {
+              text: 'Backend Source Reading Roadmap',
+              link: '/backend/backend-source-reading-roadmap',
+            },
+            { text: 'Vona Source Reading Map', link: '/backend/vona-source-reading-map' },
+            {
+              text: 'Backend Source Reading Verify Playbook',
+              link: '/backend/backend-source-reading-verify-playbook',
+            },
+            {
+              text: 'Backend Source Reading Debug Checklist',
+              link: '/backend/backend-source-reading-debug-checklist',
+            },
           ],
         },
         {
@@ -212,6 +248,10 @@ export default defineConfig({
             { text: 'Model Guide', link: '/backend/model-guide' },
             { text: 'Entity Guide', link: '/backend/entity-guide' },
             { text: 'DTO Guide', link: '/backend/dto-guide' },
+            {
+              text: 'Backend Resource/Module Contract Chain',
+              link: '/backend/backend-resource-module-contract-chain',
+            },
           ],
         },
         {
@@ -243,6 +283,7 @@ export default defineConfig({
             { text: 'Queue Guide', link: '/backend/queue-guide' },
             { text: 'Election Guide', link: '/backend/election-guide' },
             { text: 'Schedule Guide', link: '/backend/schedule-guide' },
+            { text: 'Status Guide', link: '/backend/status-guide' },
             { text: 'Worker Guide', link: '/backend/worker-guide' },
             { text: 'Broadcast Guide', link: '/backend/broadcast-guide' },
             { text: 'Web Socket Guide', link: '/backend/websocket-guide' },
@@ -256,6 +297,18 @@ export default defineConfig({
           text: 'API & Testing',
           items: [
             { text: 'OpenAPI Guide', link: '/backend/openapi-guide' },
+            {
+              text: 'Backend Contract Emission Specimen',
+              link: '/backend/backend-contract-emission-specimen',
+            },
+            {
+              text: 'Backend Contract Emission Source Reading Map',
+              link: '/backend/backend-contract-emission-source-reading-map',
+            },
+            {
+              text: 'Backend Contract Emission Output Inspection',
+              link: '/backend/backend-contract-emission-output-inspection',
+            },
             { text: 'DTO Infer and Generation', link: '/backend/dto-infer-generation' },
             { text: 'Unit Testing', link: '/backend/unit-testing' },
           ],
@@ -268,6 +321,26 @@ export default defineConfig({
             { text: 'Introduction', link: '/frontend/introduction' },
             { text: 'Quickstart', link: '/frontend/quickstart' },
             { text: 'Foundation', link: '/frontend/foundation' },
+            {
+              text: 'Reading Zova for Vue Developers',
+              link: '/frontend/reading-zova-for-vue-developers',
+            },
+            {
+              text: 'Zova vs Vue 3 Comparison',
+              link: '/frontend/zova-vs-vue3-comparison',
+            },
+            {
+              text: 'Zova Reactivity Under the Hood',
+              link: '/frontend/zova-reactivity-under-the-hood',
+            },
+            {
+              text: 'Frontend Source Reading Roadmap',
+              link: '/frontend/frontend-source-reading-roadmap',
+            },
+            {
+              text: 'Zova Source Reading Map',
+              link: '/frontend/zova-source-reading-map',
+            },
           ],
         },
         {
@@ -286,6 +359,8 @@ export default defineConfig({
           items: [
             { text: 'Environment and Config Guide', link: '/frontend/environment-config-guide' },
             { text: 'App Startup Guide', link: '/frontend/app-startup-guide' },
+            { text: 'Zova App Guide', link: '/frontend/zova-app-guide' },
+            { text: 'Root Behaviors Guide', link: '/frontend/root-behaviors-guide' },
             { text: 'System Startup Guide', link: '/frontend/system-startup-guide' },
           ],
         },
@@ -305,9 +380,19 @@ export default defineConfig({
             { text: 'Page Params Guide', link: '/frontend/page-params-guide' },
             { text: 'Zod Guide', link: '/frontend/zod-guide' },
             { text: 'Page Route Guide', link: '/frontend/page-route-guide' },
+            { text: 'A-Router Guide', link: '/frontend/a-router-guide' },
+            { text: 'Zova Router Under the Hood', link: '/frontend/zova-router-under-the-hood' },
+            { text: 'Router View Hosts Guide', link: '/frontend/router-view-hosts-guide' },
             { text: 'Router Tabs Introduction', link: '/frontend/router-tabs-introduction' },
             { text: 'Router Tabs Overview', link: '/frontend/router-tabs-overview' },
             { text: 'Router Tabs Mechanism', link: '/frontend/router-tabs-mechanism' },
+            { text: 'Router Tabs vs Stack', link: '/frontend/router-tabs-vs-stack' },
+            { text: 'Router Stack Guide', link: '/frontend/router-stack-guide' },
+            { text: 'Page Meta Guide', link: '/frontend/page-meta-guide' },
+            {
+              text: 'Router Tabs Layout Integration',
+              link: '/frontend/router-tabs-layout-integration',
+            },
             {
               text: 'Router Tabs Route Meta Cookbook',
               link: '/frontend/router-tabs-route-meta-cookbook',
@@ -324,6 +409,45 @@ export default defineConfig({
           text: 'Components & UI',
           items: [
             { text: 'Component Guide', link: '/frontend/component-guide' },
+            { text: 'Form Guide', link: '/frontend/form-guide' },
+            {
+              text: 'Zova Form Under the Hood',
+              link: '/frontend/zova-form-under-the-hood',
+            },
+            {
+              text: 'Zova Form Source Reading Map',
+              link: '/frontend/zova-form-source-reading-map',
+            },
+            {
+              text: 'Form Scene to Page Meta',
+              link: '/frontend/form-scene-to-page-meta-guide',
+            },
+            {
+              text: 'Permission, formScene, and Action Visibility',
+              link: '/frontend/permission-formscene-action-visibility-guide',
+            },
+            { text: 'Table Guide', link: '/frontend/table-guide' },
+            { text: 'TableCell Authoring Cookbook', link: '/frontend/table-cell-cookbook' },
+            {
+              text: 'Table + Resource CRUD Cookbook',
+              link: '/frontend/table-resource-crud-cookbook',
+            },
+            {
+              text: 'Table Action Visibility & Permission Flow',
+              link: '/frontend/table-action-visibility-permission-flow-guide',
+            },
+            {
+              text: 'Zova Table Under the Hood',
+              link: '/frontend/zova-table-under-the-hood',
+            },
+            {
+              text: 'Zova Table Controller Render Deep Dive',
+              link: '/frontend/zova-table-controller-render-supplement',
+            },
+            {
+              text: 'Zova Table Source Reading Map',
+              link: '/frontend/zova-table-source-reading-map',
+            },
             { text: 'Component Props Guide', link: '/frontend/component-props-guide' },
             { text: 'Component v-model Guide', link: '/frontend/component-v-model-guide' },
             { text: 'Generic Component Guide', link: '/frontend/generic-component-guide' },
@@ -336,15 +460,83 @@ export default defineConfig({
           text: 'Data & State',
           items: [
             { text: 'Server Data', link: '/frontend/server-data' },
+            { text: 'Fetch Interceptor Guide', link: '/frontend/fetch-interceptor-guide' },
             { text: 'API Guide', link: '/frontend/api-guide' },
+            { text: 'OpenAPI Runtime Under the Hood', link: '/frontend/a-openapi-under-the-hood' },
             { text: 'Model Architecture', link: '/frontend/model-architecture' },
-            { text: 'Model State Guide', link: '/frontend/model-state-guide' },
+            { text: 'Model Runtime Under the Hood', link: '/frontend/a-model-under-the-hood' },
+            {
+              text: 'Resource Models & CRUD',
+              items: [
+                { text: 'Model State Guide', link: '/frontend/model-state-guide' },
+                {
+                  text: 'Model Resource Owner Pattern',
+                  link: '/frontend/model-resource-owner-pattern',
+                },
+                {
+                  text: 'Rest Resource Under the Hood',
+                  link: '/frontend/rest-resource-under-the-hood',
+                },
+                {
+                  text: 'Rest Resource Source Reading Map',
+                  link: '/frontend/rest-resource-source-reading-map',
+                },
+                {
+                  text: 'Resource Entry Page Deep Dive',
+                  link: '/frontend/resource-entry-page-deep-dive',
+                },
+                {
+                  text: 'Resource List Page Deep Dive',
+                  link: '/frontend/resource-list-page-deep-dive',
+                },
+                {
+                  text: 'ModelResource Internals Deep Dive',
+                  link: '/frontend/model-resource-internals-deep-dive',
+                },
+                {
+                  text: 'Filter to Query to Select Data Flow',
+                  link: '/frontend/filter-query-select-data-flow-guide',
+                },
+                {
+                  text: 'Using ModelResource in Your Module',
+                  link: '/frontend/model-resource-usage-guide',
+                },
+                {
+                  text: 'Resource Model Best Practices and Anti-Patterns',
+                  link: '/frontend/model-resource-best-practices',
+                },
+                {
+                  text: 'Resource Model Cookbook',
+                  link: '/frontend/model-resource-cookbook',
+                },
+              ],
+            },
           ],
         },
         {
           text: 'API Contract & SDK',
           items: [
             { text: 'OpenAPI SDK Guide', link: '/frontend/openapi-sdk-guide' },
+            {
+              text: 'Generated Contract Consumption Specimen',
+              link: '/frontend/generated-contract-consumption-specimen',
+            },
+            {
+              text: 'Generated Contract Consumption: List Branch',
+              link: '/frontend/generated-contract-consumption-list-branch',
+            },
+            {
+              text: 'Generated Contract Consumption: Entry Branch',
+              link: '/frontend/generated-contract-consumption-entry-branch',
+            },
+            {
+              text: 'Generated Contract Consumption Verify Playbook',
+              link: '/frontend/generated-contract-consumption-verify-playbook',
+            },
+            {
+              text: 'Generated Contract Consumption Debug Checklist',
+              link: '/frontend/generated-contract-consumption-debug-checklist',
+            },
             { text: 'API Schema Guide', link: '/frontend/api-schema-guide' },
             { text: 'SDK Guide', link: '/frontend/sdk-guide' },
           ],

package/cabloy-docs/ai/cli-to-skill-map.md

@@ -152,6 +152,13 @@ Typical skill role:
 - likely CLI path: Vona persistence verification plus Zova metadata/build flows only if renderer follow-up is required
 - skill then verifies entity, locale, tests, `fileVersion` logic, and renderer/build/deps follow-up when applicable
 
+### Example: “Remove an existing module cleanly”
+
+- skill decides this is a module-removal workflow rather than scaffolding or contract evolution
+- skill classifies backend-only vs frontend-only vs fullstack removal
+- likely CLI path: root build/deps/typecheck scripts such as `npm run build:zova:admin`, `npm run deps:vona`, `npm run deps:zova`, and `npm run tsc`
+- skill then verifies that source, package references, generated registrations, and stale runtime directories are handled in the correct order
+
 ## Anti-patterns
 
 Avoid these mistakes in skills:

package/cabloy-docs/ai/docs-skills-rules-mapping.md

@@ -143,6 +143,28 @@ Use this quick rule:
 - full explanation → [Backend OpenAPI to Frontend SDK](/fullstack/openapi-to-sdk)
 - workflow steering → skill and rules can point to the docs and choose the right CLI path
 
+### Example: “How should AI remove an existing module cleanly?”
+
+- public operational explanation → [Playbook: Module Removal](/ai/playbook-module-removal)
+- maintainer rationale and pitfalls → `.docs-internal/architecture/module-removal-workflow.md`
+- avoid putting the full workflow in `CLAUDE.md` because the task needs branching, cleanup order, generated-runtime recovery, and verification
+- procedural decision workflow → `cabloy-module-removal` skill
+
+### Example: “How should AI plan a new business domain name and structure?”
+
+- public naming and suite-first explanation → [Suites and Modules](/fullstack/suites-and-modules)
+- frontend-side naming companion → [Modules and Suites](/frontend/modules-and-suites)
+- keep the durable naming rules in docs instead of duplicating them in repo rules
+- avoid putting the full branching workflow in `CLAUDE.md` because the task needs proposal, validation, confirmation, and CLI handoff
+- procedural decision workflow → `cabloy-domain-planning` skill
+
+### Example: “What `@Api.field(...)` ordering rule should AI preserve when mixing helpers and zod?”
+
+- full explanation → [Entity Guide](/backend/entity-guide) and [DTO Guide](/backend/dto-guide)
+- AI workflow reminder → [Playbook: Add a Backend Module](/ai/playbook-backend-module)
+- procedural checklist reminder → backend scaffold skill references
+- avoid putting the full explanation only in `CLAUDE.md` because this is a framework-specific authoring rule, not a short global behavior rule
+
 ## Anti-patterns to avoid
 
 Avoid these mistakes:

package/cabloy-docs/ai/future-skill-roadmap.md

@@ -10,18 +10,23 @@ A roadmap helps convert that documented knowledge into a focused set of high-val
 
 ## What already exists
 
-Current root skill:
+Current root skills include:
 
 - `cabloy-workflow`
+- `cabloy-domain-planning`
+- `cabloy-contract-loop`
+- `cabloy-resource-field-update`
+- `cabloy-module-removal`
 
-Its current role is broad workflow selection:
+Their current roles are:
 
-- detect Basic vs Start
-- classify backend/frontend/fullstack/docs work
-- prefer CLI-first behavior
-- suggest verification
+- `cabloy-workflow` → broad workflow selection, edition detection, CLI-first routing, and verification framing
+- `cabloy-domain-planning` → suite-first naming proposals, providerId confirmation, module-boundary suggestions, and scaffold handoff for new business domains
+- `cabloy-contract-loop` → backend/frontend contract regeneration, reverse-chain handling, and drift diagnosis
+- `cabloy-resource-field-update` → existing backend resource-field changes with `fileVersion` and renderer-aware follow-up
+- `cabloy-module-removal` → backend/frontend/fullstack module deletion order, generated-runtime cleanup, and verification
 
-This is a strong foundation skill, but it is intentionally general.
+This is now a stronger foundation skill set, but it still leaves several useful workflow families for future specialization.
 
 ## Recommended next skill families
 

package/cabloy-docs/ai/introduction.md

@@ -75,6 +75,7 @@ Use this path when the task is about implementing or reviewing Cabloy code with
 - [Playbook: Backend Module](/ai/playbook-backend-module)
 - [Playbook: Frontend Page](/ai/playbook-frontend-page)
 - [Playbook: Contract Regeneration](/ai/playbook-contract-regeneration)
+- [Playbook: Module Removal](/ai/playbook-module-removal)
 - [Playbook: Metadata Refresh](/ai/playbook-metadata-refresh)
 
 ### Verification and roadmap path

package/cabloy-docs/ai/playbook-backend-module.md

@@ -66,6 +66,12 @@ Depending on the feature, extend the generated code with the right framework-lev
 - migration and changes
 - field indexes
 
+When refining entity or DTO fields that use `@Api.field(...)`, apply this framework-specific guardrail:
+
+- if you include an explicit zod schema such as `z.number().int().min(1)`, place it as the **last argument**
+- keep helper metadata such as `v.xxx(...)` and `ZovaRender.xxx(...)` before the zod schema
+- otherwise helpers written after the zod schema may stop taking effect
+
 Relevant docs:
 
 - [Controller Guide](/backend/controller-guide)

package/cabloy-docs/ai/playbook-module-removal.md

@@ -0,0 +1,164 @@
+# Playbook: Remove a Cabloy Module
+
+This playbook turns Cabloy module deletion into a repeatable AI-friendly workflow.
+
+## When to use this playbook
+
+Use this playbook when the goal is to remove an existing module from the Cabloy monorepo.
+
+Typical triggers include:
+
+- delete a demo module
+- retire a backend module
+- remove a frontend module
+- remove a fullstack module that exists in both Vona and Zova
+- clean up stale generated runtime or type residues after a module was removed
+
+## Step 1: Detect the repo and scope
+
+Before deleting anything:
+
+1. detect whether the active repo is Cabloy Basic or Cabloy Start
+2. confirm whether the module is backend-only, frontend-only, or fullstack
+3. inspect the root `package.json`
+4. inspect `npm run vona` and `npm run zova`
+
+This avoids deleting the wrong surfaces or using the wrong edition-specific assumptions.
+
+## Step 2: Inventory the real module surfaces
+
+Inspect the real source and direct dependency surfaces first.
+
+Typical locations include:
+
+- `vona/src/module/<module>` or suite-based backend module roots
+- `zova/src/module/<module>` or suite-based frontend module roots
+- `vona/package.json`
+- `zova/package.json`
+- generated registries and lockfiles
+- tests that still target the module
+
+If the user asked for a public scrub, also inspect `cabloy-docs/`. Otherwise, treat docs cleanup as a separate scope decision.
+
+## Step 3: Remove source and direct references first
+
+Start by removing the real source and direct workspace package references.
+
+Typical order:
+
+1. remove backend module source if in scope
+2. remove frontend module source if in scope
+3. remove direct workspace dependency entries from the relevant `package.json` files
+4. refresh or clean generated registrations only after source removal
+
+Do not start by hand-editing generated caches while the real module source or package references still exist.
+
+## Step 4: Regenerate with the repo-owned workflow
+
+After source cleanup, use the existing root scripts to refresh generated outputs.
+
+Representative root commands in Cabloy Basic include:
+
+```bash
+npm run build:zova:admin
+npm run deps:vona
+npm run deps:zova
+npm run tsc
+npm run test
+```
+
+### Fullstack default sequence
+
+When the module exists on both the Vona and Zova sides, the usual sequence is:
+
+1. `npm run build:zova:admin`
+2. `npm run deps:vona`
+3. `npm run deps:zova`
+4. `npm run tsc`
+
+This keeps the Zova Admin JS bundle and rest output aligned before Vona consumes downstream artifacts.
+
+### Narrower branches
+
+For backend-only removal, prefer the narrowest meaningful verification first:
+
+- `npm run deps:vona`
+- `npm run tsc`
+- `npm run test` when runtime/test coupling is likely
+
+For frontend-only removal, use the relevant Zova build/deps path first, then typecheck.
+
+## Step 5: Clean generated runtime directories when residues remain stale
+
+If stale module types or runtime entries still remain after the normal cleanup and regeneration flow, treat generated runtime directories as disposable working state.
+
+In particular, the primary recovery targets for this workflow are:
+
+- `vona/.vona`
+- `zova/.zova`
+
+These are not necessarily the only generated working directories in the repo, but they are the main stale-runtime targets for normal module-removal recovery.
+
+Why this is safe:
+
+- these directories are generated by the Vona and Zova CLI flows
+- they are ignored by the repo because they are not source-of-truth files
+- they may survive when a service or build process does not stop cleanly
+
+After deleting them, rerun the normal regeneration flow and typecheck again.
+
+## Step 6: Verify that the module is really gone
+
+Search for remaining references to:
+
+- the module relative name
+- the backend workspace package name
+- the frontend workspace package name
+- route or resource names if applicable
+
+Then verify with the narrowest meaningful commands first, followed by broader checks when needed.
+
+Typical verification commands:
+
+```bash
+npm run build:zova:admin
+npm run deps:vona
+npm run deps:zova
+npm run tsc
+npm run test
+```
+
+The expected result is:
+
+- no direct workspace dependency entries remain
+- no generated registry still points at the removed module
+- no stale typecheck failures still reference the module
+- no important runtime or test surfaces still import it
+
+## Step 7: Treat docs cleanup as an explicit second scope
+
+Removing code/runtime surfaces does not automatically mean public docs should be rewritten.
+
+Make this an explicit scope decision:
+
+- code/runtime removal only
+- code/runtime removal plus docs/examples scrub
+
+If docs cleanup is in scope, update `cabloy-docs/` as a separate pass after runtime cleanup is stable.
+
+## AI rule of thumb
+
+A good Cabloy module-removal workflow is usually:
+
+1. detect edition and scope
+2. inventory real module surfaces
+3. remove source and direct references
+4. regenerate with repo entrypoints
+5. clean generated runtime dirs only when stale residues remain
+6. verify the module is really gone
+
+Not:
+
+1. delete a few generated files first
+2. guess which paths matter
+3. leave workspace dependencies or generated registrations stale

package/cabloy-docs/ai/skills.md

@@ -35,3 +35,15 @@ A strong Cabloy skill usually includes:
 When a skill needs to apply an architectural rule such as backend class placement, prefer a branching decision tree that points back to durable docs instead of embedding the full architecture rationale inside the skill itself.
 
 For edition-aware skills, use [Edition Detection for AI Workflows](/ai/edition-detection) and [Edition Consistency Checklist](/ai/edition-consistency-checklist) as the durable review surfaces before expanding edition-specific branches.
+
+## Example workflow skills in this repo
+
+Current examples include:
+
+- `cabloy-workflow` for choosing the correct Cabloy work path before implementation
+- `cabloy-domain-planning` for proposing and confirming providerId, suite, and initial module names before scaffolding a new business domain
+- `cabloy-contract-loop` for backend/frontend contract regeneration and drift diagnosis
+- `cabloy-resource-field-update` for updating an existing backend resource field thread
+- `cabloy-module-removal` for removing a backend, frontend, or fullstack module cleanly, including generated-runtime cleanup, stale-residue recovery, and verification
+
+The module-removal workflow is a good example of why skills belong in `.claude/skills/` instead of `CLAUDE.md`: the task needs branching, cleanup order, recovery guidance for generated runtime directories such as `vona/.vona` and `zova/.zova`, and a verification checklist that would be too large for a short repo-wide rule.