jsgui3-server 0.0.147 → 0.0.149

package/docs/books/admin-ui/03-controls.md

@@ -0,0 +1,194 @@
+# Chapter 3: Controls
+
+## Control Placement Strategy
+
+| Control | Location | Rationale |
+|---------|----------|-----------|
+| `Property_Viewer` | jsgui3-html | General-purpose read-only property display |
+| `Property_Editor` | jsgui3-html | Already exists - editing properties |
+| `Object_KVP_Viewer` | jsgui3-html | Already exists - key-value pairs |
+| `Object_KVP_Editor` | jsgui3-html | Already exists - editable KVP |
+| `Resource_Viewer` | jsgui3-html | General-purpose for any resource with name/type/status |
+| `Tree_View` | jsgui3-html | General-purpose hierarchical display |
+| `Admin_Page` | jsgui3-server | Server-specific admin shell |
+| `Resource_List` | jsgui3-server | Server-specific resource listing |
+| `Observables_List` | jsgui3-server | Server-specific observable listing |
+| `Observable_Monitor` | jsgui3-server | Server-specific real-time monitoring |
+| `Resource_Detail_Page` | jsgui3-server | Server-specific resource detail view |
+
+---
+
+## General-Purpose Controls (jsgui3-html)
+
+### Existing Controls to Leverage
+
+1. **`Property_Editor`** - Edits properties with type-specific inputs
+2. **`Object_KVP_Viewer`** - Displays object as key-value pairs
+3. **`Object_KVP_Editor`** - Editable key-value pairs
+
+### New Controls Needed in jsgui3-html
+
+#### Property_Viewer
+
+Read-only display of an object's properties in a clean table format.
+
+```javascript
+const viewer = new controls.Property_Viewer({
+    context,
+    data: { name: 'MyResource', type: 'observable', status: 'active' },
+    schema: {
+        name: { label: 'Name', type: 'string' },
+        type: { label: 'Type', type: 'badge' },
+        status: { label: 'Status', type: 'status-indicator' }
+    }
+});
+```
+
+#### Resource_Viewer
+
+Displays a resource with icon, name, type badge, and expandable details.
+
+```javascript
+const rv = new controls.Resource_Viewer({
+    context,
+    resource: {
+        name: '/api/tick-stream',
+        type: 'observable',
+        schema: { type: 'int' },
+        status: 'active',
+        connections: 3
+    }
+});
+```
+
+#### Tree_View
+
+Hierarchical tree with expand/collapse, icons, and selection.
+
+```javascript
+const tree = new controls.Tree_View({
+    context,
+    data: [
+        { label: 'Publishers', icon: '📡', children: [...] },
+        { label: 'Routes', icon: '🛤️', children: [...] }
+    ],
+    onSelect: (node) => console.log('Selected:', node)
+});
+```
+
+---
+
+## Server-Specific Controls (jsgui3-server/admin-ui)
+
+### 1. Admin_Page
+
+The main container control that serves as the Admin UI shell.
+
+```javascript
+class Admin_Page extends Active_HTML_Document {
+    // Renders sidebar + main panel + header
+}
+```
+
+**Layout:**
+- Left sidebar: `Resource_List` + `Observables_List`
+- Main panel: `Resource_Detail_Page` or selected content
+- Header: Server name, uptime, connection count
+
+### 2. Resource_List
+
+Displays all registered server resources using `Tree_View`.
+
+**Data Source:** `GET /api/admin/resources`
+
+**Structure:**
+```
+├── Routes
+│   ├── / (webpage)
+│   ├── /admin (admin-ui)
+│   └── /api/* (function)
+├── Publishers
+│   ├── HTTP_Website_Publisher
+│   └── HTTP_Observable_Publisher
+└── Resources
+    ├── Server Router
+    └── Resource Pool
+```
+
+### 3. Observables_List
+
+Lists all published observables with status indicators.
+
+**Data Source:** `GET /api/admin/observables`
+
+**Item Display:**
+- Route path
+- Schema type badge
+- Status indicator (active/paused/stopped)
+- Connection count
+
+### 4. Observable_Monitor
+
+Real-time display for a single observable using `Auto_Observable_UI`.
+
+**Features:**
+- Play/Pause controls
+- History buffer (last N values)
+- Schema display
+- Export to JSON
+
+### 5. Resource_Detail_Page
+
+Detail view for a selected resource.
+
+**Sections:**
+- **Header**: Name, type badge
+- **Properties**: Using `Property_Viewer`
+- **Actions**: Pause, resume, stop (for observables)
+- **Live View**: For observables, embedded monitor
+
+### 6. Config_Panel
+
+Form-based configuration editor using `Property_Editor`.
+
+**Features:**
+- Read-only by default (safety)
+- Unlock with confirmation for editing
+- Validation before save
+
+### 7. Metrics_Dashboard
+
+Displays server health metrics.
+
+**Metrics:**
+- Active connections
+- Requests/second
+- Memory usage
+- Observable subscription count
+
+---
+
+## Styling Approach
+
+All controls use CSS-in-JS via the static `.css` property:
+
+```javascript
+Admin_Page.css = `
+.admin-page {
+    display: grid;
+    grid-template-columns: 280px 1fr;
+    height: 100vh;
+    background: #1a1a2e;
+}
+.admin-sidebar { ... }
+.admin-main { ... }
+`;
+```
+
+## Extension Points
+
+Custom admin panels can be registered:
+
+```javascript
+server.admin.registerPanel('MyPanel', MyPanelControl);
+```

