retold 1.0.6 → 4.0.2

package/docs/modules/meadow.md

@@ -0,0 +1,209 @@
+# Meadow — Data Access Layer
+
+Meadow provides provider-agnostic data access for Retold applications. Define your entities once, and Meadow handles CRUD operations, query generation, schema management, and audit tracking across MySQL, MSSQL, SQLite, or in-browser ALASQL.
+
+## How the Pieces Fit
+
+```mermaid
+graph LR
+  app["Application Code"] --> meadow["Meadow<br/>(ORM)"]
+  meadow --> foxhound["FoxHound<br/>(Query DSL)"]
+  foxhound --> conn["Connection<br/>(mysql/mssql/sqlite)"]
+  conn --> db[("Database")]
+  meadow --> stricture["Stricture<br/>(Schema)"]
+  stricture --> output["JSON Schema<br/>DDL<br/>Documentation"]
+
+  style app fill:#e8f5e9,stroke:#43a047,color:#333
+  style meadow fill:#fff3e0,stroke:#ffa726,color:#333
+  style foxhound fill:#fff3e0,stroke:#ffcc80,color:#333
+  style conn fill:#fff3e0,stroke:#ffcc80,color:#333
+  style stricture fill:#fff3e0,stroke:#ffcc80,color:#333
+  style db fill:#ffebee,stroke:#ef5350,color:#333
+  style output fill:#f5f5f5,stroke:#bdbdbd,color:#666
+```
+
+**Meadow** is the data broker — it exposes CRUD methods, handles audit columns, and delegates query building and execution to FoxHound and the connection provider.
+
+**FoxHound** generates SQL from a fluent API. Write one query definition; get correct SQL for any supported dialect.
+
+**Stricture** defines schemas in a simple MicroDDL format and generates JSON, SQL DDL, documentation, and Meadow schema files from a single source of truth.
+
+## Core Modules
+
+### [Meadow](/meadow/meadow/)
+
+The central data broker. Each Meadow instance represents one data entity (table).
+
+```javascript
+const libFable = require('fable');
+const libMeadow = require('meadow');
+
+let _Fable = new libFable({
+    Product: 'BookStore',
+    MySQL: { Server: 'localhost', User: 'root', Database: 'bookstore' }
+});
+
+let _BookMeadow = _Fable.instantiateServiceProvider('Meadow',
+{
+    Scope: 'Book',
+    DefaultSchema: require('./Book-Schema.json')
+});
+```
+
+**Built-in operations:**
+
+| Operation | Method | Description |
+|-----------|--------|-------------|
+| Create | `.doCreate(record, callback)` | Insert a new record |
+| Read | `.doRead(id, callback)` | Get one record by ID |
+| Reads | `.doReads(query, callback)` | Get multiple records with filtering |
+| Update | `.doUpdate(record, callback)` | Update an existing record |
+| Delete | `.doDelete(id, callback)` | Soft-delete a record |
+| Undelete | `.doUndelete(id, callback)` | Restore a soft-deleted record |
+| Count | `.doCount(query, callback)` | Count matching records |
+
+**Automatic features:** audit columns (CreatingIDUser, UpdatingIDUser, CreateDate, UpdateDate), soft deletes (Deleted flag + DeleteDate), GUID uniqueness (GUIDBook column), and data marshalling.
+
+**npm:** `meadow` · **Version:** 2.0.x
+
+---
+
+### [FoxHound](/meadow/foxhound/)
+
+A fluent query DSL that generates dialect-specific SQL.
+
+```javascript
+let tmpQuery = _Fable.instantiateServiceProvider('FoxHound')
+    .setScope('Book')
+    .addFilter('Author', 'Tolkien')
+    .addFilter('YearPublished', '1954', '>=')
+    .setSort('Title')
+    .setBegin(0).setCap(10)
+    .buildReadQuery();
+
+// MySQL:  SELECT * FROM Book WHERE Author = 'Tolkien'
+//         AND YearPublished >= '1954' ORDER BY Title LIMIT 0,10
+// MSSQL:  SELECT TOP 10 * FROM Book WHERE Author = 'Tolkien' ...
+// SQLite: SELECT * FROM Book WHERE Author = 'Tolkien' ... LIMIT 10 OFFSET 0
+```
+
+**Supported dialects:** MySQL, MSSQL, SQLite, ALASQL (in-browser)
+
+**Operations:** Create, Read, Update, Delete, Count — each generates the correct SQL for the configured dialect with parameterized queries to prevent injection.
+
+**npm:** `foxhound` · **Version:** 2.0.x
+
+---
+
+### [Stricture](/meadow/stricture/)
+
+A MicroDDL for rapid data model definition.
+
+```
+# Book entity
+Book
+	IDBook           | int    | identity | primary
+	GUIDBook         | guid   | unique
+	Title            | string(200)
+	Author           | string(200)
+	YearPublished    | int
+	ISBN             | string(20)
+```
+
+From this definition, Stricture generates:
+
+- **JSON schema** — For Meadow entity configuration
+- **MySQL CREATE TABLE** — Database DDL with indexes
+- **Meadow schema** — Column definitions for the data broker
+- **Documentation** — Human-readable data model docs
+
+**npm:** `stricture` · **Version:** 1.0.x
+
+---
+
+### [Meadow-Endpoints](/meadow/meadow-endpoints/)
+
+Auto-generates a full REST API from a Meadow entity. Given a "Book" entity, you get:
+
+| Route | Method | Operation |
+|-------|--------|-----------|
+| `GET /Books` | Reads | List with filtering and pagination |
+| `GET /Books/Count` | Count | Record count |
+| `GET /Book/:id` | Read | Single record by ID |
+| `GET /Book/Schema` | Schema | Entity schema definition |
+| `POST /Book` | Create | Insert new record |
+| `PUT /Book` | Update | Modify existing record |
+| `DEL /Book/:id` | Delete | Soft-delete record |
+| `DEL /Book/:id/Undelete` | Undelete | Restore record |
+
+**Behavior injection** lets you add hooks at any lifecycle point:
+
+```javascript
+_Endpoints.BehaviorModifications.setBehavior('Read-Authorize',
+    function(pRequest, fCallback)
+    {
+        // Check permissions before allowing the read
+        if (!pRequest.UserSession.authenticated)
+        {
+            pRequest.CommonServices.log.warn('Unauthorized access attempt');
+            return fCallback('Unauthorized');
+        }
+        return fCallback();
+    });
+```
+
+**npm:** `meadow-endpoints` · **Version:** 4.0.x
+
+---
+
+### [Retold-Data-Service](/meadow/retold-data-service/)
+
+An all-in-one Fable service that assembles a Stricture schema into a complete REST API — Meadow entity, endpoints, and connection — in a single service instantiation.
+
+```javascript
+let _BookService = _Fable.instantiateServiceProvider('RetoldDataService',
+{
+    Scope: 'Book',
+    Schema: BookSchema
+});
+
+// That's it — full CRUD REST API is ready to be wired to Orator
+```
+
+**npm:** `retold-data-service` · **Version:** 2.0.x
+
+## Connection Modules
+
+| Module | Database | npm |
+|--------|----------|-----|
+| [meadow-connection-mysql](/meadow/meadow-connection-mysql/) | MySQL / MariaDB | `meadow-connection-mysql` |
+| [meadow-connection-mssql](/meadow/meadow-connection-mssql/) | Microsoft SQL Server | `meadow-connection-mssql` |
+| [meadow-connection-sqlite](/meadow/meadow-connection-sqlite/) | SQLite (via better-sqlite3) | `meadow-connection-sqlite` |
+
+Each connection module provides a pooled database connection as a Fable service. Swap between databases by changing which connection module you install — no application code changes needed.
+
+## Supporting Modules
+
+| Module | Purpose | npm |
+|--------|---------|-----|
+| [bibliograph](/meadow/bibliograph/) | Key-value record comprehension for change tracking in ingestion pipelines | `bibliograph` |
+| [parime](/meadow/parime/) | Generic data lake behaviors and services | `parime` |
+| [retold-harness](/meadow/retold-harness/) | Pre-built API harness with a bookstore demo (8 entities, 10,000+ records) | `retold-harness` |
+| [meadow-integration](/meadow/meadow-integration/) | Data integration tools for CSV import and schema mapping | `meadow-integration` |
+
+## All Meadow Modules
+
+| Module | Description |
+|--------|-------------|
+| [stricture](/meadow/stricture/) | MicroDDL schema definition and code generation |
+| [foxhound](/meadow/foxhound/) | Fluent query DSL with multi-dialect SQL generation |
+| [bibliograph](/meadow/bibliograph/) | Record-level change tracking |
+| [meadow](/meadow/meadow/) | Provider-agnostic data broker and ORM |
+| [parime](/meadow/parime/) | Data lake behaviors |
+| [meadow-endpoints](/meadow/meadow-endpoints/) | Automatic RESTful CRUD endpoint generation |
+| [meadow-connection-mysql](/meadow/meadow-connection-mysql/) | MySQL connection provider |
+| [meadow-connection-mssql](/meadow/meadow-connection-mssql/) | MSSQL connection provider |
+| [meadow-connection-sqlite](/meadow/meadow-connection-sqlite/) | SQLite connection provider |
+| [retold-data-service](/meadow/retold-data-service/) | All-in-one schema-to-REST-API service |
+| [retold-harness](/meadow/retold-harness/) | Demo API harness with bookstore dataset |
+| [meadow-integration](/meadow/meadow-integration/) | Data integration and CSV import |

