fable 3.1.72 → 3.1.73

package/docs/services/progress-tracker-set.md

@@ -5,8 +5,12 @@ The ProgressTrackerSet service manages named progress trackers for tracking the
 ## Access
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+
 // On-demand service - instantiate when needed
 const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+console.log('trackerSet:', typeof trackerSet);
 ```
 
 ## Basic Usage
@@ -14,6 +18,8 @@ const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
 ### Create and Start a Tracker
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
 const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
 
 // Create a tracker with 100 total operations
@@ -21,38 +27,62 @@ trackerSet.createProgressTracker('download', 100);
 
 // Start the tracker (begins timing)
 trackerSet.startProgressTracker('download');
+console.log('Started:', trackerSet.getProgressTrackerStatusString('download'));
 ```
 
 ### Increment Progress
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.createProgressTracker('download', 100);
+trackerSet.startProgressTracker('download');
+
 // Increment by 1
 trackerSet.incrementProgressTracker('download');
 
 // Increment by a specific amount
 trackerSet.incrementProgressTracker('download', 10);
+
+console.log('Completed:', trackerSet.getProgressTrackerCompletedOperationCountString('download'));
 ```
 
 ### End the Tracker
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.createProgressTracker('download', 100);
+trackerSet.startProgressTracker('download');
+trackerSet.incrementProgressTracker('download', 100);
+
 trackerSet.endProgressTracker('download');
+console.log('End status:', trackerSet.getProgressTrackerStatusString('download'));
 ```
 
 ### Get Status
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.createProgressTracker('download', 100);
+trackerSet.startProgressTracker('download');
+trackerSet.incrementProgressTracker('download', 45);
+
 // Get a human-readable status string
 const status = trackerSet.getProgressTrackerStatusString('download');
-// e.g., "ProgressTracker download is 45.000% completed - 45 / 100 operations over 2s 150ms (median 47ms per). Estimated completion: 2s 585ms"
+console.log('status:', status);
 
 // Get just the percent complete
 const percent = trackerSet.getProgressTrackerPercentCompleteString('download');
-// e.g., "45.000%"
+console.log('percent:', percent);
 
 // Get completed count
 const count = trackerSet.getProgressTrackerCompletedOperationCountString('download');
-// e.g., "45"
+console.log('count:', count);
 
 // Log status directly
 trackerSet.logProgressTrackerStatus('download');
@@ -65,7 +95,12 @@ trackerSet.logProgressTrackerStatus('download');
 Create a new progress tracker. Default hash is `'Default'`, default total is `100`.
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+
 const tracker = trackerSet.createProgressTracker('import-records', 500);
+console.log('Tracker data:', tracker);
 ```
 
 Returns the tracker data object.
@@ -75,7 +110,12 @@ Returns the tracker data object.
 Start timing a progress tracker. Creates the tracker if it doesn't exist.
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+
 trackerSet.startProgressTracker('import-records');
+console.log('Started import-records');
 ```
 
 ### `endProgressTracker(hash)`
@@ -83,7 +123,13 @@ trackerSet.startProgressTracker('import-records');
 Mark the tracker as complete, recording the end timestamp.
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.startProgressTracker('import-records');
+
 trackerSet.endProgressTracker('import-records');
+console.log('Ended import-records');
 ```
 
 ### `incrementProgressTracker(hash, amount)`
@@ -91,8 +137,15 @@ trackerSet.endProgressTracker('import-records');
 Increment the current operation count. Defaults to incrementing by 1. Auto-starts the tracker if not started.
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.createProgressTracker('import-records', 100);
+trackerSet.startProgressTracker('import-records');
+
 trackerSet.incrementProgressTracker('import-records');
 trackerSet.incrementProgressTracker('import-records', 5);
+console.log('Completed:', trackerSet.getProgressTrackerCompletedOperationCountString('import-records'));
 ```
 
 ### `updateProgressTracker(hash, currentOperations)`
@@ -100,7 +153,14 @@ trackerSet.incrementProgressTracker('import-records', 5);
 Set the current operation count to an absolute value.
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.createProgressTracker('import-records', 500);
+trackerSet.startProgressTracker('import-records');
+
 trackerSet.updateProgressTracker('import-records', 250);