package/docs/books/admin-ui/04-implementation-plan.md

@@ -0,0 +1,62 @@
+# Chapter 4: Implementation Plan
+
+## Phase 1: Foundation
+
+### jsgui3-html (General-Purpose)
+- [ ] Implement `Property_Viewer` control
+- [ ] Implement `Resource_Viewer` control  
+- [ ] Implement `Tree_View` control
+
+### jsgui3-server (Admin-Specific)
+- [x] Create `admin-ui/client.js` with `Admin_Page`
+- [x] Create `admin-ui/server.js` with API routes
+- [x] Register `/admin` route in main server
+
+## Phase 2: Resource Browser
+
+- [ ] Implement `Resource_List` using `Tree_View`
+- [x] Add API: `GET /api/admin/resources`
+- [ ] Implement `Resource_Detail_Page`
+- [ ] Wire up selection → detail view
+
+## Phase 3: Observable Visibility
+
+- [ ] Implement `Observables_List` control
+- [x] Add API: `GET /api/admin/observables`
+- [ ] Implement `Observable_Monitor` with `Auto_Observable_UI`
+- [ ] Add play/pause/history features
+
+## Phase 4: Metrics & Config
+
+- [ ] Implement `Metrics_Dashboard`
+- [ ] Add API: `GET /api/admin/metrics` (SSE)
+- [ ] Implement `Config_Panel` using `Property_Editor`
+
+## Phase 5: Polish
+
+- [ ] Responsive design
+- [ ] Keyboard navigation
+- [ ] Export/import config
+- [ ] Documentation and examples
+
+## File Checklist
+
+| File | Location | Status |
+|------|----------|--------|
+| `Property_Viewer.js` | jsgui3-html | Planned |
+| `Resource_Viewer.js` | jsgui3-html | Planned |
+| `Tree_View.js` | jsgui3-html | Planned |
+| `admin-ui/client.js` | jsgui3-server | ✅ Done |
+| `admin-ui/server.js` | jsgui3-server | ✅ Done |
+| `admin-ui/controls/Resource_List.js` | jsgui3-server | Planned |
+| `admin-ui/controls/Observables_List.js` | jsgui3-server | Planned |
+| `admin-ui/controls/Observable_Monitor.js` | jsgui3-server | Planned |
+| `admin-ui/controls/Resource_Detail_Page.js` | jsgui3-server | Planned |
+
+## Success Criteria
+
+1. Navigate to `/admin` and see the Admin UI
+2. Browse all server resources in tree view
+3. Select a resource to see its properties
+4. View live observable streams with auto-generated UIs
+5. See basic metrics (connections, uptime)

package/docs/books/admin-ui/README.md