package/docs/modules/orator.md

@@ -0,0 +1,165 @@
+# Orator — API Server
+
+Orator provides an unopinionated HTTP server abstraction for Retold applications. It wraps service server implementations (Restify for production, IPC for testing) behind a consistent interface, so your application code does not depend on any specific HTTP library.
+
+## How It Works
+
+```mermaid
+graph TB
+  app["Your Application<br/>(routes, middleware, etc.)"]
+  app --> core["Orator Core<br/>Lifecycle, content types,<br/>route registration"]
+  core --> restify["Restify Server<br/>(Production)"]
+  core --> ipc["IPC Server<br/>(Testing)"]
+  core --> other["(Other servers)"]
+
+  style app fill:#e8f5e9,stroke:#43a047,color:#333
+  style core fill:#e3f2fd,stroke:#42a5f5,color:#333
+  style restify fill:#fff,stroke:#90caf9,color:#333
+  style ipc fill:#fff,stroke:#90caf9,color:#333
+  style other fill:#f5f5f5,stroke:#bdbdbd,color:#666
+```
+
+Your application registers routes, middleware, and lifecycle hooks with Orator. Orator delegates to whichever service server implementation is configured — Restify for real HTTP, IPC for in-process testing.
+
+## Core Modules
+
+### [Orator](/orator/orator/)
+
+The main server abstraction. Manages lifecycle, route registration, and service server delegation.
+
+```javascript
+const libFable = require('fable');
+const libOrator = require('orator');
+
+let _Fable = new libFable({
+    Product: 'MyAPI',
+    APIServerPort: 8080
+});
+
+let _Orator = _Fable.instantiateServiceProvider('Orator');
+
+// Register routes
+_Orator.addRoute('GET', '/health', function(pRequest, pResponse, fNext)
+{
+    pResponse.send({ status: 'ok' });
+    return fNext();
+});
+
+// Start the server
+_Orator.startService(function(pError)
+{
+    _Fable.log.info('Server listening on port 8080');
+});
+```
+
+**Lifecycle hooks** let you inject behavior at server startup, before/after route handling, and at shutdown:
+
+```javascript
+_Orator.addPreStartFunction(function(fCallback) { /* ... */ return fCallback(); });
+_Orator.addPreRouteFunction(function(pRequest, pResponse, fNext) { /* ... */ return fNext(); });
+```
+
+**npm:** `orator` · **Version:** 5.0.x
+
+---
+
+### [Orator-ServiceServer-Restify](/orator/orator-serviceserver-restify/)
+
+Production HTTP server powered by Restify. Provides full HTTP support, body parsing, CORS, middleware, and configurable listen options.
+
+This is the server implementation used for real deployments. Install it alongside Orator and it registers itself automatically.
+
+```javascript
+const libOrator = require('orator');
+require('orator-serviceserver-restify');
+
+// Restify server is now the active service server
+```
+
+**npm:** `orator-serviceserver-restify` · **Version:** 2.0.x
+
+---
+
+### [Orator-Static-Server](/orator/orator-static-server/)
+
+Static file serving for Orator with MIME type detection, default file support, subdomain-based folder routing, and configurable route prefix stripping.
+
+```javascript
+_Orator.addStaticRoute('/app', '/var/www/app/dist');
+```
+
+**npm:** `orator-static-server` · **Version:** 1.0.x
+
+---
+
+### [Orator-HTTP-Proxy](/orator/orator-http-proxy/)
+
+Reverse proxy for forwarding requests to backend services. Supports multiple HTTP verbs and handles HTTP-to-HTTPS translation.
+
+```javascript
+_Orator.addProxyRoute('/api/external', 'https://backend.example.com/api');
+```
+
+**npm:** `orator-http-proxy` · **Version:** 1.0.x
+
+---
+
+### [Tidings](/orator/tidings/)
+
+An extensible reporting system for generating HTML, PDF, and other format reports. Provides asset collection, templating, and rasterization in a micro-service-friendly pattern.
+
+**npm:** `tidings` · **Version:** 1.0.x
+
+---
+
+### [Orator-Endpoint](/orator/orator-endpoint/)
+
+A base class for creating reusable, pluggable API endpoint handlers that can be shared across Orator applications.
+
+**npm:** `orator-endpoint` · **Version:** 1.0.x
+
+## Typical Setup
+
+A standard API server combines Orator with Meadow-Endpoints:
+
+```javascript
+const libFable = require('fable');
+const libOrator = require('orator');
+const libMeadowEndpoints = require('meadow-endpoints');
+require('orator-serviceserver-restify');
+
+let _Fable = new libFable({
+    Product: 'BookAPI',
+    APIServerPort: 8086,
+    MySQL: { Server: 'localhost', User: 'root', Database: 'bookstore' }
+});
+
+let _Orator = _Fable.instantiateServiceProvider('Orator');
+
+// Create a data entity and wire its endpoints to Orator
+let _BookEntity = _Fable.instantiateServiceProvider('Meadow',
+    { Scope: 'Book', DefaultSchema: BookSchema });
+let _BookEndpoints = _Fable.instantiateServiceProvider('MeadowEndpoints',
+    { Entity: _BookEntity });
+_BookEndpoints.connectRoutes(_Orator);
+
+// Start serving
+_Orator.startService((pError) =>
+{
+    _Fable.log.info('BookAPI running on :8086');
+});
+```
+
+This gives you a full REST API with Create, Read, Reads, Update, Delete, Undelete, Count, and Schema endpoints for the Book entity — all auto-generated.
+
+## All Orator Modules
+
+| Module | Description |
+|--------|-------------|
+| [orator](/orator/orator/) | HTTP server abstraction with lifecycle hooks |
+| [orator-serviceserver-restify](/orator/orator-serviceserver-restify/) | Production HTTP server via Restify |
+| [orator-static-server](/orator/orator-static-server/) | Static file serving with MIME detection |
+| [orator-http-proxy](/orator/orator-http-proxy/) | HTTP reverse proxy pass-through |
+| [tidings](/orator/tidings/) | Reporting scaffolding for HTML/PDF output |
+| [orator-endpoint](/orator/orator-endpoint/) | Reusable endpoint base class |
+| [orator-conversion](/orator/orator-conversion/) | File format conversion endpoints |

