fable 3.1.72 → 3.1.74

package/docs/README.md

@@ -16,10 +16,10 @@ Fable is a comprehensive framework that provides a service-oriented architecture
 ## Quick Start
 
 ```javascript
-const Fable = require('fable');
+const libFable = require('fable');
 
 // Create a new Fable instance with optional configuration
-const fable = new Fable({
+const fable = new libFable({
     Product: 'MyApplication',
     ProductVersion: '1.0.0',
     LogStreams: [
@@ -54,14 +54,32 @@ Fable services fall into three categories:
 ### Service Registration
 
 ```javascript
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ServiceRegistrationDemo', ProductVersion: '1.0.0' });
+
+// A trivial service class for demonstration purposes
+class MyServiceClass extends libFableServiceBase
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+        this.serviceType = 'MyService';
+    }
+}
+const options = { greeting: 'hello' };
+
 // Add a service type without instantiating
 fable.addServiceType('MyService', MyServiceClass);
+console.log('Registered service types include MyService:', 'MyService' in fable.serviceTypes);
 
 // Add and immediately instantiate a service
-fable.addAndInstantiateServiceType('MyService', MyServiceClass);
+fable.addAndInstantiateServiceType('AnotherService', MyServiceClass);
+console.log('AnotherService instantiated:', typeof fable.AnotherService);
 
 // Instantiate a service on-demand
 const myService = fable.instantiateServiceProvider('MyService', options, 'custom-hash');
+console.log('myService.serviceType:', myService.serviceType);
 ```
 
 ## Configuration
@@ -69,16 +87,22 @@ const myService = fable.instantiateServiceProvider('MyService', options, 'custom
 Fable accepts a configuration object that controls various aspects of behavior:
 
 ```javascript