@@ -0,0 +1,26 @@
+# Admin UI Book
+
+This folder contains documentation for the `jsgui3-server` Admin UI system.
+
+## Chapters
+
+1. [Introduction](./01-introduction.md) - Vision and goals
+2. [Architecture](./02-architecture.md) - High-level design
+3. [Controls](./03-controls.md) - UI components
+4. [Implementation Plan](./04-implementation-plan.md) - Phases and tasks
+
+## Purpose
+
+The Admin UI provides a web-based interface to administer and monitor `jsgui3-server` instances. Key features include:
+
+- **Resource Viewer**: Browse server-side resources (publishers, routes, etc.)
+- **Observable Monitor**: Real-time visibility into observable server processes
+- **Configuration Editor**: Modify server settings
+- **Performance Dashboard**: View metrics and health
+
+## Design Principles
+
+1. **Dogfooding**: Built entirely with jsgui3 controls
+2. **Real-time**: Uses `Remote_Observable` for live updates
+3. **Extensible**: Plugin architecture for custom panels
+4. **Polished UX**: Modern dark theme, smooth transitions

package/docs/books/jsgui3-bundling-research-book/00-table-of-contents.md

@@ -0,0 +1,35 @@
+# 0. Table of Contents
+
+## Part I: What the Bundler Does Today
+
+1. [Pipeline and Runtime Semantics](01-pipeline-and-runtime-semantics.md)
+2. [JavaScript Bundling Core](02-javascript-bundling-core.md)
+3. [Style Extraction and CSS Compilation](03-style-extraction-and-css-compilation.md)
+4. [Static Publishing and Delivery](04-static-publishing-and-delivery.md)
+
+## Part II: Why Bundles Are Still Larger Than Needed
+
+5. [Current Limits and Size-Bloat Vectors](05-current-limits-and-size-bloat-vectors.md)
+
+## Part III: How to Get to Lightweight Bundles
+
+6. [Unused Module Elimination Strategy](06-unused-module-elimination-strategy.md)
+7. [jsgui3-html Control and Mixin Pruning](07-jsgui3-html-control-and-mixin-pruning.md)
+8. [Test and Verification Methodology](08-test-and-verification-methodology.md)
+9. [Roadmap and Rollout](09-roadmap-and-rollout.md)
+10. [Further Research: Strategies and Upgrades](10-further-research-strategies-and-upgrades.md)
+
+## Primary Code Surfaces Referenced
+
+- `publishers/http-webpageorsite-publisher.js`
+- `publishers/http-webpage-publisher.js`
+- `publishers/helpers/preparers/static/bundle/Static_Routes_Responses_Webpage_Bundle_Preparer.js`
+- `publishers/helpers/assigners/static-routes/Single_Control_Webpage_Server_Static_Routes_Assigner.js`
+- `publishers/helpers/assigners/static-uncompressed-response-buffers/Single_Control_Webpage_Server_Static_Uncompressed_Response_Buffers_Assigner.js`
+- `publishers/helpers/assigners/static-compressed-response-buffers/Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner.js`
+- `publishers/helpers/assigners/static-headers/Single_Control_Webpage_Server_Static_Headers_Assigner.js`
+- `resources/processors/bundlers/js/esbuild/Advanced_JS_Bundler_Using_ESBuild.js`
+- `resources/processors/bundlers/js/esbuild/Core_JS_Non_Minifying_Bundler_Using_ESBuild.js`
+- `resources/processors/bundlers/js/esbuild/Core_JS_Single_File_Minifying_Bundler_Using_ESBuild.js`
+- `resources/processors/extractors/js/css_and_js/AST_Node/CSS_And_JS_From_JS_String_Using_AST_Node_Extractor.js`
+- `resources/processors/bundlers/style-bundler.js`

package/docs/books/jsgui3-bundling-research-book/01-pipeline-and-runtime-semantics.md