package/docs/modules/pict.md

@@ -0,0 +1,235 @@
+# Pict — MVC Tools
+
+Pict provides a non-opinionated set of Model-View-Controller tools for building user interfaces. Its core insight: UI is text. Whether you are rendering to a browser DOM, a terminal, or generating strings for another system, Pict treats the output as rendered text and gives you a consistent set of tools for managing views, templates, data, and application lifecycle.
+
+## Design Philosophy
+
+Pict does not impose opinions about what MVC means. It provides discrete tools — Views, Templates, Providers, and an Application class — that you can use individually or compose together.
+
+*Pict is a subclass of Fable*, so does everything fable does.
+
+- **Views** manage lifecycle (initialize, render, marshal data) and render templates into target containers
+- **Templates** are text with expressions that resolve against application state
+- **Providers** fetch and manage data for views
+- **The Application class** coordinates view lifecycle and shared state
+
+```mermaid
+graph TB
+  subgraph PictApp["Pict Application"]
+    appdata["Application State (AppData)"]
+    appdata --> viewA["View A"]
+    appdata --> viewB["View B"]
+    appdata --> viewC["View C"]
+    viewA <--> viewB <--> viewC
+    viewA --> tplA["Templates"] --> outA["Rendered Output"]
+    viewB --> tplB["Templates"] --> outB["Rendered Output"]
+    viewC --> tplC["Templates"] --> outC["Rendered Output"]
+  end
+
+  style PictApp fill:#f3e5f5,stroke:#ab47bc,color:#333
+  style appdata fill:#e1bee7,stroke:#ab47bc,color:#333
+  style viewA fill:#fff,stroke:#ce93d8,color:#333
+  style viewB fill:#fff,stroke:#ce93d8,color:#333
+  style viewC fill:#fff,stroke:#ce93d8,color:#333
+  style tplA fill:#f5f5f5,stroke:#bdbdbd,color:#666
+  style tplB fill:#f5f5f5,stroke:#bdbdbd,color:#666
+  style tplC fill:#f5f5f5,stroke:#bdbdbd,color:#666
+  style outA fill:#e8f5e9,stroke:#66bb6a,color:#666
+  style outB fill:#e8f5e9,stroke:#66bb6a,color:#666
+  style outC fill:#e8f5e9,stroke:#66bb6a,color:#666
+```
+
+## Core Modules
+
+### [Pict](/pict/pict/)
+
+The main module. Creates the application context, manages template and view registries, provides the template expression engine, and coordinates rendering.
+
+```javascript
+const libPict = require('pict');
+
+let _Pict = new libPict({
+    Product: 'MyApp',
+    DefaultRenderable: true
+});
+
+// Register a template
+_Pict.TemplateProvider.addTemplate('HelloTemplate',
+    '<h1>Hello {~Data:Record.Name~}!</h1>');
+
+// Set some data
+_Pict.AppData.Record = { Name: 'World' };
+```
+
+**Template expressions** use the `{~ ~}` syntax to resolve data, call templates, invoke providers, and perform logic:
+
+| Expression | Purpose | Example |
+|-----------|---------|---------|
+| `{~Data:Path~}` | Resolve data from AppData | `{~Data:Record.Name~}` |
+| `{~Template:Name~}` | Render another template | `{~Template:Header~}` |
+| `{~Each:Array:Template~}` | Iterate and render | `{~Each:Records:RowTemplate~}` |
+| `{~If:Condition~}` | Conditional rendering | `{~If:Record.Active~}` |
+
+**npm:** `pict` · **Version:** 1.0.x
+
+---
+
+### [Pict-View](/pict/pict-view/)
+
+The View base class. Views manage a complete lifecycle — initialization, rendering, data marshaling (two-way binding), CSS injection, and teardown.
+
+```javascript
+const libPictView = require('pict-view');
+
+class MyView extends libPictView
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+        this.serviceType = 'MyView';
+    }
+
+    onBeforeRender()
+    {
+        this.log.info('About to render');
+    }
+
+    onAfterMarshalFromView()
+    {
+        // Data has been pulled from the DOM back into AppData
+    }
+}
+```
+
+**View lifecycle:** Initialize → Render → Solve → Marshal From View → Marshal To View
+
+**npm:** `pict-view` · **Version:** 1.0.x
+
+---
+
+### [Pict-Template](/pict/pict-template/)
+
+Base class for custom template handlers. Extend this to add new template expression types beyond the built-in set.
+
+**npm:** `pict-template` · **Version:** 1.0.x
+
+---
+
+### [Pict-Provider](/pict/pict-provider/)
+
+Base class for data providers. Providers fetch, transform, and deliver data to views.
+
+**npm:** `pict-provider` · **Version:** 1.0.x
+
+---
+
+### [Pict-Application](/pict/pict-application/)
+
+Application base class that coordinates multiple views, manages shared state, and provides structured lifecycle management for complete applications.
+
+```javascript
+const libPictApplication = require('pict-application');
+
+class MyApp extends libPictApplication
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+        this.serviceType = 'MyApp';
+    }
+
+    onAfterInitialize()
+    {
+        // Register views, load data, start rendering
+    }
+}
+```
+
+**npm:** `pict-application` · **Version:** 1.0.x
+
+## Section Modules
+
+Sections are pre-built view patterns for common UI needs.
+
+### [Pict-Section-Form](/pict/pict-section-form/)
+
+Configuration-driven dynamic forms. Define form layout, fields, validation, and data binding in JSON — the section handles rendering, data marshaling, and mathematical solving.
+
+Supports 13+ input types with custom providers for each. Used extensively for building data entry interfaces without writing HTML by hand.
+
+**npm:** `pict-section-form` · **Version:** 1.0.x
+
+---
+
+### [Pict-Section-Recordset](/pict/pict-section-recordset/)
+
+CRUD views (Create, Read, Update, Delete) based on Meadow endpoint schemas. Provides list views, detail views, and record management with data provider integration.
+
+**npm:** `pict-section-recordset` · **Version:** 1.0.x
+
+---
+
+### [Pict-Section-TUIGrid](/pict/pict-section-tuigrid/)
+
+Toast UI Grid integration for tabular data display. Provides spreadsheet-like data grids with sorting, filtering, and editing.
+
+**npm:** `pict-section-tuigrid` · **Version:** 1.0.x
+
+---
+
+### [Pict-Section-Content](/pict/pict-section-content/)
+
+Markdown parsing and content rendering with Mermaid diagrams and KaTeX math equations. Provides a reusable provider for markdown-to-HTML conversion and a styled view with post-render hooks.
+
+**npm:** `pict-section-content`
+
+---
+
+### [Pict-Section-Flow](/pict/pict-section-flow/)
+
+Flow diagram section for visual workflow and process representations.
+
+**npm:** `pict-section-flow`
+
+## Application Modules
+
+| Module | Purpose | npm |
+|--------|---------|-----|
+| [pict-docuserve](/pict/pict-docuserve/) | Single-page documentation viewer built on Pict with catalog navigation and search | `pict-docuserve` |
+| [pict-nonlinearconfig](/pict/pict-nonlinearconfig/) | Nonlinear configuration manager | `pict-nonlinearconfig` |
+
+## Supporting Modules
+
+| Module | Purpose | npm |
+|--------|---------|-----|
+| [pict-router](/pict/pict-router/) | Hash-based URL routing via Navigo with template string route functions | `pict-router` |
+| [pict-panel](/pict/pict-panel/) | Control panel component, hot-loadable from CDN | `pict-panel` |
+| [informary](/pict/informary/) | Dependency-free browser form marshaling with undo/redo and field-level deltas | `informary` |
+| [cryptbrau](/pict/cryptbrau/) | Simple in-browser symmetric encryption | `cryptbrau` |
+| [pict-serviceproviderbase](/pict/pict-serviceproviderbase/) | Base classes for Pict services with pre-initialization support | `pict-serviceproviderbase` |
+| [pict-service-commandlineutility](/pict/pict-service-commandlineutility/) | CLI utility tools built on Commander | `pict-service-commandlineutility` |
+| [pict-terminalui](/pict/pict-terminalui/) | Blessed-based terminal interface for Pict views | `pict-terminalui` |
+
+## All Pict Modules
+
+| Module | Description |
+|--------|-------------|
+| [pict](/pict/pict/) | Core MVC module with template engine |
+| [pict-template](/pict/pict-template/) | Custom template handler base class |
+| [pict-view](/pict/pict-view/) | View base class with full lifecycle |
+| [pict-provider](/pict/pict-provider/) | Data provider base class |
+| [pict-application](/pict/pict-application/) | Application lifecycle management |
+| [pict-panel](/pict/pict-panel/) | Hot-loadable control panel |
+| [pict-nonlinearconfig](/pict/pict-nonlinearconfig/) | Nonlinear configuration manager |
+| [pict-section-flow](/pict/pict-section-flow/) | Flow diagram section |
+| [pict-docuserve](/pict/pict-docuserve/) | Single-page documentation viewer |
+| [cryptbrau](/pict/cryptbrau/) | In-browser symmetric encryption |
+| [informary](/pict/informary/) | Browser form marshaling with undo/redo |
+| [pict-service-commandlineutility](/pict/pict-service-commandlineutility/) | CLI utility tools |
+| [pict-section-recordset](/pict/pict-section-recordset/) | CRUD record management views |
+| [pict-section-content](/pict/pict-section-content/) | Markdown parsing and content rendering |
+| [pict-section-form](/pict/pict-section-form/) | Configuration-driven dynamic forms |
+| [pict-section-tuigrid](/pict/pict-section-tuigrid/) | Toast UI Grid tabular data |
+| [pict-router](/pict/pict-router/) | Hash-based URL routing |
+| [pict-serviceproviderbase](/pict/pict-serviceproviderbase/) | Pict service base classes |
+| [pict-terminalui](/pict/pict-terminalui/) | Blessed-based terminal interface |