-const fable = new Fable({
+const libFable = require('fable');
+
+const fable = new libFable({
     Product: 'MyApp',
     ProductVersion: '1.0.0',
     UUID: { DataCenter: 0, Worker: 0 },
     LogStreams: [
-        { level: 'info' },
-        { level: 'error', path: '/var/log/myapp/error.log' }
+        { level: 'info' }
+        // In Node.js you can also write a file-based stream, e.g.:
+        // { level: 'error', path: '/var/log/myapp/error.log' }
     ],
     RestClientURLPrefix: 'https://api.example.com'
 });
+
+console.log('Configured fable:', fable.settings.Product, 'v' + fable.settings.ProductVersion);
+console.log('RestClientURLPrefix setting:', fable.settings.RestClientURLPrefix);
 ```
 
 ## Documentation

package/docs/_brand.json

@@ -0,0 +1,18 @@
+{
+	"Hash": "fable",
+	"Name": "Fable",
+	"Tagline": "Service dependency injection, configuration, and logging library — the foundation of every Retold application",
+	"Palette": "mix",
+	"Icon": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 96 96\" width=\"96\" height=\"96\">\n\t\t<defs>\n\t\t\t<clipPath id=\"frame-fable-filled-light\">\n\t\t\t\t<path d=\"M 24 2\n\t\tH 72\n\t\tQ 94 2 94 24\n\t\tV 72\n\t\tQ 94 94 72 94\n\t\tH 24\n\t\tQ 2 94 2 72\n\t\tV 24\n\t\tQ 2 2 24 2 Z\"/>\n\t\t\t</clipPath>\n\t\t</defs>\n\t\t<path d=\"M 24 2\n\t\tH 72\n\t\tQ 94 2 94 24\n\t\tV 72\n\t\tQ 94 94 72 94\n\t\tH 24\n\t\tQ 2 94 2 72\n\t\tV 24\n\t\tQ 2 2 24 2 Z\" fill=\"#af2aef\"/>\n\t\t<g clip-path=\"url(#frame-fable-filled-light)\"><circle cx=\"48\" cy=\"48\" r=\"36\" fill=\"none\" stroke=\"#4ed5e8\" stroke-width=\"2\" opacity=\"0.45\"/>\n\t\t\t\t\t<circle cx=\"48\" cy=\"48\" r=\"22\" fill=\"rgba(255,255,255,0.18)\"/>\n\t\t\t\t\t<circle cx=\"13.69\" cy=\"58.91\" r=\"9\" fill=\"#4ed5e8\"/></g>\n\t\t<text x=\"48\" y=\"50\" text-anchor=\"middle\" dominant-baseline=\"central\"\n\t\t\tfont-family=\"-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif\"\n\t\t\tfont-size=\"56\" font-weight=\"700\"\n\t\t\tfill=\"#ffffff\" letter-spacing=\"-1\">F</text>\n\t</svg>",
+	"IconType": "svg",
+	"Favicon": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 96 96\" width=\"96\" height=\"96\">\n\t\t<defs>\n\t\t\t<clipPath id=\"fav-fable-light\">\n\t\t\t\t<path d=\"M 24 2\n\t\tH 72\n\t\tQ 94 2 94 24\n\t\tV 72\n\t\tQ 94 94 72 94\n\t\tH 24\n\t\tQ 2 94 2 72\n\t\tV 24\n\t\tQ 2 2 24 2 Z\"/>\n\t\t\t</clipPath>\n\t\t</defs>\n\t\t<path d=\"M 24 2\n\t\tH 72\n\t\tQ 94 2 94 24\n\t\tV 72\n\t\tQ 94 94 72 94\n\t\tH 24\n\t\tQ 2 94 2 72\n\t\tV 24\n\t\tQ 2 2 24 2 Z\" fill=\"#af2aef\"/>\n\t\t<g clip-path=\"url(#fav-fable-light)\"><circle cx=\"48\" cy=\"48\" r=\"28\" fill=\"rgba(255,255,255,0.22)\"/></g>\n\t\t<text x=\"48\" y=\"50\" text-anchor=\"middle\" dominant-baseline=\"central\"\n\t\t\tfont-family=\"-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif\"\n\t\t\tfont-size=\"60\" font-weight=\"800\"\n\t\t\tfill=\"#ffffff\" letter-spacing=\"-1\">F</text>\n\t</svg>",
+	"FaviconDark": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 96 96\" width=\"96\" height=\"96\">\n\t\t<defs>\n\t\t\t<clipPath id=\"fav-fable-dark\">\n\t\t\t\t<path d=\"M 24 2\n\t\tH 72\n\t\tQ 94 2 94 24\n\t\tV 72\n\t\tQ 94 94 72 94\n\t\tH 24\n\t\tQ 2 94 2 72\n\t\tV 24\n\t\tQ 2 2 24 2 Z\"/>\n\t\t\t</clipPath>\n\t\t</defs>\n\t\t<path d=\"M 24 2\n\t\tH 72\n\t\tQ 94 2 94 24\n\t\tV 72\n\t\tQ 94 94 72 94\n\t\tH 24\n\t\tQ 2 94 2 72\n\t\tV 24\n\t\tQ 2 2 24 2 Z\" fill=\"#ce84f2\"/>\n\t\t<g clip-path=\"url(#fav-fable-dark)\"><circle cx=\"48\" cy=\"48\" r=\"28\" fill=\"rgba(255,255,255,0.22)\"/></g>\n\t\t<text x=\"48\" y=\"50\" text-anchor=\"middle\" dominant-baseline=\"central\"\n\t\t\tfont-family=\"-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif\"\n\t\t\tfont-size=\"60\" font-weight=\"800\"\n\t\t\tfill=\"#101418\" letter-spacing=\"-1\">F</text>\n\t</svg>",
+	"Colors": {
+		"Primary": "#af2aef",
+		"Secondary": "#4ed5e8",
+		"PrimaryLight": "#af2aef",
+		"PrimaryDark": "#ce84f2",
+		"SecondaryLight": "#4ed5e8",
+		"SecondaryDark": "#a2e6ef"
+	}
+}

package/docs/_playground.json

@@ -0,0 +1,10 @@
+{
+	"Imports":
+	[
+		{ "Name": "fable",                    "Source": "bundled" },
+		{ "Name": "fable-uuid",               "Source": "bundled" },
+		{ "Name": "fable-settings",           "Source": "bundled" },
+		{ "Name": "fable-log",                "Source": "bundled" },
+		{ "Name": "fable-serviceproviderbase","Source": "bundled" }
+	]
+}

package/docs/_sidebar.md

@@ -40,3 +40,5 @@
   - [Environment Data](services/environment-data.md)
   - [Progress Time](services/progress-time.md)
   - [Progress Tracker Set](services/progress-tracker-set.md)
+
+- [Code Playground](playground.md)

package/docs/_version.json

@@ -1,7 +1,7 @@
 {
 	"Name": "fable",
-	"Version": "3.1.68",
+	"Version": "3.1.72",
 	"Description": "A service dependency injection, configuration and logging library.",
-	"GeneratedAt": "2026-04-10T17:19:38.218Z",
-	"GitCommit": "70452b7"
+	"GeneratedAt": "2026-05-15T13:50:08.507Z",
+	"GitCommit": "3564579"
 }

package/docs/architecture.md

@@ -24,15 +24,24 @@ Fable (Core ServiceManager)
 Services depend on Fable rather than creating their own dependencies. Each service receives a reference to the Fable instance during construction, providing access to all other services and shared configuration.
 
 ```javascript
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
 class MyService extends libFableServiceBase {
     constructor(pFable, pOptions, pServiceHash) {
         super(pFable, pOptions, pServiceHash);
+        this.serviceType = 'MyService';
 
         // Access other services through fable
-        this.log = this.fable.log;
+        this.log      = this.fable.log;
         this.settings = this.fable.settings;
     }
 }
+
+fable.addAndInstantiateServiceType('MyService', MyService);
+console.log('MyService wired up; log + settings accessible:',
+    typeof fable.MyService.log, typeof fable.MyService.settings);
 ```
 
 ### Lazy Instantiation
@@ -40,11 +49,25 @@ class MyService extends libFableServiceBase {
 Services can be registered without being instantiated, allowing for on-demand creation when first needed:
 
 ```javascript
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+class ExpensiveServiceClass extends libFableServiceBase {
+    constructor(pFable, pOptions, pServiceHash) {
+        super(pFable, pOptions, pServiceHash);
+        this.serviceType = 'ExpensiveService';
+        console.log('ExpensiveServiceClass instantiated — work happens here.');
+    }
+}
+
 // Register without instantiating
 fable.addServiceType('ExpensiveService', ExpensiveServiceClass);
+console.log('Registered; no instance yet.');
 
 // Later, when needed
 const service = fable.instantiateServiceProvider('ExpensiveService');
+console.log('Instantiated:', service.serviceType);
 ```
 
 ### Service Containers
@@ -52,13 +75,16 @@ const service = fable.instantiateServiceProvider('ExpensiveService');
 Each service type maintains a map of instances, supporting multiple named instances of the same service type:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
 // Create multiple instances of the same service type
 const clientA = fable.instantiateServiceProvider('RestClient', {}, 'api-client');
 const clientB = fable.instantiateServiceProvider('RestClient', {}, 'auth-client');
 
 // Access via services map
-fable.servicesMap.RestClient['api-client'];
-fable.servicesMap.RestClient['auth-client'];
+console.log('api-client:',  typeof fable.servicesMap.RestClient['api-client']);
+console.log('auth-client:', typeof fable.servicesMap.RestClient['auth-client']);
 ```
 
 ### Default Service Pattern
@@ -66,12 +92,15 @@ fable.servicesMap.RestClient['auth-client'];
 The first instance of each service type becomes the default accessor on the Fable object:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
 // First instantiation becomes default
 fable.instantiateServiceProvider('RestClient', {}, 'primary');
 
 // Now accessible directly
-fable.RestClient;           // The 'primary' instance
-fable.services.RestClient;  // Same as above
+console.log('fable.RestClient:',           typeof fable.RestClient);           // The 'primary' instance
+console.log('fable.services.RestClient:',  typeof fable.services.RestClient);  // Same as above
 ```
 
 ## Initialization Phases
@@ -83,11 +112,21 @@ Fable initializes in distinct phases to ensure proper dependency ordering:
 The lowest level state and service infrastructure is established:
 
 ```javascript
-this.serviceType = 'ServiceManager';
-this.serviceTypes = [];      // Array of registered service types
-this.servicesMap = {};       // Map of instantiated services by type and hash
-this.services = {};          // Map of default service instances
-this.serviceClasses = {};    // Map of service class constructors
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+// Inside Fable's constructor, Phase 0 sets up its own service-manager state:
+//   this.serviceType    = 'ServiceManager';
+//   this.serviceTypes   = [];      // Array of registered service types
+//   this.servicesMap    = {};      // Map of instantiated services by type and hash
+//   this.services       = {};      // Map of default service instances
+//   this.serviceClasses = {};      // Map of service class constructors
+//
+// You can observe these on a constructed instance:
+console.log('serviceType:',         fable.serviceType);
+console.log('serviceTypes count:',  fable.serviceTypes.length);
+console.log('servicesMap keys:',    Object.keys(fable.servicesMap).slice(0, 5), '...');
+console.log('services keys:',       Object.keys(fable.services).slice(0, 5),    '...');
 ```
 
 ### Phase 1: Core Utility Services
@@ -95,10 +134,19 @@ this.serviceClasses = {};    // Map of service class constructors
 Fundamental services required for Fable to operate:
 
 ```javascript
-this.SettingsManager = new libFableSettings(pSettings);
-this.UUID = new libFableUUID(this.SettingsManager.settings);
-this.Logging = new libFableLog(this.SettingsManager.settings);
-this.Logging.initialize();
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+// Inside Fable's constructor, Phase 1 wires up the core utility services:
+//   this.SettingsManager = new libFableSettings(pSettings);
+//   this.UUID            = new libFableUUID(this.SettingsManager.settings);
+//   this.Logging         = new libFableLog(this.SettingsManager.settings);
+//   this.Logging.initialize();
+//
+// On the constructed instance these are all live:
+console.log('SettingsManager:', typeof fable.SettingsManager);
+console.log('UUID:',            typeof fable.UUID);
+console.log('Logging:',         typeof fable.Logging);
 ```
 
 ### Phase 1.5: Self-Registration
@@ -106,8 +154,15 @@ this.Logging.initialize();
 Fable registers itself as a service, enabling consistent service access patterns:
 
 ```javascript
-this.ServiceManager = this;
-this.connectFable(this);
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+// Inside Fable's constructor, Phase 1.5 self-registers:
+//   this.ServiceManager = this;
+//   this.connectFable(this);
+//
+// On the constructed instance, fable.ServiceManager === fable:
+console.log('fable.ServiceManager === fable:', fable.ServiceManager === fable);
 ```
 
 ### Phase 2: Default Built-in Services
@@ -115,16 +170,24 @@ this.connectFable(this);
 All default services are registered and optionally instantiated:
 
 ```javascript
-// Auto-instantiated (available immediately)
-this.addAndInstantiateServiceType('EnvironmentData', ...);
-this.addAndInstantiateServiceType('Dates', ...);
-this.addAndInstantiateServiceType('DataFormat', ...);
-// ... etc
-
-// On-demand (registered but not instantiated)
-this.addServiceType('Template', ...);
-this.addServiceType('RestClient', ...);
-// ... etc
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+// Inside Fable's constructor, Phase 2 registers all built-in services:
+//   // Auto-instantiated (available immediately)
+//   this.addAndInstantiateServiceType('EnvironmentData', ...);
+//   this.addAndInstantiateServiceType('Dates', ...);
+//   this.addAndInstantiateServiceType('DataFormat', ...);
+//   ...
+//   // On-demand (registered but not instantiated)
+//   this.addServiceType('Template', ...);
+//   this.addServiceType('RestClient', ...);
+//   ...
+//
+// On the constructed instance, you can see both:
+const autoInstantiated = Object.keys(fable.services).filter(k => fable[k]);
+console.log('Auto-instantiated services:', autoInstantiated.join(', '));
+console.log('Registered service types:',   fable.serviceTypes.join(', '));
 ```
 
 ## Service Base Class
@@ -132,6 +195,10 @@ this.addServiceType('RestClient', ...);
 All Fable services extend `CoreServiceProviderBase` from `fable-serviceproviderbase`:
 
 ```javascript
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
 class MyService extends libFableServiceBase {
     constructor(pFable, pOptions, pServiceHash) {
         super(pFable, pOptions, pServiceHash);
@@ -145,6 +212,14 @@ class MyService extends libFableServiceBase {
     // - this.options (passed options)
     // - this.Hash (unique service instance identifier)
 }
+
+fable.addAndInstantiateServiceType('MyService', MyService);
+const svc = fable.MyService;
+console.log('serviceType:',  svc.serviceType);
+console.log('fable ref:',    typeof svc.fable);
+console.log('log:',          typeof svc.log);
+console.log('options:',      typeof svc.options);
+console.log('Hash:',         svc.Hash);
 ```
 
 ## Service Registration Methods
@@ -154,7 +229,16 @@ class MyService extends libFableServiceBase {
 Registers a service class without instantiation:
 
 ```javascript
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+class MyServiceClass extends libFableServiceBase {
+    constructor(pFable, pOptions, pServiceHash) { super(pFable, pOptions, pServiceHash); this.serviceType = 'MyService'; }
+}
+
 fable.addServiceType('MyService', MyServiceClass);
+console.log('Registered:', fable.serviceTypes.includes('MyService'));
 ```
 
 ### `addAndInstantiateServiceType(pServiceType, pServiceClass)`
@@ -162,8 +246,17 @@ fable.addServiceType('MyService', MyServiceClass);
 Registers and immediately creates a default instance:
 
 ```javascript
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+class MyServiceClass extends libFableServiceBase {
+    constructor(pFable, pOptions, pServiceHash) { super(pFable, pOptions, pServiceHash); this.serviceType = 'MyService'; }
+}
+
 fable.addAndInstantiateServiceType('MyService', MyServiceClass);
 // Creates instance with hash 'MyService-Default'
+console.log('Default instance Hash:', fable.MyService.Hash);
 ```
 
 ### `instantiateServiceProvider(pServiceType, pOptions, pCustomServiceHash)`
@@ -171,10 +264,22 @@ fable.addAndInstantiateServiceType('MyService', MyServiceClass);
 Creates a new instance of a registered service:
 
 ```javascript
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+class MyServiceClass extends libFableServiceBase {
+    constructor(pFable, pOptions, pServiceHash) { super(pFable, pOptions, pServiceHash); this.serviceType = 'MyService'; }
+}
+
+fable.addServiceType('MyService', MyServiceClass);
+
 const service = fable.instantiateServiceProvider('MyService',
     { option: 'value' },
     'my-custom-hash'
 );
+console.log('Service Hash:', service.Hash);
+console.log('Service options:', service.options);
 ```
 
 ### `instantiateServiceProviderFromPrototype(pServiceType, pOptions, pCustomServiceHash, pServicePrototype)`
@@ -182,14 +287,28 @@ const service = fable.instantiateServiceProvider('MyService',
 Creates an instance using a custom class that may differ from the registered class:
 
 ```javascript
-class CustomizedService extends MyServiceClass { /* ... */ }
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+class MyServiceClass extends libFableServiceBase {
+    constructor(pFable, pOptions, pServiceHash) { super(pFable, pOptions, pServiceHash); this.serviceType = 'MyService'; }
+}
+fable.addServiceType('MyService', MyServiceClass);
+
+class CustomizedService extends MyServiceClass {
+    constructor(pFable, pOptions, pServiceHash) { super(pFable, pOptions, pServiceHash); this.flavor = 'custom'; }
+}
 
+const options = { mode: 'demo' };
 const service = fable.instantiateServiceProviderFromPrototype(
     'MyService',
     options,
     'customized',
     CustomizedService
 );
+console.log('Custom flavor:', service.flavor);
+console.log('Hash:',          service.Hash);
 ```
 
 ## Service Access Patterns
@@ -199,9 +318,12 @@ const service = fable.instantiateServiceProviderFromPrototype(
 Auto-instantiated services are available directly on the Fable instance:
 
 ```javascript
-fable.Dates.dayJS().format('YYYY-MM-DD');
-fable.Math.addPrecise('1.5', '2.5');
-fable.DataFormat.formatterDollars(1234.56);
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+console.log(fable.Dates.dayJS().format('YYYY-MM-DD'));
+console.log(fable.Math.addPrecise('1.5', '2.5'));
+console.log(fable.DataFormat.formatterDollars(1234.56));
 ```
 
 ### Services Map Access
@@ -209,8 +331,11 @@ fable.DataFormat.formatterDollars(1234.56);
 All instantiated services are accessible through the services map:
 
 ```javascript
-fable.services.Dates;
-fable.servicesMap.Dates['Dates-Default'];
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+console.log('fable.services.Dates:',                 typeof fable.services.Dates);
+console.log("fable.servicesMap.Dates['Dates-Default']:", typeof fable.servicesMap.Dates['Dates-Default']);
 ```
 
 ### Factory Methods
@@ -218,11 +343,17 @@ fable.servicesMap.Dates['Dates-Default'];
 Some services provide convenient factory methods:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
 // Create a new Anticipate instance without registration
 const anticipate = fable.newAnticipate();
+console.log('anticipate:', typeof anticipate);
 
 // Create a new Manifest instance without registration
+const definition = { Scope: 'Demo', Descriptors: { Foo: { Hash: 'foo', Type: 'String' } } };
 const manifest = fable.newManyfest(definition);
+console.log('manifest scope:', manifest.scope);
 ```
 
 ## Configuration Flow
@@ -240,8 +371,16 @@ User Config -> SettingsManager -> Fable.settings -> All Services
 Services access configuration through:
 
 ```javascript
-this.fable.settings.SomeSetting;
-this.fable.SettingsManager.settings;
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', SomeSetting: 'demo-value' });
+
+// Inside a service, you access config via:
+//   this.fable.settings.SomeSetting
+//   this.fable.SettingsManager.settings
+//
+// At the top level, drop "this.":
+console.log('settings.SomeSetting:',          fable.settings.SomeSetting);
+console.log('SettingsManager.settings type:', typeof fable.SettingsManager.settings);
 ```
 
 ## Logging Architecture
@@ -260,13 +399,22 @@ Log levels: `trace`, `debug`, `info`, `warn`, `error`, `fatal`
 Custom log providers can be created by extending `LogProviderBase`:
 
 ```javascript
-const LogProviderBase = require('fable').LogProviderBase;
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
+const LogProviderBase = require('fable-log').LogProviderBase;
 
 class CustomLogProvider extends LogProviderBase {
     write(pLogEntry) {
         // Custom logging implementation
+        console.log('CustomLogProvider received:', pLogEntry.msg);
     }
 }
+
+const provider = new CustomLogProvider(fable.Logging, { level: 'trace' });
+provider.initialize();
+fable.Logging.addLogger(provider);
+fable.log.info('Hello from custom provider demo');
 ```
 
 ## Browser Compatibility
@@ -274,15 +422,16 @@ class CustomLogProvider extends LogProviderBase {
 Fable supports browser environments through service remapping:
 
 ```javascript
-// package.json browser field
-{
+// Shape of the browser remap declared in package.json:
+const packageJSONBrowserField = {
     "browser": {
         "./source/service/Fable-Service-EnvironmentData.js":
             "./source/service/Fable-Service-EnvironmentData-Web.js",
         "./source/service/Fable-Service-FilePersistence.js":
             "./source/service/Fable-Service-FilePersistence-Web.js"
     }
-}
+};
+console.log('Browser remap entries:', Object.keys(packageJSONBrowserField.browser).length);
 ```
 
 The `dist/` folder contains browserified bundles for direct browser use.
@@ -292,7 +441,9 @@ The `dist/` folder contains browserified bundles for direct browser use.
 ### Creating Custom Services
 
 ```javascript
+const libFable = require('fable');
 const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
 
 class MyCustomService extends libFableServiceBase {
     constructor(pFable, pOptions, pServiceHash) {
@@ -310,7 +461,7 @@ class MyCustomService extends libFableServiceBase {
 fable.addAndInstantiateServiceType('MyCustomService', MyCustomService);
 
 // Use it
-fable.MyCustomService.myMethod();
+console.log('myMethod() returns:', fable.MyCustomService.myMethod());
 ```
 
 ### Service Initialization Hook
@@ -318,9 +469,20 @@ fable.MyCustomService.myMethod();
 For advanced scenarios, Fable supports an extra initialization callback:
 
 ```javascript
+const libFable = require('fable');
+const libFableServiceBase = require('fable-serviceproviderbase');
+const fable = new libFable({ Product: 'ArchitectureDemo', ProductVersion: '1.0.0' });
+
 fable.extraServiceInitialization = (pService) => {
     // Perform additional setup on every service
     pService.customProperty = 'value';
     return pService;
 };
+
+// Subsequent service instantiations now pass through the hook:
+class DemoService extends libFableServiceBase {
+    constructor(pFable, pOptions, pServiceHash) { super(pFable, pOptions, pServiceHash); this.serviceType = 'DemoService'; }
+}
+fable.addAndInstantiateServiceType('DemoService', DemoService);
+console.log('DemoService.customProperty:', fable.DemoService.customProperty);
 ```

package/docs/index.html

@@ -4,12 +4,10 @@
 		<meta charset="utf-8">
 		<meta http-equiv="X-UA-Compatible" content="IE=edge">
 		<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-		<meta name="description" content="Fable &lt;small&gt;3&lt;/small&gt; v3.1.68 Documentation — A service dependency injection, configuration and logging library.">
+		<meta name="description" content="Fable &lt;small&gt;3&lt;/small&gt; v3.1.72 Documentation — A service dependency injection, configuration and logging library.">
 
-		<title>Fable &lt;small&gt;3&lt;/small&gt; v3.1.68 Documentation</title>
+		<title>Fable &lt;small&gt;3&lt;/small&gt; v3.1.72 Documentation</title>
 
-		<!-- Application Stylesheet -->
-		<link href="css/docuserve.css" rel="stylesheet">
 		<!-- KaTeX stylesheet for LaTeX equation rendering -->
 		<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.21/dist/katex.min.css">
 		<!-- PICT Dynamic View CSS Container -->
@@ -28,12 +26,13 @@
 		<!-- The root container for the Pict application -->
 		<div id="Docuserve-Application-Container"></div>
 
-		<!-- Mermaid diagram rendering -->
+		<!-- Mermaid diagram rendering.  pict-section-content (v0.1.8+) drives
+		     initialization with theme: 'base' + themeVariables sourced
+		     from --theme-color-* so diagrams follow the active theme. -->
 		<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
-		<script>mermaid.initialize({ startOnLoad: false, theme: 'default' });</script>
 		<!-- KaTeX for LaTeX equation rendering -->
 		<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.21/dist/katex.min.js"></script>
 		<!-- Load the Docuserve PICT Application Bundle from jsDelivr CDN -->
-		<script src="https://cdn.jsdelivr.net/npm/pict-docuserve@0/dist/pict-docuserve.min.js" type="text/javascript"></script>
+		<script src="https://cdn.jsdelivr.net/npm/pict-docuserve@1/dist/pict-docuserve.min.js" type="text/javascript"></script>
 	</body>
 </html>