@@ -0,0 +1,34 @@
+# 1. Pipeline and Runtime Semantics
+
+## System Entry Point
+
+For webpage/site publishing, the active bundling entry path is:
+
+1. `HTTP_Webpage_Publisher.get_ready()`
+2. `HTTP_Webpageorsite_Publisher.get_ready()`
+3. `JS_Bundler.bundle(src_path_client_js)`
+4. static route/response preparation
+
+The concrete orchestrator is `publishers/http-webpageorsite-publisher.js`, which constructs `JS_Bundler` and awaits `js_bundler.bundle(...)`.
+
+## Bundle Payload Contract
+
+The bundle object is `Bundle` (a `Collection`) from `resources/processors/bundlers/bundle.js`. Effective convention is:
+
+- bundle array with one `Bundle` instance
+- `Bundle._arr` containing items such as:
+  - `{ type: 'JavaScript', extension: 'js', text: '...' }`
+  - `{ type: 'CSS', extension: 'css', text: '...' }`
+  - `{ type: 'HTML', extension: 'html', text: '...' }` (added by webpage publisher)
+
+This contract is implicit and shared by publishers/assigners.
+
+## Readiness and Failure Semantics
+
+`HTTP_Webpage_Publisher` starts an async readiness flow in constructor and emits `'ready'` on success. On error, it emits `'error'` and then still emits `'ready'` with `{}` so upstream startup can continue.
+
+`HTTP_Webpageorsite_Publisher.get_ready()` also has defensive fallback for missing `src_path_client_js`, returning placeholder JS/CSS text items.
+
+## Consequence
+
+The current design prioritizes startup continuity over hard failure. This is operationally useful, but for strict production correctness a separate "fail-fast bundling" mode should exist.

package/docs/books/jsgui3-bundling-research-book/02-javascript-bundling-core.md

@@ -0,0 +1,36 @@
+# 2. JavaScript Bundling Core
+
+## Active JS Bundler Chain
+
+`resources/processors/bundlers/js-bundler.js` exports `./js/JS_Bundler`, which exports `./esbuild/Advanced_JS_Bundler_Using_ESBuild`.
+
+That advanced bundler composes two core stages:
+
+1. `Core_JS_Non_Minifying_Bundler_Using_ESBuild`
+2. `Core_JS_Single_File_Minifying_Bundler_Using_ESBuild` (production branch)
+
+## Stage A: Non-Minifying Bundle
+
+`Core_JS_Non_Minifying_Bundler_Using_ESBuild` executes `esbuild.build` with:
+
+- `bundle: true`
+- `treeShaking: true`
+- `write: false`
+- optional sourcemap, controlled by `sourcemaps.enabled`, `debug`, and `includeInProduction`
+
+It returns a one-item `Bundle` containing JavaScript text.
+
+## Stage B: Style-Assignment Removal
+
+`Advanced_JS_Bundler_Using_ESBuild` parses the Stage A JS, extracts style assignments, and produces CSS-free JS text for a second JS pass.
+
+## Stage C: Debug/Production Split
+
+- Debug path: re-bundle CSS-free JS without minification.
+- Production path: re-bundle CSS-free JS, then run minifier bundler.
+
+Minifier behavior is configurable by `bundler.minify` with levels `conservative | normal | aggressive` and option overrides.
+
+## Existing Optimization Character
+
+The current model is "bundle then sanitize" rather than "module graph first with explicit retained-module manifest." It relies heavily on esbuild tree shaking plus post-bundle style extraction.

package/docs/books/jsgui3-bundling-research-book/03-style-extraction-and-css-compilation.md

@@ -0,0 +1,35 @@
+# 3. Style Extraction and CSS Compilation
+
+## Extraction Target
+
+`CSS_And_JS_From_JS_String_Using_AST_Node_Extractor` scans bundled JS AST and finds assignment expressions where:
+
+- left side is a member expression ending in `css`, `scss`, or `sass`
+- right side is a template literal
+
+Matched style source is collected, and assignment source spans are removed from JS output.
+
+## Output Shape
+
+Extractor returns:
+
+- `css` (concatenated)
+- `scss` (concatenated)
+- `sass` (concatenated)
+- `style_segments` (ordered typed segments)
+- `js` (style-assignment-free JS)
+
+## Compilation Phase
+
+`resources/processors/bundlers/style-bundler.js` compiles style payloads via `SASS_Compiler` when SCSS/SASS is present (or when CSS is configured to compile through sass). It supports:
+
+- mixed segment compilation
+- load paths
+- output style
+- optional inline sourcemaps
+
+The compiled CSS is appended as a `CSS` bundle item.
+
+## Current Limits
+
+Extraction currently depends on a specific syntactic shape (`AssignmentExpression` + template literal). Non-matching style declaration patterns can evade extraction and remain in JS, which both bloats JS and risks duplicate style semantics.

package/docs/books/jsgui3-bundling-research-book/04-static-publishing-and-delivery.md