package/docs/modules/utility.md

@@ -0,0 +1,54 @@
+# Utility — Build & Documentation Tools
+
+The utility group provides supporting tools for building, documenting, testing, and supervising Retold applications.
+
+## Modules
+
+### [Indoctrinate](/utility/indoctrinate/)
+
+Documentation scaffolding and generation. Scans source trees, catalogs content with automatic label-based metadata, and generates structured output in multiple formats. Powers the Retold documentation hub by generating cross-module catalogs and keyword search indexes.
+
+**Key features:** Content cataloging with label-based filtering, multi-format output (HTML, LaTeX, text), Retold catalog generation for cross-repo documentation, lunr-based keyword index for cross-module search.
+
+**npm:** `indoctrinate` · **Version:** 1.0.x
+
+---
+
+### [Manyfest](/utility/manyfest/)
+
+JSON manifest for consistent data description and parsing across all application layers — database, API, frontend, and UI. Provides address-based access patterns for reading and writing nested object properties with validation and type coercion.
+
+**Key features:** Address-based data access (dot notation and array indexing), type validation and coercion, manifest-driven form generation, schema description for data layers.
+
+**npm:** `manyfest` · **Version:** 1.0.x
+
+---
+
+### [Quackage](/utility/quackage/)
+
+Standardized build tool for Retold modules. Handles browser bundling (Browserify), transpilation, unit testing, file management, JSON view assembly, and documentation generation from a single CLI.
+
+```bash
+npx quack build          # Build browser bundle
+npx quack test           # Run Mocha tests
+npx quack coverage       # Generate coverage report
+```
+
+**npm:** `quackage` · **Version:** 1.0.x
+
+---
+
+### [Ultravisor](/utility/ultravisor/)
+
+Process supervision tool for running commands on schedule with LLM integration. Supports distributed nodes, global state, and flexible task types (shell, browser, HTTP, database).
+
+**npm:** `ultravisor` · **Version:** 1.0.x
+
+## All Utility Modules
+
+| Module | Description |
+|--------|-------------|
+| [indoctrinate](/utility/indoctrinate/) | Documentation scaffolding with content cataloging and cross-module search |
+| [manyfest](/utility/manyfest/) | JSON manifest for data description, validation, and address-based access |
+| [quackage](/utility/quackage/) | Build tool for browser bundles, testing, and packaging |
+| [ultravisor](/utility/ultravisor/) | Process supervision with scheduled tasks and LLM integration |