+console.log('Status:', trackerSet.getProgressTrackerStatusString('import-records'));
 ```
 
 ### `setProgressTrackerTotalOperations(hash, total)`
@@ -108,7 +168,13 @@ trackerSet.updateProgressTracker('import-records', 250);
 Change the total number of expected operations.
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.createProgressTracker('import-records', 500);
+
 trackerSet.setProgressTrackerTotalOperations('import-records', 1000);
+console.log('Total updated; data:', trackerSet.getProgressTrackerData('import-records').TotalCount);
 ```
 
 ### `getProgressTracker(hash)`
@@ -116,9 +182,16 @@ trackerSet.setProgressTrackerTotalOperations('import-records', 1000);
 Get a ProgressTracker wrapper object for a given hash. This provides convenience methods for working with the tracker:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.createProgressTracker('import-records', 100);
+trackerSet.startProgressTracker('import-records');
+
 const tracker = trackerSet.getProgressTracker('import-records');
 tracker.incrementProgressTracker(1);
 tracker.setProgressTrackerTotalOperations(500);
+console.log('Tracker after wrapper ops:', trackerSet.getProgressTrackerData('import-records'));
 ```
 
 ### `getProgressTrackerData(hash)`
@@ -126,7 +199,15 @@ tracker.setProgressTrackerTotalOperations(500);
 Get the raw tracker data object:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
+trackerSet.createProgressTracker('import-records', 100);
+trackerSet.startProgressTracker('import-records');
+trackerSet.incrementProgressTracker('import-records', 45);
+
 const data = trackerSet.getProgressTrackerData('import-records');
+console.log(data);
 // {
 //     Hash: 'import-records',
 //     StartTimeStamp: 1700000000000,
@@ -162,6 +243,12 @@ Each tracker data object contains:
 ### Batch Processing with Progress
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+
+// Stubbed processItem for the playground demo
+function processItem(item, cb) { console.log('processed:', item); cb(); }
+
 function processBatch(fable, items, fCallback) {
     const trackerSet = fable.instantiateServiceProvider('ProgressTrackerSet');
 
@@ -190,6 +277,8 @@ function processBatch(fable, items, fCallback) {
         fCallback();
     });
 }
+
+processBatch(fable, ['a', 'b', 'c', 'd'], () => console.log('Batch done.'));
 ```
 
 ### Integration with Operation Service
@@ -197,6 +286,13 @@ function processBatch(fable, items, fCallback) {
 The Operation service uses ProgressTrackerSet internally. Each step gets its own progress tracker, and the overall operation has one too. Inside a step, use `this.ProgressTracker`:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'TrackerDemo', ProductVersion: '1.0.0' });
