fable 3.1.71 → 3.1.73

package/docs/services/object-cache.md

@@ -5,12 +5,17 @@ The ObjectCache service (powered by [cachetrax](https://github.com/stevenvelozo/
 ## Access
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+
 // On-demand service - instantiate when needed
 const cache = fable.instantiateServiceProvider('ObjectCache');
+console.log('cache:', typeof cache);
 
 // Create named caches for different purposes
-const userCache = fable.instantiateServiceProvider('ObjectCache', {}, 'user-cache');
+const userCache    = fable.instantiateServiceProvider('ObjectCache', {}, 'user-cache');
 const sessionCache = fable.instantiateServiceProvider('ObjectCache', {}, 'session-cache');
+console.log('userCache and sessionCache instantiated:', typeof userCache, typeof sessionCache);
 ```
 
 ## Basic Operations
@@ -18,35 +23,60 @@ const sessionCache = fable.instantiateServiceProvider('ObjectCache', {}, 'sessio
 ### Put (Add or Update)
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
 cache.put('some-data', 'my-key');
 // Stores 'some-data' with hash 'my-key'
 // If 'my-key' already exists, updates the stored datum
 
 cache.put({ name: 'John', age: 30 }, 'user-123');
 // Stores an object with hash 'user-123'
+
+console.log('my-key:',   cache.read('my-key'));
+console.log('user-123:', cache.read('user-123'));
 ```
 
 ### Read
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.put('some-data', 'my-key');
 const data = cache.read('my-key');
+console.log('data:', data);
 // Returns the stored datum, or false if not found
 ```
 
 ### Expire (Remove)
 
 ```javascript
-cache.expire('my-key');
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.put('some-data', 'my-key');
+console.log(cache.expire('my-key'));
 // Removes the entry from the cache and returns the removed node
 // Returns false if the key doesn't exist
+console.log('After expire — read:', cache.read('my-key'));
 ```
 
 ### Touch (Refresh)
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.put('some-data', 'my-key');
 cache.touch('my-key');
 // Moves the entry to the tail of the list and resets its timestamp
 // Useful for keeping frequently accessed items fresh
+console.log('after touch — my-key still present:', cache.read('my-key'));
 ```
 
 ## Size-Based Expiration
@@ -56,15 +86,19 @@ cache.touch('my-key');
 Set `maxLength` to automatically evict the oldest entry when the cache exceeds the limit:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
 cache.maxLength = 2;
 
 cache.put('A', 'ABC');
 cache.put('D', 'DEF');
-// Cache: [ABC, DEF] (length 2)
+console.log('After two puts:', Object.keys(cache.RecordMap));
 
 cache.put('G', 'GHI');
 // ABC is automatically evicted
-// Cache: [DEF, GHI] (length 2)
+console.log('After third put (evicts oldest):', Object.keys(cache.RecordMap));
 ```
 
 Setting `maxLength` to `0` (the default) disables automatic size-based eviction on insert. To enforce a new smaller `maxLength` on existing entries, call `prune()`.
@@ -76,7 +110,12 @@ Setting `maxLength` to `0` (the default) disables automatic size-based eviction
 Set `maxAge` (in milliseconds) to expire entries older than the specified age when `prune()` is called:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
 cache.maxAge = 60000; // 1 minute
+console.log('cache.maxAge:', cache.maxAge);
 ```
 
 ## Pruning
@@ -86,9 +125,15 @@ cache.maxAge = 60000; // 1 minute
 Prune the cache based on both `maxAge` and `maxLength` rules. Expired entries are removed first, then size limits are enforced:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
 cache.maxLength = 2;
 
 // After adding many entries...
+for (let i = 0; i < 5; i++) cache.put('value-' + i, 'key-' + i);
+
 cache.prune((removedRecords) => {
     console.log(`Pruned ${removedRecords.length} entries`);
     // Cache is now within maxLength
@@ -100,6 +145,11 @@ cache.prune((removedRecords) => {
 Prune only entries older than `maxAge`:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.put('fresh', 'recent-key');
 cache.maxAge = 30000; // 30 seconds
 cache.pruneBasedOnExpiration((removed) => {
     console.log(`Expired ${removed.length} old entries`);
@@ -111,6 +161,12 @@ cache.pruneBasedOnExpiration((removed) => {
 Prune only based on `maxLength`, popping entries from the head (oldest) of the list:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.maxLength = 2;
+for (let i = 0; i < 5; i++) cache.put('v-' + i, 'k-' + i);
 cache.pruneBasedOnLength((removed) => {
     console.log(`Evicted ${removed.length} entries for length`);
 });
@@ -121,6 +177,14 @@ cache.pruneBasedOnLength((removed) => {
 Prune entries using a custom function. The function receives `(datum, hash, node)` and should return `true` to expire the entry:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.put('temp-A', 'key-1');
+cache.put('keep-me', 'key-2');
+cache.put('temp-B', 'key-3');
+
 cache.pruneCustom(
     (removed) => { console.log(`Custom pruned ${removed.length}`); },
     (datum, hash, node) => {
@@ -128,6 +192,7 @@ cache.pruneCustom(
         return typeof datum === 'string' && datum.startsWith('temp');
     }
 );
+console.log('Remaining keys:', Object.keys(cache.RecordMap));
 ```
 
 ## Low-Level Access
@@ -137,10 +202,15 @@ cache.pruneCustom(
 Get the full linked list node (including metadata) for a hash:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.put('some-data', 'my-key');
 const node = cache.getNode('my-key');
-// node.Datum -- the stored data
-// node.Hash -- the hash key
-// node.Metadata.Created -- timestamp (ms) when the entry was created
+console.log('node.Datum:',            node.Datum);
+console.log('node.Hash:',             node.Hash);
+console.log('node.Metadata.Created:', node.Metadata.Created);
 ```
 
 ### RecordMap
@@ -148,8 +218,14 @@ const node = cache.getNode('my-key');
 Access the record map directly (a plain object mapping hashes to data):
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.put('some-data', 'my-key');
+cache.put({ name: 'John', age: 30 }, 'user-123');
 const allRecords = cache.RecordMap;
-// { 'my-key': 'some-data', 'user-123': { name: 'John', age: 30 } }
+console.log('allRecords:', allRecords);
 ```
 
 ### Internal List
@@ -157,9 +233,16 @@ const allRecords = cache.RecordMap;
 The cache is backed by a linked list accessible via `cache._List`:
 
 ```javascript
-cache._List.length  // Number of entries in the cache
-cache._List.head    // First (oldest) node
-cache._List.tail    // Last (newest) node
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ObjectCacheDemo', ProductVersion: '1.0.0' });
+const cache = fable.instantiateServiceProvider('ObjectCache');
+
+cache.put('A', 'a-key');
+cache.put('B', 'b-key');
+
+console.log('length:',     cache._List.length);  // Number of entries in the cache
+console.log('head.Datum:', cache._List.head ? cache._List.head.Datum : null);
+console.log('tail.Datum:', cache._List.tail ? cache._List.tail.Datum : null);
 ```
 
 ## Notes

package/docs/services/operation.md

@@ -5,8 +5,12 @@ The Operation service provides phased step execution with built-in progress trac
 ## Access
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+
 // On-demand service - instantiate when needed
 const operation = fable.instantiateServiceProvider('Operation', { Name: 'My Operation' }, 'MY-OP-1');
+console.log('operation:', typeof operation, 'name:', operation.state.Metadata.Name);
 ```
 
 ## Basic Usage
@@ -14,9 +18,13 @@ const operation = fable.instantiateServiceProvider('Operation', { Name: 'My Oper
 ### Create an Operation
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+
 const operation = fable.instantiateServiceProvider('Operation', {
     Name: 'Data Import'
 }, 'IMPORT-123');
+console.log('Operation created:', operation.state.Metadata.Name);
 ```
 
 ### Add Steps
@@ -24,6 +32,10 @@ const operation = fable.instantiateServiceProvider('Operation', {
 Use `addStep()` to register sequential steps. Each step function receives a completion callback and runs with a bound context:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+const operation = fable.instantiateServiceProvider('Operation', { Name: 'Data Import' }, 'IMPORT-123');
+
 operation.addStep(
     function (fStepComplete) {
         this.log.info('Validating input...');
@@ -47,6 +59,8 @@ operation.addStep(
     'Process all records',
     'PROCESS-STEP'
 );
+
+console.log('Registered steps:', operation.state.Status.StepCount);
 ```
 
 ### Execute the Operation
@@ -54,6 +68,15 @@ operation.addStep(
 Steps execute sequentially in the order they were added:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+const operation = fable.instantiateServiceProvider('Operation', { Name: 'Demo' }, 'DEMO-1');
+
+operation.addStep(function (fStepComplete) {
+    this.log.info('Step 1 running');
+    fStepComplete();
+}, {}, 'Step1', 'first step', 'S1');
+
 operation.execute((pError) => {
     if (pError) {
         fable.log.error('Operation failed', { error: pError.message });
@@ -83,6 +106,10 @@ Inside a step function, `this` is bound to a context object with these propertie
 ### Set Total Operations for a Step
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+const operation = fable.instantiateServiceProvider('Operation', { Name: 'Demo' }, 'TOTALS-1');
+
 operation.addStep(
     function (fStepComplete) {
         // ... step work ...
@@ -93,11 +120,20 @@ operation.addStep(
 
 // Set expected total operations for the step
 operation.setStepTotalOperations('PROCESS-STEP', 100);
+console.log('Step PROCESS-STEP total ops registered.');
 ```
 
 ### Increment Progress Within a Step
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+
+const items = ['a', 'b', 'c'];
+function processItem(item) { console.log('processed:', item); }
+
+const operation = fable.instantiateServiceProvider('Operation', { Name: 'Item Processor' }, 'ITEMS-1');
+
 operation.addStep(
     function (fStepComplete) {
         this.ProgressTracker.setProgressTrackerTotalOperations(items.length);
@@ -117,6 +153,8 @@ operation.addStep(
     },
     {}, 'Process Items', 'Process each item with tracking', 'ITEMS-STEP'
 );
+
+operation.execute((pError) => console.log('Done — pError:', pError));
 ```
 
 ## Operation State and Logging
@@ -124,12 +162,16 @@ operation.addStep(
 The operation maintains a structured state object:
 
 ```javascript
-operation.state.Metadata.UUID    // Unique identifier
-operation.state.Metadata.Name    // Operation name
-operation.state.Status.StepCount // Number of registered steps
-operation.state.Steps            // Array of step state entries
-operation.state.Log              // Array of log strings
-operation.state.Errors           // Array of error strings
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+const operation = fable.instantiateServiceProvider('Operation', { Name: 'State Demo' }, 'STATE-1');
+
+console.log('Metadata.UUID:',    operation.state.Metadata.UUID);    // Unique identifier
+console.log('Metadata.Name:',    operation.state.Metadata.Name);    // Operation name
+console.log('Status.StepCount:', operation.state.Status.StepCount); // Number of registered steps
+console.log('Steps:',            operation.state.Steps);            // Array of step state entries
+console.log('Log:',              operation.state.Log);              // Array of log strings
+console.log('Errors:',           operation.state.Errors);           // Array of error strings
 ```
 
 ### Built-in Log Methods
@@ -137,19 +179,29 @@ operation.state.Errors           // Array of error strings
 The operation provides logging methods that write to both fable.log and the operation's internal log:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+const operation = fable.instantiateServiceProvider('Operation', { Name: 'Log Demo' }, 'LOG-1');
+
 operation.log.trace('Trace message');
 operation.log.debug('Debug message');
 operation.log.info('Info message');
 operation.log.warn('Warning message');
 operation.log.error('Error message');    // Also writes to state.Errors
 operation.log.fatal('Fatal message');    // Also writes to state.Errors
+console.log('state.Errors count:', operation.state.Errors.length);
 ```
 
 ### Logging with Data
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+const operation = fable.instantiateServiceProvider('Operation', { Name: 'Log With Data' }, 'LOGDATA-1');
+
 operation.log.debug('Processing', { TestData: 'Ignition Complete' });
 // Appends JSON stringified data to the log
+console.log('Last log entry:', operation.state.Log[operation.state.Log.length - 1]);
 ```
 
 ## Use Cases
@@ -157,6 +209,13 @@ operation.log.debug('Processing', { TestData: 'Ignition Complete' });
 ### Multi-Step Async Workflow
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'OperationDemo', ProductVersion: '1.0.0' });
+
+// Stubs for the playground demo
+function importRecord(rec, cb) { console.log('imported:', rec); cb(); }
+function finalizeImport(cb)     { console.log('finalized'); cb(); }
+
 function createImportOperation(fable, records) {
     const operation = fable.instantiateServiceProvider('Operation', {
         Name: 'Record Import'
@@ -195,6 +254,9 @@ function createImportOperation(fable, records) {
 
     return operation;
 }
+
+const op = createImportOperation(fable, [{ id: 1 }, { id: 2 }, { id: 3 }]);
+op.execute((pError) => console.log('Import done — pError:', pError));
 ```
 
 ## Notes

package/docs/services/progress-time.md

@@ -5,8 +5,11 @@ The ProgressTime service provides named timestamp creation and delta measurement
 ## Access
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
 // Auto-instantiated, available directly
-fable.ProgressTime
+console.log('fable.ProgressTime:', typeof fable.ProgressTime);
 ```
 
 ## Basic Timing
@@ -14,11 +17,16 @@ fable.ProgressTime
 ### Create a Timestamp
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
 // Create a 'Default' timestamp (no hash specified)
 fable.ProgressTime.createTimeStamp();
 
 // Create a named timestamp
 fable.ProgressTime.createTimeStamp('MyOperation');
+
+console.log('Timestamps:', Object.keys(fable.ProgressTime.timeStamps));
 ```
 
 ### Get Elapsed Time (Delta)
@@ -26,18 +34,23 @@ fable.ProgressTime.createTimeStamp('MyOperation');
 Measure milliseconds elapsed since a timestamp was created:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
 fable.ProgressTime.createTimeStamp();
 
 // ... do some work ...
+await new Promise(r => setTimeout(r, 10));
 
 const elapsed = fable.ProgressTime.getTimeStampDelta();
-// Returns milliseconds since 'Default' timestamp was created
+console.log('elapsed since Default:', elapsed, 'ms');
 
 // With a named timestamp
 fable.ProgressTime.createTimeStamp('DatabaseQuery');
 // ... query ...
+await new Promise(r => setTimeout(r, 5));
 const queryTime = fable.ProgressTime.getTimeStampDelta('DatabaseQuery');
-// Returns milliseconds since 'DatabaseQuery' was created
+console.log('queryTime:', queryTime, 'ms');
 ```
 
 Returns `-1` if the timestamp doesn't exist.
@@ -45,14 +58,18 @@ Returns `-1` if the timestamp doesn't exist.
 ### Get Duration Between Two Timestamps
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
 fable.ProgressTime.createTimeStamp('Start');
 
 // ... some time passes ...
+await new Promise(r => setTimeout(r, 25));
 
 fable.ProgressTime.createTimeStamp('End');
 
 const duration = fable.ProgressTime.getDurationBetweenTimestamps('Start', 'End');
-// Returns milliseconds between the two timestamps
+console.log('Duration Start..End:', duration, 'ms');
 ```
 
 ## Timestamp Management
@@ -60,31 +77,49 @@ const duration = fable.ProgressTime.getDurationBetweenTimestamps('Start', 'End')
 ### Get Timestamp Value
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
+fable.ProgressTime.createTimeStamp('MyOperation');
 const value = fable.ProgressTime.getTimeStampValue('MyOperation');
+console.log('value:', value);
 // Returns the raw millisecond timestamp, or -1 if not found
 ```
 
 ### Remove a Timestamp
 
 ```javascript
-fable.ProgressTime.removeTimeStamp('MyOperation');
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
+fable.ProgressTime.createTimeStamp('MyOperation');
+console.log(fable.ProgressTime.removeTimeStamp('MyOperation'));
 // Returns true if removed, false if it didn't exist
 ```
 
 ### Update a Timestamp
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
+fable.ProgressTime.createTimeStamp('MyOperation');
 fable.ProgressTime.updateTimeStampValue('MyOperation');
-// Updates to current time
+console.log('After current-time update:', fable.ProgressTime.getTimeStampValue('MyOperation'));
 
 fable.ProgressTime.updateTimeStampValue('MyOperation', 1700000000000);
-// Updates to a specific millisecond value
+console.log('After explicit update:',    fable.ProgressTime.getTimeStampValue('MyOperation'));
 ```
 
 ### Access All Timestamps
 
 ```javascript
-fable.ProgressTime.timeStamps
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
+fable.ProgressTime.createTimeStamp();
+fable.ProgressTime.createTimeStamp('MyOperation');
+console.log(fable.ProgressTime.timeStamps);
 // { Default: 1700000000000, MyOperation: 1700000001000, ... }
 ```
 
@@ -93,16 +128,30 @@ fable.ProgressTime.timeStamps
 ### Get Delta Message
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
+fable.ProgressTime.createTimeStamp();
+fable.ProgressTime.createTimeStamp('DatabaseQuery');
+await new Promise(r => setTimeout(r, 10));
+
 const message = fable.ProgressTime.getTimeStampDeltaMessage();
-// Returns something like: 'Elapsed for Default:  2s 150ms'
+console.log(message);
 
 const customMessage = fable.ProgressTime.getTimeStampDeltaMessage('DatabaseQuery', 'DB query took');
-// Returns something like: 'DB query took 523ms'
+console.log(customMessage);
 ```
 
 ### Log Delta
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
+fable.ProgressTime.createTimeStamp();
+fable.ProgressTime.createTimeStamp('DatabaseQuery');
+await new Promise(r => setTimeout(r, 5));
+
 fable.ProgressTime.logTimeStampDelta();
 // Logs via fable.log.info: 'Elapsed for Default:  2s 150ms'
 
@@ -113,13 +162,16 @@ fable.ProgressTime.logTimeStampDelta('DatabaseQuery', 'DB query completed in');
 ### Format Duration
 
 ```javascript
-fable.ProgressTime.formatTimeDuration(3661150);
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
+console.log(fable.ProgressTime.formatTimeDuration(3661150));
 // Returns '1h 1m 1s 150ms'
 
-fable.ProgressTime.formatTimeDuration(523);
+console.log(fable.ProgressTime.formatTimeDuration(523));
 // Returns '523ms'
 
-fable.ProgressTime.formatTimeDuration(65000);
+console.log(fable.ProgressTime.formatTimeDuration(65000));
 // Returns '1m 5s 0ms'
 ```
 
@@ -128,15 +180,20 @@ fable.ProgressTime.formatTimeDuration(65000);
 ### Multi-Phase Operations
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
 fable.ProgressTime.createTimeStamp('Total');
 fable.ProgressTime.createTimeStamp('Phase1');
 
 // ... Phase 1 work ...
+await new Promise(r => setTimeout(r, 5));
 
 fable.ProgressTime.logTimeStampDelta('Phase1', 'Phase 1');
 fable.ProgressTime.createTimeStamp('Phase2');
 
 // ... Phase 2 work ...
+await new Promise(r => setTimeout(r, 5));
 
 fable.ProgressTime.logTimeStampDelta('Phase2', 'Phase 2');
 fable.ProgressTime.logTimeStampDelta('Total', 'Total time');
@@ -145,6 +202,9 @@ fable.ProgressTime.logTimeStampDelta('Total', 'Total time');
 ### Request Timing
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'ProgressTimeDemo', ProductVersion: '1.0.0' });
+
 function timeRequest(name) {
     fable.ProgressTime.createTimeStamp(name);
     return () => {
@@ -155,6 +215,7 @@ function timeRequest(name) {
 
 const done = timeRequest('api-call');
 // ... do request ...
+await new Promise(r => setTimeout(r, 10));
 done();
 // Logs: 'Request api-call  245ms'
 ```