@@ -0,0 +1,39 @@
+# 4. Static Publishing and Delivery
+
+## Preparation Chain
+
+`Static_Routes_Responses_Webpage_Bundle_Preparer.prepare(...)` runs:
+
+1. route assignment
+2. identity buffer assignment
+3. compressed buffer assignment
+4. response header assignment
+
+## Route Model
+
+`Single_Control_Webpage_Server_Static_Routes_Assigner` maps by type:
+
+- JavaScript -> `/js/js.js`
+- CSS -> `/css/css.css`
+- HTML -> `/`
+
+This is deterministic but static; no fingerprinted asset paths yet.
+
+## Encoding Model
+
+`Single_Control_Webpage_Server_Static_Uncompressed_Response_Buffers_Assigner` writes `response_buffers.identity`.
+
+`Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner` optionally adds:
+
+- `response_buffers.gzip`
+- `response_buffers.br`
+
+Configurable controls include `enabled`, `algorithms`, `gzip.level`, `brotli.quality`, and `threshold`.
+
+## Header Model
+
+`Single_Control_Webpage_Server_Static_Headers_Assigner` writes headers per encoding variant under `item.response_headers[encoding]`, including `Content-Length`, `Content-Type`, and `Content-Encoding` where applicable.
+
+## Practical Implication
+
+The delivery layer is currently path-stable and content-encoding-aware but not cache-fingerprint-aware. Lightweight bundles can still be produced, but CDN/browser cache efficiency is constrained by fixed asset names.

package/docs/books/jsgui3-bundling-research-book/05-current-limits-and-size-bloat-vectors.md

@@ -0,0 +1,25 @@
+# 5. Current Limits and Size-Bloat Vectors
+
+## Bloat Vector 1: Entry-Point Over-Inclusion
+
+If the client entry imports a broad namespace (or re-export hub), esbuild includes reachable modules conservatively. Tree shaking helps, but side-effect ambiguity limits elimination.
+
+## Bloat Vector 2: Side Effects and Dynamic Access
+
+Patterns like dynamic member access, side-effectful module initialization, or broad registry mutation make safe elimination harder. Bundlers retain uncertain modules by design.
+
+## Bloat Vector 3: Post-Bundle Style Extraction Cost
+
+Current strategy performs non-minifying bundle first, then AST style extraction, then JS rebundle/minify. This gives clean CSS separation but incurs additional processing and can retain JS content not representable as removable style assignments.
+
+## Bloat Vector 4: Fixed Aggregate Assets
+
+Everything converges to a single `/js/js.js` and `/css/css.css` asset pair. This simplifies runtime, but does not naturally support granular shared-chunk caching.
+
+## Bloat Vector 5: Startup-Continuity Fallbacks
+
+Bundling fallback behavior favors server startup continuity. If fallback text assets are accepted too loosely in operational workflows, latent size/perf regressions may go unnoticed.
+
+## Core Observation
+
+The system is robust and functionally coherent, but it lacks a first-class "reachability report + elimination policy" layer that explains exactly what was retained and why.

package/docs/books/jsgui3-bundling-research-book/06-unused-module-elimination-strategy.md

@@ -0,0 +1,77 @@
+# 6. Unused Module Elimination Strategy
+
+## Design Goal
+
+Add deterministic dead-module elimination while preserving runtime correctness and keeping current high-level APIs stable.
+
+## Phase 1: Observability First
+
+Introduce a bundle analysis artifact per build:
+
+- `module_graph_manifest.json`
+- fields: module path, retained/pruned flag, retention reason, side-effect classification, importer chain
+
+Use esbuild `metafile` as baseline graph input. Do not prune yet in this phase.
+
+## Phase 2: Policy-Based Pruning
+
+Add pruning policies:
+
+- `safe`: prune only modules proven side-effect free and unreachable from entry exports
+- `balanced`: allow package-level side-effect allowlists
+- `aggressive`: opt-in broader pruning with explicit risk declaration
+
+Each pruned module must carry an auditable reason code.
+
+## Phase 3: Runtime Safety Guardrails
+
+Add optional runtime checks in debug mode:
+
+- missing symbol trap hooks for known registries
+- warning when dynamic lookup requests pruned modules
+
+## Proposed Configuration Surface
+
+```js
+bundler: {
+  elimination: {
+    enabled: true,
+    profile: 'safe',
+    emit_manifest: true,
+    fail_on_uncertain_prune: true
+  }
+}
+```
+
+## Contract
+
+The contract must be: "No silent pruning." Every elimination decision is traceable in emitted metadata.
+
+## Current Implementation (Initial)
+
+`jsgui3-server` now includes an initial `jsgui3-html` control scan-and-package path in the advanced esbuild bundler.
+
+Enable it with:
+
+```js
+bundler: {
+  elimination: {
+    enabled: true,
+    jsgui3_html_controls: {
+      enabled: true
+    }
+  }
+}
+```
+
+Behavior:
+
+- scans reachable source files from the entry file
+- detects static `jsgui3-html` control usage patterns
+- builds a lightweight shim exporting only selected controls
+- aliases `require('jsgui3-html')` to that shim during bundling
+- attaches scan metadata at `bundle.bundle_analysis.jsgui3_html_control_scan`
+
+Safety:
+
+- if dynamic control indexing is detected (`controls[some_var]`), optimization is disabled by default