+
+const operation = fable.instantiateServiceProvider('Operation', { Name: 'Items' }, 'ITEMS-OP');
+const items = ['a', 'b', 'c'];
+function processItem(item) { console.log('processed:', item); }
+
 operation.addStep(
     function (fStepComplete) {
         this.ProgressTracker.setProgressTrackerTotalOperations(items.length);
@@ -211,6 +307,8 @@ operation.addStep(
     },
     {}, 'Process', 'Process all items', 'PROCESS'
 );
+
+operation.execute((pError) => console.log('Op done — pError:', pError));
 ```
 
 ## Notes

package/docs/services/rest-client.md

@@ -5,12 +5,17 @@ The RestClient service provides HTTP/REST client functionality with support for
 ## Access
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'RestClientDemo', ProductVersion: '1.0.0' });
+
 // On-demand service - must be instantiated
 const restClient = fable.instantiateServiceProvider('RestClient');
+console.log('restClient:', typeof restClient);
 
 // Or create named instances for different purposes
-const apiClient = fable.instantiateServiceProvider('RestClient', {}, 'api');
+const apiClient  = fable.instantiateServiceProvider('RestClient', {}, 'api');
 const authClient = fable.instantiateServiceProvider('RestClient', { TraceLog: true }, 'auth');
+console.log('Named instances ready:', typeof apiClient, typeof authClient);
 ```
 
 ## Configuration
@@ -18,9 +23,13 @@ const authClient = fable.instantiateServiceProvider('RestClient', { TraceLog: tr
 ### Options
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'RestClientDemo', ProductVersion: '1.0.0' });
+
 const restClient = fable.instantiateServiceProvider('RestClient', {
     TraceLog: true  // Enable request/response logging
 });
+console.log('TraceLog enabled:', restClient.options.TraceLog);
 ```
 
 ### URL Prefix
@@ -28,12 +37,15 @@ const restClient = fable.instantiateServiceProvider('RestClient', {
 Set a global URL prefix in Fable settings:
 
 ```javascript
-const fable = new Fable({
+const libFable = require('fable');
+const fable = new libFable({
     RestClientURLPrefix: 'https://api.example.com'
 });
+console.log('URL prefix:', fable.settings.RestClientURLPrefix);
 
-// All requests will be prefixed
-restClient.getJSON('/users', callback);  // Requests https://api.example.com/users
+// In Node.js (network calls are skipped in the browser playground):
+// restClient.getJSON('/users', callback);  // -> Requests https://api.example.com/users
+console.info("    restClient.getJSON('/users', callback);  // -> https://api.example.com/users");
 ```
 
 ## JSON Requests
@@ -41,86 +53,73 @@ restClient.getJSON('/users', callback);  // Requests https://api.example.com/use
 ### GET JSON
 
 ```javascript
-// Simple URL
-restClient.getJSON('https://api.example.com/users', (error, response, data) => {
-    if (error) {
-        console.error('Request failed:', error);
-        return;
-    }
-    console.log('Status:', response.statusCode);
-    console.log('Data:', data);  // Parsed JSON
-});
-
-// With options
-restClient.getJSON({
-    url: 'https://api.example.com/users',
-    headers: {
-        'Authorization': 'Bearer token123'
-    }
-}, (error, response, data) => {
-    console.log(data);
-});
+// Node.js reference — real HTTP requests don't run in the browser playground (CORS).
+console.info("In Node.js:");
+console.info("    // Simple URL");
+console.info("    restClient.getJSON('https://api.example.com/users', (error, response, data) => {");
+console.info("        if (error) { console.error('Request failed:', error); return; }");
+console.info("        console.log('Status:', response.statusCode);");
+console.info("        console.log('Data:', data);  // Parsed JSON");
+console.info("    });");
+console.info("    // With options");
+console.info("    restClient.getJSON({");
+console.info("        url: 'https://api.example.com/users',");
+console.info("        headers: { Authorization: 'Bearer token123' }");
+console.info("    }, (error, response, data) => { console.log(data); });");
 ```
 
 ### POST JSON
 
 ```javascript
-restClient.postJSON({
-    url: 'https://api.example.com/users',
-    body: {
-        name: 'John Doe',
-        email: 'john@example.com'
-    }
-}, (error, response, data) => {
-    console.log('Created user:', data);
-});
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.postJSON({");
+console.info("        url: 'https://api.example.com/users',");
+console.info("        body: { name: 'John Doe', email: 'john@example.com' }");
+console.info("    }, (error, response, data) => { console.log('Created user:', data); });");
 ```
 
 ### PUT JSON
 
 ```javascript
-restClient.putJSON({
-    url: 'https://api.example.com/users/123',
-    body: {
-        name: 'John Smith'
-    }
-}, (error, response, data) => {
-    console.log('Updated user:', data);
-});
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.putJSON({");
+console.info("        url: 'https://api.example.com/users/123',");
+console.info("        body: { name: 'John Smith' }");
+console.info("    }, (error, response, data) => { console.log('Updated user:', data); });");
 ```
 
 ### PATCH JSON
 
 ```javascript
-restClient.patchJSON({
-    url: 'https://api.example.com/users/123',
-    body: {
-        email: 'john.smith@example.com'
-    }
-}, (error, response, data) => {
-    console.log('Patched user:', data);
-});
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.patchJSON({");
+console.info("        url: 'https://api.example.com/users/123',");
+console.info("        body: { email: 'john.smith@example.com' }");
+console.info("    }, (error, response, data) => { console.log('Patched user:', data); });");
 ```
 
 ### DELETE JSON
 
 ```javascript
-restClient.delJSON({
-    url: 'https://api.example.com/users/123'
-}, (error, response, data) => {
-    console.log('Deleted user');
-});
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.delJSON({");
+console.info("        url: 'https://api.example.com/users/123'");
+console.info("    }, (error, response, data) => { console.log('Deleted user'); });");
 ```
 
 ### HEAD JSON
 
 ```javascript
-restClient.headJSON({
-    url: 'https://api.example.com/users/123',
-    body: {}  // Required but not sent
-}, (error, response, data) => {
-    console.log('Headers:', response.headers);
-});
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.headJSON({");
+console.info("        url: 'https://api.example.com/users/123',");
+console.info("        body: {}  // Required but not sent");
+console.info("    }, (error, response, data) => { console.log('Headers:', response.headers); });");
 ```
 
 ## Raw Text Requests
@@ -128,9 +127,11 @@ restClient.headJSON({
 ### GET Raw Text
 
 ```javascript
-restClient.getRawText('https://example.com/page.html', (error, response, text) => {
-    console.log('HTML:', text);
-});
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.getRawText('https://example.com/page.html', (error, response, text) => {");
+console.info("        console.log('HTML:', text);");
+console.info("    });");
 ```
 
 ## Chunked Requests
@@ -140,24 +141,26 @@ For streaming or large responses:
 ### Text Chunks
 
 ```javascript
-restClient.executeChunkedRequest({
-    method: 'GET',
-    url: 'https://example.com/large-file.txt'
-}, (error, response, data) => {
-    console.log('Complete data:', data);
-});
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.executeChunkedRequest({");
+console.info("        method: 'GET',");
+console.info("        url: 'https://example.com/large-file.txt'");
+console.info("    }, (error, response, data) => { console.log('Complete data:', data); });");
 ```
 
 ### Binary Chunks
 
 ```javascript
-restClient.executeChunkedRequestBinary({
-    method: 'GET',
-    url: 'https://example.com/image.png'
-}, (error, response, buffer) => {
-    // buffer is a Node.js Buffer
-    require('fs').writeFileSync('image.png', buffer);
-});
+// Node.js reference — real HTTP + fs don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.executeChunkedRequestBinary({");
+console.info("        method: 'GET',");
+console.info("        url: 'https://example.com/image.png'");
+console.info("    }, (error, response, buffer) => {");
+console.info("        // buffer is a Node.js Buffer");
+console.info("        require('fs').writeFileSync('image.png', buffer);");
+console.info("    });");
 ```
 
 ## Cookie Management
@@ -165,10 +168,15 @@ restClient.executeChunkedRequestBinary({
 ### Set Cookies
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'RestClientDemo', ProductVersion: '1.0.0' });
+const restClient = fable.instantiateServiceProvider('RestClient');
+
 restClient.cookie = {
     'session_id': 'abc123',
     'user_token': 'xyz789'
 };
+console.log('Cookies set:', restClient.cookie);
 ```
 
 ### Automatic Cookie Handling
@@ -176,10 +184,16 @@ restClient.cookie = {
 Cookies are automatically included in subsequent requests:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'RestClientDemo', ProductVersion: '1.0.0' });
+const restClient = fable.instantiateServiceProvider('RestClient');
+
 restClient.cookie = { session: 'abc123' };
+console.log('Cookie set:', restClient.cookie);
 
-// This request will include the session cookie
-restClient.getJSON('/protected-resource', callback);
+// In Node.js (browser playground skips real network):
+// restClient.getJSON('/protected-resource', callback);
+console.info("    // restClient.getJSON('/protected-resource', callback);  // sends session cookie");
 ```
 
 ## Request Options
@@ -187,17 +201,18 @@ restClient.getJSON('/protected-resource', callback);
 All request methods accept an options object:
 
 ```javascript
-{
+const requestOptionsShape = {
     url: 'https://api.example.com/endpoint',
     method: 'GET',  // Usually set by the convenience method
     headers: {
         'Authorization': 'Bearer token',
-        'Content-Type': 'application/json',
-        'Accept': 'application/json'
+        'Content-Type':  'application/json',
+        'Accept':        'application/json'
     },
     body: { /* request body for POST/PUT/PATCH */ },
     timeout: 30000  // Request timeout in milliseconds
-}
+};
+console.log('requestOptionsShape:', requestOptionsShape);
 ```
 
 ## Custom Request Preparation
@@ -205,12 +220,21 @@ All request methods accept an options object:
 Override the `prepareRequestOptions` function to modify all outgoing requests:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'RestClientDemo', ProductVersion: '1.0.0' });
+const restClient = fable.instantiateServiceProvider('RestClient');
+
+function getAccessToken() { return 'demo-token-abc123'; }
+
 restClient.prepareRequestOptions = (options) => {
     // Add authentication to all requests
     if (!options.headers) options.headers = {};
     options.headers['Authorization'] = 'Bearer ' + getAccessToken();
     return options;
 };
+
+const sample = restClient.prepareRequestOptions({ url: '/users' });
+console.log('Prepared options:', sample);
 ```
 
 ## Trace Logging
@@ -218,12 +242,17 @@ restClient.prepareRequestOptions = (options) => {
 Enable detailed request logging:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'RestClientDemo', ProductVersion: '1.0.0' });
+
 const restClient = fable.instantiateServiceProvider('RestClient', {
     TraceLog: true
 });
 
 // Or enable globally
 fable.TraceLog = true;
+console.log('Per-instance TraceLog:', restClient.options.TraceLog);
+console.log('Global fable.TraceLog:', fable.TraceLog);
 
 // Logs include:
 // - Request start time
@@ -246,33 +275,29 @@ Beginning GET request to https://api.example.com/users at 1704067200000
 Access the underlying `simple-get` library directly:
 
 ```javascript
-restClient.simpleGet({
-    method: 'GET',
-    url: 'https://example.com',
-    // ... other simple-get options
-}, callback);
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.simpleGet({");
+console.info("        method: 'GET',");
+console.info("        url: 'https://example.com',");
+console.info("        // ... other simple-get options");
+console.info("    }, callback);");
 ```
 
 ## Error Handling
 
 ```javascript
-restClient.getJSON('https://api.example.com/users', (error, response, data) => {
-    if (error) {
-        // Network error, timeout, etc.
-        console.error('Network error:', error.message);
-        return;
-    }
-
-    if (response.statusCode >= 400) {
-        // HTTP error status
-        console.error('HTTP error:', response.statusCode);
-        console.error('Error body:', data);
-        return;
-    }
-
-    // Success
-    console.log('Data:', data);
-});
+// Node.js reference — real HTTP requests don't run in the browser playground.
+console.info("In Node.js:");
+console.info("    restClient.getJSON('https://api.example.com/users', (error, response, data) => {");
+console.info("        if (error) { console.error('Network error:', error.message); return; }");
+console.info("        if (response.statusCode >= 400) {");
+console.info("            console.error('HTTP error:', response.statusCode);");
+console.info("            console.error('Error body:', data);");
+console.info("            return;");
+console.info("        }");
+console.info("        console.log('Data:', data);");
+console.info("    });");
 ```
 
 ## Multiple Instances
@@ -280,11 +305,14 @@ restClient.getJSON('https://api.example.com/users', (error, response, data) => {
 Create separate clients for different APIs:
 
 ```javascript
+const libFable = require('fable');
+const fable = new libFable({ Product: 'RestClientDemo', ProductVersion: '1.0.0' });
+
 const mainApi = fable.instantiateServiceProvider('RestClient', {}, 'main-api');
 const authApi = fable.instantiateServiceProvider('RestClient', {}, 'auth-api');
 
 // Set different cookies for each
-mainApi.cookie = { api_session: '...' };
+mainApi.cookie = { api_session:  '...' };
 authApi.cookie = { auth_session: '...' };
 
 // Set different request preparation
@@ -293,4 +321,8 @@ authApi.prepareRequestOptions = (options) => {
     options.headers['X-Auth-Service'] = 'true';
     return options;
 };
+
+console.log('mainApi cookie keys:', Object.keys(mainApi.cookie));
+console.log('authApi cookie keys:', Object.keys(authApi.cookie));
+console.log('authApi prepared headers:', authApi.prepareRequestOptions({}).headers);
 ```