package/docs/books/jsgui3-bundling-research-book/07-jsgui3-html-control-and-mixin-pruning.md

@@ -0,0 +1,63 @@
+# 7. jsgui3-html Control and Mixin Pruning
+
+## Objective
+
+Allow `jsgui3-html` to grow in feature breadth while keeping simple app bundles lightweight by pruning unused controls, mixins, and helper modules.
+
+## Constraint Surface
+
+`jsgui3-html` usage often includes:
+
+- direct imports (`const {Window} = require('jsgui3-html').controls`)
+- registry-style access (`jsgui.controls.some_control`)
+- inheritance chains and mixin composition
+
+Pruning must account for all three.
+
+## Reachability Model
+
+Build a typed symbol graph with nodes:
+
+- controls
+- mixins
+- utility helpers
+- transitive runtime support modules
+
+Edges:
+
+- static import/require edges
+- inheritance edges
+- mixin application edges
+- registry publication edges
+
+A module is retained if any retained symbol depends on it.
+
+## Beyond Controls and Mixins
+
+The same graph can prune additional payload classes:
+
+- optional theme packs
+- optional icon packs
+- optional debug instrumentation
+- optional adapter layers (for features not used by the app)
+- feature-local helper modules that are only referenced by pruned controls
+
+## Packaging Recommendation
+
+Within `jsgui3-html`, define explicit boundaries:
+
+- `core` (always lightweight baseline)
+- optional feature groups (advanced controls, diagnostics, heavy widgets)
+
+Then allow bundler elimination to prune unused optional groups based on symbol reachability.
+
+## Dynamic-Access Safety
+
+When dynamic registry access is detected and symbol resolution is uncertain:
+
+- `safe` profile retains uncertain candidates
+- manifest records reason as `dynamic_access_uncertain`
+
+## Result
+
+This produces consistent APIs while allowing bundle contents to shrink significantly for narrow use cases.

package/docs/books/jsgui3-bundling-research-book/08-test-and-verification-methodology.md

@@ -0,0 +1,43 @@
+# 8. Test and Verification Methodology
+
+## Verification Principle
+
+Bundle-size optimization is valid only if behavioral equivalence is maintained for supported usage profiles.
+
+## Test Layers
+
+1. Unit tests for elimination graph logic
+2. Integration tests for bundler output and route serving
+3. E2E browser tests for real interaction flows (Puppeteer)
+4. Size-regression tests with per-fixture budgets
+
+## Bundle Correctness Tests
+
+For each fixture app:
+
+- generate baseline bundle (elimination disabled)
+- generate optimized bundle (elimination enabled)
+- compare runtime outcomes and key DOM/event traces
+- compare bundle size deltas against expected thresholds
+
+## Puppeteer Scenarios
+
+For control-heavy examples:
+
+- open page and wait for control activation markers
+- perform high-specificity interactions (drag, resize, date pick, color pick, keyboard paths)
+- assert expected UI state and emitted network/API behavior
+
+For resource-integrated flows:
+
+- verify client-visible state updates driven by server resources
+- verify SSE/event paths where applicable
+- confirm no missing-symbol/runtime errors caused by pruning
+
+## Gating Policy
+
+A prune policy cannot be promoted from experimental to default unless:
+
+- all functional suites pass
+- bundle manifest diff is stable and explainable
+- size regression thresholds are met across representative fixtures.