pict-docuserve 0.0.1

package/dist/pict-docuserve.js

@@ -0,0 +1,4670 @@
+"use strict";
+
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+(function (f) {
+  if (typeof exports === "object" && typeof module !== "undefined") {
+    module.exports = f();
+  } else if (typeof define === "function" && define.amd) {
+    define([], f);
+  } else {
+    var g;
+    if (typeof window !== "undefined") {
+      g = window;
+    } else if (typeof global !== "undefined") {
+      g = global;
+    } else if (typeof self !== "undefined") {
+      g = self;
+    } else {
+      g = this;
+    }
+    g.PictDocuserve = f();
+  }
+})(function () {
+  var define, module, exports;
+  return function () {
+    function r(e, n, t) {
+      function o(i, f) {
+        if (!n[i]) {
+          if (!e[i]) {
+            var c = "function" == typeof require && require;
+            if (!f && c) return c(i, !0);
+            if (u) return u(i, !0);
+            var a = new Error("Cannot find module '" + i + "'");
+            throw a.code = "MODULE_NOT_FOUND", a;
+          }
+          var p = n[i] = {
+            exports: {}
+          };
+          e[i][0].call(p.exports, function (r) {
+            var n = e[i][1][r];
+            return o(n || r);
+          }, p, p.exports, r, e, n, t);
+        }
+        return n[i].exports;
+      }
+      for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
+      return o;
+    }
+    return r;
+  }()({
+    1: [function (require, module, exports) {
+      module.exports = {
+        "name": "fable-serviceproviderbase",
+        "version": "3.0.15",
+        "description": "Simple base classes for fable services.",
+        "main": "source/Fable-ServiceProviderBase.js",
+        "scripts": {
+          "start": "node source/Fable-ServiceProviderBase.js",
+          "test": "npx mocha -u tdd -R spec",
+          "tests": "npx mocha -u tdd --exit -R spec --grep",
+          "coverage": "npx nyc --reporter=lcov --reporter=text-lcov npx mocha -- -u tdd -R spec",
+          "build": "npx quack build"
+        },
+        "mocha": {
+          "diff": true,
+          "extension": ["js"],
+          "package": "./package.json",
+          "reporter": "spec",
+          "slow": "75",
+          "timeout": "5000",
+          "ui": "tdd",
+          "watch-files": ["source/**/*.js", "test/**/*.js"],
+          "watch-ignore": ["lib/vendor"]
+        },
+        "repository": {
+          "type": "git",
+          "url": "https://github.com/stevenvelozo/fable-serviceproviderbase.git"
+        },
+        "keywords": ["entity", "behavior"],
+        "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
+        "license": "MIT",
+        "bugs": {
+          "url": "https://github.com/stevenvelozo/fable-serviceproviderbase/issues"
+        },
+        "homepage": "https://github.com/stevenvelozo/fable-serviceproviderbase",
+        "devDependencies": {
+          "fable": "^3.0.143",
+          "quackage": "^1.0.33"
+        }
+      };
+    }, {}],
+    2: [function (require, module, exports) {
+      /**
+      * Fable Service Base
+      * @author <steven@velozo.com>
+      */
+
+      const libPackage = require('../package.json');
+      class FableServiceProviderBase {
+        // The constructor can be used in two ways:
+        // 1) With a fable, options object and service hash (the options object and service hash are optional)
+        // 2) With an object or nothing as the first parameter, where it will be treated as the options object
+        constructor(pFable, pOptions, pServiceHash) {
+          // Check if a fable was passed in; connect it if so
+          if (typeof pFable === 'object' && pFable.isFable) {
+            this.connectFable(pFable);
+          } else {
+            this.fable = false;
+          }
+
+          // Initialize the services map if it wasn't passed in
+          /** @type {Object} */
+          this._PackageFableServiceProvider = libPackage;
+
+          // initialize options and UUID based on whether the fable was passed in or not.
+          if (this.fable) {
+            this.UUID = pFable.getUUID();
+            this.options = typeof pOptions === 'object' ? pOptions : {};
+          } else {
+            // With no fable, check to see if there was an object passed into either of the first two
+            // Parameters, and if so, treat it as the options object
+            this.options = typeof pFable === 'object' && !pFable.isFable ? pFable : typeof pOptions === 'object' ? pOptions : {};
+            this.UUID = "CORE-SVC-".concat(Math.floor(Math.random() * (99999 - 10000) + 10000));
+          }
+
+          // It's expected that the deriving class will set this
+          this.serviceType = "Unknown-".concat(this.UUID);
+
+          // The service hash is used to identify the specific instantiation of the service in the services map
+          this.Hash = typeof pServiceHash === 'string' ? pServiceHash : !this.fable && typeof pOptions === 'string' ? pOptions : "".concat(this.UUID);
+        }
+        connectFable(pFable) {
+          if (typeof pFable !== 'object' || !pFable.isFable) {
+            let tmpErrorMessage = "Fable Service Provider Base: Cannot connect to Fable, invalid Fable object passed in.  The pFable parameter was a [".concat(typeof pFable, "].}");
+            console.log(tmpErrorMessage);
+            return new Error(tmpErrorMessage);
+          }
+          if (!this.fable) {
+            this.fable = pFable;
+          }
+          if (!this.log) {
+            this.log = this.fable.Logging;
+          }
+          if (!this.services) {
+            this.services = this.fable.services;
+          }
+          if (!this.servicesMap) {
+            this.servicesMap = this.fable.servicesMap;
+          }
+          return true;
+        }
+      }
+      _defineProperty(FableServiceProviderBase, "isFableService", true);
+      module.exports = FableServiceProviderBase;
+
+      // This is left here in case we want to go back to having different code/base class for "core" services
+      module.exports.CoreServiceProviderBase = FableServiceProviderBase;
+    }, {
+      "../package.json": 1
+    }],
+    3: [function (require, module, exports) {
+      module.exports = {
+        "name": "pict-application",
+        "version": "1.0.30",
+        "description": "Application base class for a pict view-based application",
+        "main": "source/Pict-Application.js",
+        "scripts": {
+          "test": "npx mocha -u tdd -R spec",
+          "start": "node source/Pict-Application.js",
+          "coverage": "npx nyc --reporter=lcov --reporter=text-lcov npx mocha -- -u tdd -R spec",
+          "build": "npx quack build",
+          "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t pict-application-image:local",
+          "docker-dev-run": "docker run -it -d --name pict-application-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/pict-application\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" pict-application-image:local",
+          "docker-dev-shell": "docker exec -it pict-application-dev /bin/bash",
+          "tests": "npx mocha -u tdd --exit -R spec --grep",
+          "lint": "eslint source/**",
+          "types": "tsc -p ."
+        },
+        "types": "types/source/Pict-Application.d.ts",
+        "repository": {
+          "type": "git",
+          "url": "git+https://github.com/stevenvelozo/pict-application.git"
+        },
+        "author": "steven velozo <steven@velozo.com>",
+        "license": "MIT",
+        "bugs": {
+          "url": "https://github.com/stevenvelozo/pict-application/issues"
+        },
+        "homepage": "https://github.com/stevenvelozo/pict-application#readme",
+        "devDependencies": {
+          "@eslint/js": "^9.28.0",
+          "browser-env": "^3.3.0",
+          "eslint": "^9.28.0",
+          "pict": "^1.0.343",
+          "pict-provider": "^1.0.7",
+          "pict-view": "^1.0.64",
+          "quackage": "^1.0.45",
+          "typescript": "^5.9.3"
+        },
+        "mocha": {
+          "diff": true,
+          "extension": ["js"],
+          "package": "./package.json",
+          "reporter": "spec",
+          "slow": "75",
+          "timeout": "5000",
+          "ui": "tdd",
+          "watch-files": ["source/**/*.js", "test/**/*.js"],
+          "watch-ignore": ["lib/vendor"]
+        },
+        "dependencies": {
+          "fable-serviceproviderbase": "^3.0.15"
+        }
+      };
+    }, {}],
+    4: [function (require, module, exports) {
+      const libFableServiceBase = require('fable-serviceproviderbase');
+      const libPackage = require('../package.json');
+      const defaultPictSettings = {
+        Name: 'DefaultPictApplication',
+        // The main "viewport" is the view that is used to host our application
+        MainViewportViewIdentifier: 'Default-View',
+        MainViewportRenderableHash: false,
+        MainViewportDestinationAddress: false,
+        MainViewportDefaultDataAddress: false,
+        // Whether or not we should automatically render the main viewport and other autorender views after we initialize the pict application
+        AutoSolveAfterInitialize: true,
+        AutoRenderMainViewportViewAfterInitialize: true,
+        AutoRenderViewsAfterInitialize: false,
+        AutoLoginAfterInitialize: false,
+        AutoLoadDataAfterLogin: false,
+        ConfigurationOnlyViews: [],
+        Manifests: {},
+        // The prefix to prepend on all template destination hashes
+        IdentifierAddressPrefix: 'PICT-'
+      };
+
+      /**
+       * Base class for pict applications.
+       */
+      class PictApplication extends libFableServiceBase {
+        /**
+         * @param {import('fable')} pFable
+         * @param {Record<string, any>} [pOptions]
+         * @param {string} [pServiceHash]
+         */
+        constructor(pFable, pOptions, pServiceHash) {
+          let tmpCarryOverConfiguration = typeof pFable.settings.PictApplicationConfiguration === 'object' ? pFable.settings.PictApplicationConfiguration : {};
+          let tmpOptions = Object.assign({}, JSON.parse(JSON.stringify(defaultPictSettings)), tmpCarryOverConfiguration, pOptions);
+          super(pFable, tmpOptions, pServiceHash);
+
+          /** @type {any} */
+          this.options;
+          /** @type {any} */
+          this.log;
+          /** @type {import('pict') & import('fable')} */
+          this.fable;
+          /** @type {string} */
+          this.UUID;
+          /** @type {string} */
+          this.Hash;
+          /**
+           * @type {{ [key: string]: any }}
+           */
+          this.servicesMap;
+          this.serviceType = 'PictApplication';
+          /** @type {Record<string, any>} */
+          this._Package = libPackage;
+
+          // Convenience and consistency naming
+          this.pict = this.fable;
+          // Wire in the essential Pict state
+          /** @type {Record<string, any>} */
+          this.AppData = this.fable.AppData;
+          /** @type {Record<string, any>} */
+          this.Bundle = this.fable.Bundle;
+
+          /** @type {number} */
+          this.initializeTimestamp;
+          /** @type {number} */
+          this.lastSolvedTimestamp;
+          /** @type {number} */
+          this.lastLoginTimestamp;
+          /** @type {number} */
+          this.lastMarshalFromViewsTimestamp;
+          /** @type {number} */
+          this.lastMarshalToViewsTimestamp;
+          /** @type {number} */
+          this.lastAutoRenderTimestamp;
+          /** @type {number} */
+          this.lastLoadDataTimestamp;
+
+          // Load all the manifests for the application
+          let tmpManifestKeys = Object.keys(this.options.Manifests);
+          if (tmpManifestKeys.length > 0) {
+            for (let i = 0; i < tmpManifestKeys.length; i++) {
+              // Load each manifest
+              let tmpManifestKey = tmpManifestKeys[i];
+              this.fable.instantiateServiceProvider('Manifest', this.options.Manifests[tmpManifestKey], tmpManifestKey);
+            }
+          }
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Solve All Views                          */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * @return {boolean}
+         */
+        onPreSolve() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onPreSolve:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onPreSolveAsync(fCallback) {
+          this.onPreSolve();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onBeforeSolve() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onBeforeSolve:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onBeforeSolveAsync(fCallback) {
+          this.onBeforeSolve();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onSolve() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onSolve:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onSolveAsync(fCallback) {
+          this.onSolve();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        solve() {
+          if (this.pict.LogNoisiness > 2) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " executing solve() function..."));
+          }
+
+          // Walk through any loaded providers and solve them as well.
+          let tmpLoadedProviders = Object.keys(this.pict.providers);
+          let tmpProvidersToSolve = [];
+          for (let i = 0; i < tmpLoadedProviders.length; i++) {
+            let tmpProvider = this.pict.providers[tmpLoadedProviders[i]];
+            if (tmpProvider.options.AutoSolveWithApp) {
+              tmpProvidersToSolve.push(tmpProvider);
+            }
+          }
+          // Sort the providers by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+          tmpProvidersToSolve.sort((a, b) => {
+            return a.options.AutoSolveOrdinal - b.options.AutoSolveOrdinal;
+          });
+          for (let i = 0; i < tmpProvidersToSolve.length; i++) {
+            tmpProvidersToSolve[i].solve(tmpProvidersToSolve[i]);
+          }
+          this.onBeforeSolve();
+          // Now walk through any loaded views and initialize them as well.
+          let tmpLoadedViews = Object.keys(this.pict.views);
+          let tmpViewsToSolve = [];
+          for (let i = 0; i < tmpLoadedViews.length; i++) {
+            let tmpView = this.pict.views[tmpLoadedViews[i]];
+            if (tmpView.options.AutoInitialize) {
+              tmpViewsToSolve.push(tmpView);
+            }
+          }
+          // Sort the views by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+          tmpViewsToSolve.sort((a, b) => {
+            return a.options.AutoInitializeOrdinal - b.options.AutoInitializeOrdinal;
+          });
+          for (let i = 0; i < tmpViewsToSolve.length; i++) {
+            tmpViewsToSolve[i].solve();
+          }
+          this.onSolve();
+          this.onAfterSolve();
+          this.lastSolvedTimestamp = this.fable.log.getTimeStamp();
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        solveAsync(fCallback) {
+          let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+          tmpAnticipate.anticipate(this.onBeforeSolveAsync.bind(this));
+
+          // Allow the callback to be passed in as the last parameter no matter what
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : false;
+          if (!tmpCallback) {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " solveAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " solveAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          // Walk through any loaded providers and solve them as well.
+          let tmpLoadedProviders = Object.keys(this.pict.providers);
+          let tmpProvidersToSolve = [];
+          for (let i = 0; i < tmpLoadedProviders.length; i++) {
+            let tmpProvider = this.pict.providers[tmpLoadedProviders[i]];
+            if (tmpProvider.options.AutoSolveWithApp) {
+              tmpProvidersToSolve.push(tmpProvider);
+            }
+          }
+          // Sort the providers by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+          tmpProvidersToSolve.sort((a, b) => {
+            return a.options.AutoSolveOrdinal - b.options.AutoSolveOrdinal;
+          });
+          for (let i = 0; i < tmpProvidersToSolve.length; i++) {
+            tmpAnticipate.anticipate(tmpProvidersToSolve[i].solveAsync.bind(tmpProvidersToSolve[i]));
+          }
+
+          // Walk through any loaded views and solve them as well.
+          let tmpLoadedViews = Object.keys(this.pict.views);
+          let tmpViewsToSolve = [];
+          for (let i = 0; i < tmpLoadedViews.length; i++) {
+            let tmpView = this.pict.views[tmpLoadedViews[i]];
+            if (tmpView.options.AutoSolveWithApp) {
+              tmpViewsToSolve.push(tmpView);
+            }
+          }
+          // Sort the views by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+          tmpViewsToSolve.sort((a, b) => {
+            return a.options.AutoSolveOrdinal - b.options.AutoSolveOrdinal;
+          });
+          for (let i = 0; i < tmpViewsToSolve.length; i++) {
+            tmpAnticipate.anticipate(tmpViewsToSolve[i].solveAsync.bind(tmpViewsToSolve[i]));
+          }
+          tmpAnticipate.anticipate(this.onSolveAsync.bind(this));
+          tmpAnticipate.anticipate(this.onAfterSolveAsync.bind(this));
+          tmpAnticipate.wait(pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " solveAsync() complete."));
+            }
+            this.lastSolvedTimestamp = this.fable.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onAfterSolve() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onAfterSolve:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onAfterSolveAsync(fCallback) {
+          this.onAfterSolve();
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Application Login                        */
+        /* -------------------------------------------------------------------------- */
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onBeforeLoginAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onBeforeLoginAsync:"));
+          }
+          return fCallback();
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onLoginAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onLoginAsync:"));
+          }
+          return fCallback();
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        loginAsync(fCallback) {
+          const tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+          let tmpCallback = fCallback;
+          if (typeof tmpCallback !== 'function') {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " loginAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " loginAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          tmpAnticipate.anticipate(this.onBeforeLoginAsync.bind(this));
+          tmpAnticipate.anticipate(this.onLoginAsync.bind(this));
+          tmpAnticipate.anticipate(this.onAfterLoginAsync.bind(this));
+
+          // check and see if we should automatically trigger a data load
+          if (this.options.AutoLoadDataAfterLogin) {
+            tmpAnticipate.anticipate(fNext => {
+              if (!this.isLoggedIn()) {
+                return fNext();
+              }
+              if (this.pict.LogNoisiness > 1) {
+                this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " auto loading data after login..."));
+              }
+              //TODO: should data load errors funnel here? this creates a weird coupling between login and data load callbacks
+              this.loadDataAsync(pError => {
+                fNext(pError);
+              });
+            });
+          }
+          tmpAnticipate.wait(pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " loginAsync() complete."));
+            }
+            this.lastLoginTimestamp = this.fable.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * Check if the application state is logged in. Defaults to true. Override this method in your application based on login requirements.
+         *
+         * @return {boolean}
+         */
+        isLoggedIn() {
+          return true;
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onAfterLoginAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onAfterLoginAsync:"));
+          }
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Application LoadData                     */
+        /* -------------------------------------------------------------------------- */
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onBeforeLoadDataAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onBeforeLoadDataAsync:"));
+          }
+          return fCallback();
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onLoadDataAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onLoadDataAsync:"));
+          }
+          return fCallback();
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        loadDataAsync(fCallback) {
+          const tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+          let tmpCallback = fCallback;
+          if (typeof tmpCallback !== 'function') {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " loadDataAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " loadDataAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          tmpAnticipate.anticipate(this.onBeforeLoadDataAsync.bind(this));
+
+          // Walk through any loaded providers and load their data as well.
+          let tmpLoadedProviders = Object.keys(this.pict.providers);
+          let tmpProvidersToLoadData = [];
+          for (let i = 0; i < tmpLoadedProviders.length; i++) {
+            let tmpProvider = this.pict.providers[tmpLoadedProviders[i]];
+            if (tmpProvider.options.AutoLoadDataWithApp) {
+              tmpProvidersToLoadData.push(tmpProvider);
+            }
+          }
+          // Sort the providers by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+          tmpProvidersToLoadData.sort((a, b) => {
+            return a.options.AutoLoadDataOrdinal - b.options.AutoLoadDataOrdinal;
+          });
+          for (const tmpProvider of tmpProvidersToLoadData) {
+            tmpAnticipate.anticipate(tmpProvider.onBeforeLoadDataAsync.bind(tmpProvider));
+          }
+          tmpAnticipate.anticipate(this.onLoadDataAsync.bind(this));
+
+          //TODO: think about ways to parallelize these
+          for (const tmpProvider of tmpProvidersToLoadData) {
+            tmpAnticipate.anticipate(tmpProvider.onLoadDataAsync.bind(tmpProvider));
+          }
+          tmpAnticipate.anticipate(this.onAfterLoadDataAsync.bind(this));
+          for (const tmpProvider of tmpProvidersToLoadData) {
+            tmpAnticipate.anticipate(tmpProvider.onAfterLoadDataAsync.bind(tmpProvider));
+          }
+          tmpAnticipate.wait(/** @param {Error} [pError] */
+          pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " loadDataAsync() complete."));
+            }
+            this.lastLoadDataTimestamp = this.fable.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onAfterLoadDataAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onAfterLoadDataAsync:"));
+          }
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Application SaveData                     */
+        /* -------------------------------------------------------------------------- */
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onBeforeSaveDataAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onBeforeSaveDataAsync:"));
+          }
+          return fCallback();
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onSaveDataAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onSaveDataAsync:"));
+          }
+          return fCallback();
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        saveDataAsync(fCallback) {
+          const tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+          let tmpCallback = fCallback;
+          if (typeof tmpCallback !== 'function') {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " saveDataAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " saveDataAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          tmpAnticipate.anticipate(this.onBeforeSaveDataAsync.bind(this));
+
+          // Walk through any loaded providers and load their data as well.
+          let tmpLoadedProviders = Object.keys(this.pict.providers);
+          let tmpProvidersToSaveData = [];
+          for (let i = 0; i < tmpLoadedProviders.length; i++) {
+            let tmpProvider = this.pict.providers[tmpLoadedProviders[i]];
+            if (tmpProvider.options.AutoSaveDataWithApp) {
+              tmpProvidersToSaveData.push(tmpProvider);
+            }
+          }
+          // Sort the providers by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+          tmpProvidersToSaveData.sort((a, b) => {
+            return a.options.AutoSaveDataOrdinal - b.options.AutoSaveDataOrdinal;
+          });
+          for (const tmpProvider of tmpProvidersToSaveData) {
+            tmpAnticipate.anticipate(tmpProvider.onBeforeSaveDataAsync.bind(tmpProvider));
+          }
+          tmpAnticipate.anticipate(this.onSaveDataAsync.bind(this));
+
+          //TODO: think about ways to parallelize these
+          for (const tmpProvider of tmpProvidersToSaveData) {
+            tmpAnticipate.anticipate(tmpProvider.onSaveDataAsync.bind(tmpProvider));
+          }
+          tmpAnticipate.anticipate(this.onAfterSaveDataAsync.bind(this));
+          for (const tmpProvider of tmpProvidersToSaveData) {
+            tmpAnticipate.anticipate(tmpProvider.onAfterSaveDataAsync.bind(tmpProvider));
+          }
+          tmpAnticipate.wait(/** @param {Error} [pError] */
+          pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " saveDataAsync() complete."));
+            }
+            this.lastSaveDataTimestamp = this.fable.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onAfterSaveDataAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onAfterSaveDataAsync:"));
+          }
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Initialize Application                   */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * @return {boolean}
+         */
+        onBeforeInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onBeforeInitialize:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onBeforeInitializeAsync(fCallback) {
+          this.onBeforeInitialize();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onInitialize:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onInitializeAsync(fCallback) {
+          this.onInitialize();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        initialize() {
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow APPLICATION [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " initialize:"));
+          }
+          if (!this.initializeTimestamp) {
+            this.onBeforeInitialize();
+            if ('ConfigurationOnlyViews' in this.options) {
+              // Load all the configuration only views
+              for (let i = 0; i < this.options.ConfigurationOnlyViews.length; i++) {
+                let tmpViewIdentifier = typeof this.options.ConfigurationOnlyViews[i].ViewIdentifier === 'undefined' ? "AutoView-".concat(this.fable.getUUID()) : this.options.ConfigurationOnlyViews[i].ViewIdentifier;
+                this.log.info("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " adding configuration only view: ").concat(tmpViewIdentifier));
+                this.pict.addView(tmpViewIdentifier, this.options.ConfigurationOnlyViews[i]);
+              }
+            }
+            this.onInitialize();
+
+            // Walk through any loaded providers and initialize them as well.
+            let tmpLoadedProviders = Object.keys(this.pict.providers);
+            let tmpProvidersToInitialize = [];
+            for (let i = 0; i < tmpLoadedProviders.length; i++) {
+              let tmpProvider = this.pict.providers[tmpLoadedProviders[i]];
+              if (tmpProvider.options.AutoInitialize) {
+                tmpProvidersToInitialize.push(tmpProvider);
+              }
+            }
+            // Sort the providers by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+            tmpProvidersToInitialize.sort((a, b) => {
+              return a.options.AutoInitializeOrdinal - b.options.AutoInitializeOrdinal;
+            });
+            for (let i = 0; i < tmpProvidersToInitialize.length; i++) {
+              tmpProvidersToInitialize[i].initialize();
+            }
+
+            // Now walk through any loaded views and initialize them as well.
+            let tmpLoadedViews = Object.keys(this.pict.views);
+            let tmpViewsToInitialize = [];
+            for (let i = 0; i < tmpLoadedViews.length; i++) {
+              let tmpView = this.pict.views[tmpLoadedViews[i]];
+              if (tmpView.options.AutoInitialize) {
+                tmpViewsToInitialize.push(tmpView);
+              }
+            }
+            // Sort the views by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+            tmpViewsToInitialize.sort((a, b) => {
+              return a.options.AutoInitializeOrdinal - b.options.AutoInitializeOrdinal;
+            });
+            for (let i = 0; i < tmpViewsToInitialize.length; i++) {
+              tmpViewsToInitialize[i].initialize();
+            }
+            this.onAfterInitialize();
+            if (this.options.AutoSolveAfterInitialize) {
+              if (this.pict.LogNoisiness > 1) {
+                this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " auto solving after initialization..."));
+              }
+              // Solve the template synchronously
+              this.solve();
+            }
+            // Now check and see if we should automatically render as well
+            if (this.options.AutoRenderMainViewportViewAfterInitialize) {
+              if (this.pict.LogNoisiness > 1) {
+                this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " auto rendering after initialization..."));
+              }
+              // Render the template synchronously
+              this.render();
+            }
+            this.initializeTimestamp = this.fable.log.getTimeStamp();
+            this.onCompletionOfInitialize();
+            return true;
+          } else {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " initialize called but initialization is already completed.  Aborting."));
+            return false;
+          }
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        initializeAsync(fCallback) {
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow APPLICATION [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " initializeAsync:"));
+          }
+
+          // Allow the callback to be passed in as the last parameter no matter what
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : false;
+          if (!tmpCallback) {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " initializeAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " initializeAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          if (!this.initializeTimestamp) {
+            let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+            if (this.pict.LogNoisiness > 3) {
+              this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " beginning initialization..."));
+            }
+            if ('ConfigurationOnlyViews' in this.options) {
+              // Load all the configuration only views
+              for (let i = 0; i < this.options.ConfigurationOnlyViews.length; i++) {
+                let tmpViewIdentifier = typeof this.options.ConfigurationOnlyViews[i].ViewIdentifier === 'undefined' ? "AutoView-".concat(this.fable.getUUID()) : this.options.ConfigurationOnlyViews[i].ViewIdentifier;
+                this.log.info("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " adding configuration only view: ").concat(tmpViewIdentifier));
+                this.pict.addView(tmpViewIdentifier, this.options.ConfigurationOnlyViews[i]);
+              }
+            }
+            tmpAnticipate.anticipate(this.onBeforeInitializeAsync.bind(this));
+            tmpAnticipate.anticipate(this.onInitializeAsync.bind(this));
+
+            // Walk through any loaded providers and solve them as well.
+            let tmpLoadedProviders = Object.keys(this.pict.providers);
+            let tmpProvidersToInitialize = [];
+            for (let i = 0; i < tmpLoadedProviders.length; i++) {
+              let tmpProvider = this.pict.providers[tmpLoadedProviders[i]];
+              if (tmpProvider.options.AutoInitialize) {
+                tmpProvidersToInitialize.push(tmpProvider);
+              }
+            }
+            // Sort the providers by their priority (if they are all priority 0, it will end up being add order due to JSON Object Property Key order stuff)
+            tmpProvidersToInitialize.sort((a, b) => {
+              return a.options.AutoInitializeOrdinal - b.options.AutoInitializeOrdinal;
+            });
+            for (let i = 0; i < tmpProvidersToInitialize.length; i++) {
+              tmpAnticipate.anticipate(tmpProvidersToInitialize[i].initializeAsync.bind(tmpProvidersToInitialize[i]));
+            }
+
+            // Now walk through any loaded views and initialize them as well.
+            // TODO: Some optimization cleverness could be gained by grouping them into a parallelized async operation, by ordinal.
+            let tmpLoadedViews = Object.keys(this.pict.views);
+            let tmpViewsToInitialize = [];
+            for (let i = 0; i < tmpLoadedViews.length; i++) {
+              let tmpView = this.pict.views[tmpLoadedViews[i]];
+              if (tmpView.options.AutoInitialize) {
+                tmpViewsToInitialize.push(tmpView);
+              }
+            }
+            // Sort the views by their priority
+            // If they are all the default priority 0, it will end up being add order due to JSON Object Property Key order stuff
+            tmpViewsToInitialize.sort((a, b) => {
+              return a.options.AutoInitializeOrdinal - b.options.AutoInitializeOrdinal;
+            });
+            for (let i = 0; i < tmpViewsToInitialize.length; i++) {
+              let tmpView = tmpViewsToInitialize[i];
+              tmpAnticipate.anticipate(tmpView.initializeAsync.bind(tmpView));
+            }
+            tmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));
+            if (this.options.AutoLoginAfterInitialize) {
+              if (this.pict.LogNoisiness > 1) {
+                this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " auto login (asynchronously) after initialization..."));
+              }
+              tmpAnticipate.anticipate(this.loginAsync.bind(this));
+            }
+            if (this.options.AutoSolveAfterInitialize) {
+              if (this.pict.LogNoisiness > 1) {
+                this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " auto solving (asynchronously) after initialization..."));
+              }
+              tmpAnticipate.anticipate(this.solveAsync.bind(this));
+            }
+            if (this.options.AutoRenderMainViewportViewAfterInitialize) {
+              if (this.pict.LogNoisiness > 1) {
+                this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " auto rendering (asynchronously) after initialization..."));
+              }
+              tmpAnticipate.anticipate(this.renderMainViewportAsync.bind(this));
+            }
+            tmpAnticipate.wait(pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " initializeAsync Error: ").concat(pError.message || pError), {
+                  stack: pError.stack
+                });
+              }
+              this.initializeTimestamp = this.fable.log.getTimeStamp();
+              if (this.pict.LogNoisiness > 2) {
+                this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " initialization complete."));
+              }
+              return tmpCallback();
+            });
+          } else {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " async initialize called but initialization is already completed.  Aborting."));
+            // TODO: Should this be an error?
+            return this.onCompletionOfInitializeAsync(tmpCallback);
+          }
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onAfterInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onAfterInitialize:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onAfterInitializeAsync(fCallback) {
+          this.onAfterInitialize();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onCompletionOfInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onCompletionOfInitialize:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onCompletionOfInitializeAsync(fCallback) {
+          this.onCompletionOfInitialize();
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Marshal Data From All Views              */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * @return {boolean}
+         */
+        onBeforeMarshalFromViews() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onBeforeMarshalFromViews:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onBeforeMarshalFromViewsAsync(fCallback) {
+          this.onBeforeMarshalFromViews();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onMarshalFromViews() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onMarshalFromViews:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onMarshalFromViewsAsync(fCallback) {
+          this.onMarshalFromViews();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        marshalFromViews() {
+          if (this.pict.LogNoisiness > 2) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " executing marshalFromViews() function..."));
+          }
+          this.onBeforeMarshalFromViews();
+          // Now walk through any loaded views and initialize them as well.
+          let tmpLoadedViews = Object.keys(this.pict.views);
+          let tmpViewsToMarshalFromViews = [];
+          for (let i = 0; i < tmpLoadedViews.length; i++) {
+            let tmpView = this.pict.views[tmpLoadedViews[i]];
+            tmpViewsToMarshalFromViews.push(tmpView);
+          }
+          for (let i = 0; i < tmpViewsToMarshalFromViews.length; i++) {
+            tmpViewsToMarshalFromViews[i].marshalFromView();
+          }
+          this.onMarshalFromViews();
+          this.onAfterMarshalFromViews();
+          this.lastMarshalFromViewsTimestamp = this.fable.log.getTimeStamp();
+          return true;
+        }
+
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        marshalFromViewsAsync(fCallback) {
+          let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+          // Allow the callback to be passed in as the last parameter no matter what
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : false;
+          if (!tmpCallback) {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalFromViewsAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalFromViewsAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          tmpAnticipate.anticipate(this.onBeforeMarshalFromViewsAsync.bind(this));
+          // Walk through any loaded views and marshalFromViews them as well.
+          let tmpLoadedViews = Object.keys(this.pict.views);
+          let tmpViewsToMarshalFromViews = [];
+          for (let i = 0; i < tmpLoadedViews.length; i++) {
+            let tmpView = this.pict.views[tmpLoadedViews[i]];
+            tmpViewsToMarshalFromViews.push(tmpView);
+          }
+          for (let i = 0; i < tmpViewsToMarshalFromViews.length; i++) {
+            tmpAnticipate.anticipate(tmpViewsToMarshalFromViews[i].marshalFromViewAsync.bind(tmpViewsToMarshalFromViews[i]));
+          }
+          tmpAnticipate.anticipate(this.onMarshalFromViewsAsync.bind(this));
+          tmpAnticipate.anticipate(this.onAfterMarshalFromViewsAsync.bind(this));
+          tmpAnticipate.wait(pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalFromViewsAsync() complete."));
+            }
+            this.lastMarshalFromViewsTimestamp = this.fable.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onAfterMarshalFromViews() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onAfterMarshalFromViews:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onAfterMarshalFromViewsAsync(fCallback) {
+          this.onAfterMarshalFromViews();
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Marshal Data To All Views                */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * @return {boolean}
+         */
+        onBeforeMarshalToViews() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onBeforeMarshalToViews:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onBeforeMarshalToViewsAsync(fCallback) {
+          this.onBeforeMarshalToViews();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onMarshalToViews() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onMarshalToViews:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onMarshalToViewsAsync(fCallback) {
+          this.onMarshalToViews();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        marshalToViews() {
+          if (this.pict.LogNoisiness > 2) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " executing marshalToViews() function..."));
+          }
+          this.onBeforeMarshalToViews();
+          // Now walk through any loaded views and initialize them as well.
+          let tmpLoadedViews = Object.keys(this.pict.views);
+          let tmpViewsToMarshalToViews = [];
+          for (let i = 0; i < tmpLoadedViews.length; i++) {
+            let tmpView = this.pict.views[tmpLoadedViews[i]];
+            tmpViewsToMarshalToViews.push(tmpView);
+          }
+          for (let i = 0; i < tmpViewsToMarshalToViews.length; i++) {
+            tmpViewsToMarshalToViews[i].marshalToView();
+          }
+          this.onMarshalToViews();
+          this.onAfterMarshalToViews();
+          this.lastMarshalToViewsTimestamp = this.fable.log.getTimeStamp();
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        marshalToViewsAsync(fCallback) {
+          let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+          // Allow the callback to be passed in as the last parameter no matter what
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : false;
+          if (!tmpCallback) {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalToViewsAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalToViewsAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          tmpAnticipate.anticipate(this.onBeforeMarshalToViewsAsync.bind(this));
+          // Walk through any loaded views and marshalToViews them as well.
+          let tmpLoadedViews = Object.keys(this.pict.views);
+          let tmpViewsToMarshalToViews = [];
+          for (let i = 0; i < tmpLoadedViews.length; i++) {
+            let tmpView = this.pict.views[tmpLoadedViews[i]];
+            tmpViewsToMarshalToViews.push(tmpView);
+          }
+          for (let i = 0; i < tmpViewsToMarshalToViews.length; i++) {
+            tmpAnticipate.anticipate(tmpViewsToMarshalToViews[i].marshalToViewAsync.bind(tmpViewsToMarshalToViews[i]));
+          }
+          tmpAnticipate.anticipate(this.onMarshalToViewsAsync.bind(this));
+          tmpAnticipate.anticipate(this.onAfterMarshalToViewsAsync.bind(this));
+          tmpAnticipate.wait(pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalToViewsAsync() complete."));
+            }
+            this.lastMarshalToViewsTimestamp = this.fable.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onAfterMarshalToViews() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onAfterMarshalToViews:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onAfterMarshalToViewsAsync(fCallback) {
+          this.onAfterMarshalToViews();
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Render View                              */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * @return {boolean}
+         */
+        onBeforeRender() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onBeforeRender:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onBeforeRenderAsync(fCallback) {
+          this.onBeforeRender();
+          return fCallback();
+        }
+
+        /**
+         * @param {string} [pViewIdentifier] - The hash of the view to render. By default, the main viewport view is rendered.
+         * @param {string} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string} [pTemplateDataAddress] - The address where the data for the template is stored.
+         *
+         * TODO: Should we support objects for pTemplateDataAddress for parity with pict-view?
+         */
+        render(pViewIdentifier, pRenderableHash, pRenderDestinationAddress, pTemplateDataAddress) {
+          let tmpViewIdentifier = typeof pViewIdentifier !== 'string' ? this.options.MainViewportViewIdentifier : pViewIdentifier;
+          let tmpRenderableHash = typeof pRenderableHash !== 'string' ? this.options.MainViewportRenderableHash : pRenderableHash;
+          let tmpRenderDestinationAddress = typeof pRenderDestinationAddress !== 'string' ? this.options.MainViewportDestinationAddress : pRenderDestinationAddress;
+          let tmpTemplateDataAddress = typeof pTemplateDataAddress !== 'string' ? this.options.MainViewportDefaultDataAddress : pTemplateDataAddress;
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow APPLICATION [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " VIEW Renderable[").concat(tmpRenderableHash, "] Destination[").concat(tmpRenderDestinationAddress, "] TemplateDataAddress[").concat(tmpTemplateDataAddress, "] render:"));
+          }
+          this.onBeforeRender();
+
+          // Now get the view (by hash) from the loaded views
+          let tmpView = typeof tmpViewIdentifier === 'string' ? this.servicesMap.PictView[tmpViewIdentifier] : false;
+          if (!tmpView) {
+            this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " could not render from View ").concat(tmpViewIdentifier, " because it is not a valid view."));
+            return false;
+          }
+          this.onRender();
+          tmpView.render(tmpRenderableHash, tmpRenderDestinationAddress, tmpTemplateDataAddress);
+          this.onAfterRender();
+          return true;
+        }
+        /**
+         * @return {boolean}
+         */
+        onRender() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onRender:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onRenderAsync(fCallback) {
+          this.onRender();
+          return fCallback();
+        }
+
+        /**
+         * @param {string|((error?: Error) => void)} pViewIdentifier - The hash of the view to render. By default, the main viewport view is rendered. (or the callback)
+         * @param {string|((error?: Error) => void)} [pRenderableHash] - The hash of the renderable to render. (or the callback)
+         * @param {string|((error?: Error) => void)} [pRenderDestinationAddress] - The address where the renderable will be rendered. (or the callback)
+         * @param {string|((error?: Error) => void)} [pTemplateDataAddress] - The address where the data for the template is stored. (or the callback)
+         * @param {(error?: Error) => void} [fCallback] - The callback, if all other parameters are provided.
+         *
+         * TODO: Should we support objects for pTemplateDataAddress for parity with pict-view?
+         */
+        renderAsync(pViewIdentifier, pRenderableHash, pRenderDestinationAddress, pTemplateDataAddress, fCallback) {
+          let tmpViewIdentifier = typeof pViewIdentifier !== 'string' ? this.options.MainViewportViewIdentifier : pViewIdentifier;
+          let tmpRenderableHash = typeof pRenderableHash !== 'string' ? this.options.MainViewportRenderableHash : pRenderableHash;
+          let tmpRenderDestinationAddress = typeof pRenderDestinationAddress !== 'string' ? this.options.MainViewportDestinationAddress : pRenderDestinationAddress;
+          let tmpTemplateDataAddress = typeof pTemplateDataAddress !== 'string' ? this.options.MainViewportDefaultDataAddress : pTemplateDataAddress;
+
+          // Allow the callback to be passed in as the last parameter no matter what
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : typeof pTemplateDataAddress === 'function' ? pTemplateDataAddress : typeof pRenderDestinationAddress === 'function' ? pRenderDestinationAddress : typeof pRenderableHash === 'function' ? pRenderableHash : typeof pViewIdentifier === 'function' ? pViewIdentifier : false;
+          if (!tmpCallback) {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow APPLICATION [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " VIEW Renderable[").concat(tmpRenderableHash, "] Destination[").concat(tmpRenderDestinationAddress, "] TemplateDataAddress[").concat(tmpTemplateDataAddress, "] renderAsync:"));
+          }
+          let tmpRenderAnticipate = this.fable.newAnticipate();
+          tmpRenderAnticipate.anticipate(this.onBeforeRenderAsync.bind(this));
+          let tmpView = typeof tmpViewIdentifier === 'string' ? this.servicesMap.PictView[tmpViewIdentifier] : false;
+          if (!tmpView) {
+            let tmpErrorMessage = "PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " could not asynchronously render from View ").concat(tmpViewIdentifier, " because it is not a valid view.");
+            if (this.pict.LogNoisiness > 3) {
+              this.log.error(tmpErrorMessage);
+            }
+            return tmpCallback(new Error(tmpErrorMessage));
+          }
+          tmpRenderAnticipate.anticipate(this.onRenderAsync.bind(this));
+          tmpRenderAnticipate.anticipate(fNext => {
+            tmpView.renderAsync.call(tmpView, tmpRenderableHash, tmpRenderDestinationAddress, tmpTemplateDataAddress, fNext);
+          });
+          tmpRenderAnticipate.anticipate(this.onAfterRenderAsync.bind(this));
+          return tmpRenderAnticipate.wait(tmpCallback);
+        }
+
+        /**
+         * @return {boolean}
+         */
+        onAfterRender() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " onAfterRender:"));
+          }
+          return true;
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        onAfterRenderAsync(fCallback) {
+          this.onAfterRender();
+          return fCallback();
+        }
+
+        /**
+         * @return {boolean}
+         */
+        renderMainViewport() {
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow APPLICATION [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderMainViewport:"));
+          }
+          return this.render();
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        renderMainViewportAsync(fCallback) {
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow APPLICATION [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderMainViewportAsync:"));
+          }
+          return this.renderAsync(fCallback);
+        }
+        /**
+         * @return {void}
+         */
+        renderAutoViews() {
+          if (this.pict.LogNoisiness > 0) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " beginning renderAutoViews..."));
+          }
+          // Now walk through any loaded views and sort them by the AutoRender ordinal
+          let tmpLoadedViews = Object.keys(this.pict.views);
+          // Sort the views by their priority
+          // If they are all the default priority 0, it will end up being add order due to JSON Object Property Key order stuff
+          tmpLoadedViews.sort((a, b) => {
+            return this.pict.views[a].options.AutoRenderOrdinal - this.pict.views[b].options.AutoRenderOrdinal;
+          });
+          for (let i = 0; i < tmpLoadedViews.length; i++) {
+            let tmpView = this.pict.views[tmpLoadedViews[i]];
+            if (tmpView.options.AutoRender) {
+              tmpView.render();
+            }
+          }
+          if (this.pict.LogNoisiness > 0) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderAutoViewsAsync complete."));
+          }
+        }
+        /**
+         * @param {(error?: Error) => void} fCallback
+         */
+        renderAutoViewsAsync(fCallback) {
+          let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+          // Allow the callback to be passed in as the last parameter no matter what
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : false;
+          if (!tmpCallback) {
+            this.log.warn("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderAutoViewsAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderAutoViewsAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          if (this.pict.LogNoisiness > 0) {
+            this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " beginning renderAutoViewsAsync..."));
+          }
+
+          // Now walk through any loaded views and sort them by the AutoRender ordinal
+          // TODO: Some optimization cleverness could be gained by grouping them into a parallelized async operation, by ordinal.
+          let tmpLoadedViews = Object.keys(this.pict.views);
+          // Sort the views by their priority
+          // If they are all the default priority 0, it will end up being add order due to JSON Object Property Key order stuff
+          tmpLoadedViews.sort((a, b) => {
+            return this.pict.views[a].options.AutoRenderOrdinal - this.pict.views[b].options.AutoRenderOrdinal;
+          });
+          for (let i = 0; i < tmpLoadedViews.length; i++) {
+            let tmpView = this.pict.views[tmpLoadedViews[i]];
+            if (tmpView.options.AutoRender) {
+              tmpAnticipate.anticipate(tmpView.renderAsync.bind(tmpView));
+            }
+          }
+          tmpAnticipate.wait(pError => {
+            this.lastAutoRenderTimestamp = this.fable.log.getTimeStamp();
+            if (this.pict.LogNoisiness > 0) {
+              this.log.trace("PictApp [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderAutoViewsAsync complete."));
+            }
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * @return {boolean}
+         */
+        get isPictApplication() {
+          return true;
+        }
+      }
+      module.exports = PictApplication;
+    }, {
+      "../package.json": 3,
+      "fable-serviceproviderbase": 2
+    }],
+    5: [function (require, module, exports) {
+      module.exports = {
+        "name": "pict-provider",
+        "version": "1.0.7",
+        "description": "Pict Provider Base Class",
+        "main": "source/Pict-Provider.js",
+        "scripts": {
+          "start": "node source/Pict-Provider.js",
+          "test": "npx mocha -u tdd -R spec",
+          "tests": "npx mocha -u tdd --exit -R spec --grep",
+          "coverage": "npx nyc --reporter=lcov --reporter=text-lcov npx mocha -- -u tdd -R spec",
+          "build": "npx quack build",
+          "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t pict-provider-image:local",
+          "docker-dev-run": "docker run -it -d --name pict-provider-dev -p 24125:8080 -p 30027:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/pict-provider\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" pict-provider-image:local",
+          "docker-dev-shell": "docker exec -it pict-provider-dev /bin/bash",
+          "lint": "eslint source/**",
+          "types": "tsc -p ."
+        },
+        "types": "types/source/Pict-Provider.d.ts",
+        "repository": {
+          "type": "git",
+          "url": "git+https://github.com/stevenvelozo/pict-provider.git"
+        },
+        "author": "steven velozo <steven@velozo.com>",
+        "license": "MIT",
+        "bugs": {
+          "url": "https://github.com/stevenvelozo/pict-provider/issues"
+        },
+        "homepage": "https://github.com/stevenvelozo/pict-provider#readme",
+        "devDependencies": {
+          "@eslint/js": "^9.39.1",
+          "eslint": "^9.39.1",
+          "pict": "^1.0.342",
+          "quackage": "^1.0.45",
+          "typescript": "^5.9.3"
+        },
+        "dependencies": {
+          "fable-serviceproviderbase": "^3.0.15"
+        },
+        "mocha": {
+          "diff": true,
+          "extension": ["js"],
+          "package": "./package.json",
+          "reporter": "spec",
+          "slow": "75",
+          "timeout": "5000",
+          "ui": "tdd",
+          "watch-files": ["source/**/*.js", "test/**/*.js"],
+          "watch-ignore": ["lib/vendor"]
+        }
+      };
+    }, {}],
+    6: [function (require, module, exports) {
+      const libFableServiceBase = require('fable-serviceproviderbase');
+      const libPackage = require('../package.json');
+      const defaultPictProviderSettings = {
+        ProviderIdentifier: false,
+        // If this is set to true, when the App initializes this will.
+        // After the App initializes, initialize will be called as soon as it's added.
+        AutoInitialize: true,
+        AutoInitializeOrdinal: 0,
+        AutoLoadDataWithApp: true,
+        AutoSolveWithApp: true,
+        AutoSolveOrdinal: 0,
+        Manifests: {},
+        Templates: []
+      };
+      class PictProvider extends libFableServiceBase {
+        /**
+         * @param {import('fable')} pFable - The Fable instance.
+         * @param {Record<string, any>} [pOptions] - The options for the provider.
+         * @param {string} [pServiceHash] - The service hash for the provider.
+         */
+        constructor(pFable, pOptions, pServiceHash) {
+          // Intersect default options, parent constructor, service information
+          let tmpOptions = Object.assign({}, JSON.parse(JSON.stringify(defaultPictProviderSettings)), pOptions);
+          super(pFable, tmpOptions, pServiceHash);
+
+          /** @type {import('fable') & import('pict') & { instantiateServiceProviderWithoutRegistration(pServiceType: string, pOptions?: Record<string, any>, pCustomServiceHash?: string): any }} */
+          this.fable;
+          /** @type {import('fable') & import('pict') & { instantiateServiceProviderWithoutRegistration(pServiceType: string, pOptions?: Record<string, any>, pCustomServiceHash?: string): any }} */
+          this.pict;
+          /** @type {any} */
+          this.log;
+          /** @type {Record<string, any>} */
+          this.options;
+          /** @type {string} */
+          this.UUID;
+          /** @type {string} */
+          this.Hash;
+          if (!this.options.ProviderIdentifier) {
+            this.options.ProviderIdentifier = "AutoProviderID-".concat(this.fable.getUUID());
+          }
+          this.serviceType = 'PictProvider';
+          /** @type {Record<string, any>} */
+          this._Package = libPackage;
+
+          // Convenience and consistency naming
+          this.pict = this.fable;
+
+          // Wire in the essential Pict application state
+          /** @type {Record<string, any>} */
+          this.AppData = this.pict.AppData;
+          /** @type {Record<string, any>} */
+          this.Bundle = this.pict.Bundle;
+          this.initializeTimestamp = false;
+          this.lastSolvedTimestamp = false;
+          for (let i = 0; i < this.options.Templates.length; i++) {
+            let tmpDefaultTemplate = this.options.Templates[i];
+            if (!tmpDefaultTemplate.hasOwnProperty('Postfix') || !tmpDefaultTemplate.hasOwnProperty('Template')) {
+              this.log.error("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " could not load Default Template ").concat(i, " in the options array."), tmpDefaultTemplate);
+            } else {
+              if (!tmpDefaultTemplate.Source) {
+                tmpDefaultTemplate.Source = "PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " options object.");
+              }
+              this.pict.TemplateProvider.addDefaultTemplate(tmpDefaultTemplate.Prefix, tmpDefaultTemplate.Postfix, tmpDefaultTemplate.Template, tmpDefaultTemplate.Source);
+            }
+          }
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                        Code Section: Initialization                        */
+        /* -------------------------------------------------------------------------- */
+        onBeforeInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " onBeforeInitialize:"));
+          }
+          return true;
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after pre-pinitialization.
+         *
+         * @return {void}
+         */
+        onBeforeInitializeAsync(fCallback) {
+          this.onBeforeInitialize();
+          return fCallback();
+        }
+        onInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " onInitialize:"));
+          }
+          return true;
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after initialization.
+         *
+         * @return {void}
+         */
+        onInitializeAsync(fCallback) {
+          this.onInitialize();
+          return fCallback();
+        }
+        initialize() {
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow PROVIDER [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " initialize:"));
+          }
+          if (!this.initializeTimestamp) {
+            this.onBeforeInitialize();
+            this.onInitialize();
+            this.onAfterInitialize();
+            this.initializeTimestamp = this.pict.log.getTimeStamp();
+            return true;
+          } else {
+            this.log.warn("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " initialize called but initialization is already completed.  Aborting."));
+            return false;
+          }
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after initialization.
+         *
+         * @return {void}
+         */
+        initializeAsync(fCallback) {
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow PROVIDER [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " initializeAsync:"));
+          }
+          if (!this.initializeTimestamp) {
+            let tmpAnticipate = this.pict.instantiateServiceProviderWithoutRegistration('Anticipate');
+            if (this.pict.LogNoisiness > 0) {
+              this.log.info("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " beginning initialization..."));
+            }
+            tmpAnticipate.anticipate(this.onBeforeInitializeAsync.bind(this));
+            tmpAnticipate.anticipate(this.onInitializeAsync.bind(this));
+            tmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));
+            tmpAnticipate.wait(pError => {
+              this.initializeTimestamp = this.pict.log.getTimeStamp();
+              if (pError) {
+                this.log.error("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " initialization failed: ").concat(pError.message || pError), {
+                  Stack: pError.stack
+                });
+              } else if (this.pict.LogNoisiness > 0) {
+                this.log.info("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " initialization complete."));
+              }
+              return fCallback();
+            });
+          } else {
+            this.log.warn("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " async initialize called but initialization is already completed.  Aborting."));
+            // TODO: Should this be an error?
+            return fCallback();
+          }
+        }
+        onAfterInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " onAfterInitialize:"));
+          }
+          return true;
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after initialization.
+         *
+         * @return {void}
+         */
+        onAfterInitializeAsync(fCallback) {
+          this.onAfterInitialize();
+          return fCallback();
+        }
+        onPreRender() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " onPreRender:"));
+          }
+          return true;
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after pre-render.
+         *
+         * @return {void}
+         */
+        onPreRenderAsync(fCallback) {
+          this.onPreRender();
+          return fCallback();
+        }
+        render() {
+          return this.onPreRender();
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after render.
+         *
+         * @return {void}
+         */
+        renderAsync(fCallback) {
+          this.onPreRender();
+          return fCallback();
+        }
+        onPreSolve() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " onPreSolve:"));
+          }
+          return true;
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after pre-solve.
+         *
+         * @return {void}
+         */
+        onPreSolveAsync(fCallback) {
+          this.onPreSolve();
+          return fCallback();
+        }
+        solve() {
+          return this.onPreSolve();
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after solve.
+         *
+         * @return {void}
+         */
+        solveAsync(fCallback) {
+          this.onPreSolve();
+          return fCallback();
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after the data pre-load.
+         */
+        onBeforeLoadDataAsync(fCallback) {
+          return fCallback();
+        }
+
+        /**
+         * Hook to allow the provider to load data during application data load.
+         *
+         * @param {(pError?: Error) => void} fCallback - The callback to call after the data load.
+         */
+        onLoadDataAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " onLoadDataAsync:"));
+          }
+          return fCallback();
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after the data post-load.
+         */
+        onAfterLoadDataAsync(fCallback) {
+          return fCallback();
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after the data pre-load.
+         *
+         * @return {void}
+         */
+        onBeforeSaveDataAsync(fCallback) {
+          return fCallback();
+        }
+
+        /**
+         * Hook to allow the provider to load data during application data load.
+         *
+         * @param {(pError?: Error) => void} fCallback - The callback to call after the data load.
+         *
+         * @return {void}
+         */
+        onSaveDataAsync(fCallback) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictProvider [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ProviderIdentifier, " onSaveDataAsync:"));
+          }
+          return fCallback();
+        }
+
+        /**
+         * @param {(pError?: Error) => void} fCallback - The callback to call after the data post-load.
+         *
+         * @return {void}
+         */
+        onAfterSaveDataAsync(fCallback) {
+          return fCallback();
+        }
+      }
+      module.exports = PictProvider;
+    }, {
+      "../package.json": 5,
+      "fable-serviceproviderbase": 2
+    }],
+    7: [function (require, module, exports) {
+      module.exports = {
+        "name": "pict-view",
+        "version": "1.0.64",
+        "description": "Pict View Base Class",
+        "main": "source/Pict-View.js",
+        "scripts": {
+          "test": "mocha -u tdd -R spec",
+          "tests": "mocha -u tdd -R spec -g",
+          "start": "node source/Pict-View.js",
+          "coverage": "nyc --reporter=lcov --reporter=text-lcov npm test",
+          "build": "npx quack build",
+          "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t pict-view-image:local",
+          "docker-dev-run": "docker run -it -d --name pict-view-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/pict-view\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" pict-view-image:local",
+          "docker-dev-shell": "docker exec -it pict-view-dev /bin/bash",
+          "types": "tsc -p .",
+          "lint": "eslint source/**"
+        },
+        "types": "types/source/Pict-View.d.ts",
+        "repository": {
+          "type": "git",
+          "url": "git+https://github.com/stevenvelozo/pict-view.git"
+        },
+        "author": "steven velozo <steven@velozo.com>",
+        "license": "MIT",
+        "bugs": {
+          "url": "https://github.com/stevenvelozo/pict-view/issues"
+        },
+        "homepage": "https://github.com/stevenvelozo/pict-view#readme",
+        "devDependencies": {
+          "@eslint/js": "^9.39.1",
+          "browser-env": "^3.3.0",
+          "eslint": "^9.39.1",
+          "pict": "^1.0.337",
+          "quackage": "^1.0.45",
+          "typescript": "^5.9.3"
+        },
+        "mocha": {
+          "diff": true,
+          "extension": ["js"],
+          "package": "./package.json",
+          "reporter": "spec",
+          "slow": "75",
+          "timeout": "5000",
+          "ui": "tdd",
+          "watch-files": ["source/**/*.js", "test/**/*.js"],
+          "watch-ignore": ["lib/vendor"]
+        },
+        "dependencies": {
+          "fable": "^3.1.46",
+          "fable-serviceproviderbase": "^3.0.15"
+        }
+      };
+    }, {}],
+    8: [function (require, module, exports) {
+      const libFableServiceBase = require('fable-serviceproviderbase');
+      const libPackage = require('../package.json');
+      const defaultPictViewSettings = {
+        DefaultRenderable: false,
+        DefaultDestinationAddress: false,
+        DefaultTemplateRecordAddress: false,
+        ViewIdentifier: false,
+        // If this is set to true, when the App initializes this will.
+        // After the App initializes, initialize will be called as soon as it's added.
+        AutoInitialize: true,
+        AutoInitializeOrdinal: 0,
+        // If this is set to true, when the App autorenders (on load) this will.
+        // After the App initializes, render will be called as soon as it's added.
+        AutoRender: true,
+        AutoRenderOrdinal: 0,
+        AutoSolveWithApp: true,
+        AutoSolveOrdinal: 0,
+        CSSHash: false,
+        CSS: false,
+        CSSProvider: false,
+        CSSPriority: 500,
+        Templates: [],
+        DefaultTemplates: [],
+        Renderables: [],
+        Manifests: {}
+      };
+
+      /** @typedef {(error?: Error) => void} ErrorCallback */
+      /** @typedef {number | boolean} PictTimestamp */
+
+      /**
+       * @typedef {'replace' | 'append' | 'prepend' | 'append_once' | 'virtual-assignment'} RenderMethod
+       */
+      /**
+       * @typedef {Object} Renderable
+       *
+       * @property {string} RenderableHash - A unique hash for the renderable.
+       * @property {string} TemplateHash - The hash of the template to use for rendering this renderable.
+       * @property {string} [DefaultTemplateRecordAddress] - The default address for resolving the data record for this renderable.
+       * @property {string} [ContentDestinationAddress] - The default address (DOM CSS selector) for rendering the content of this renderable.
+       * @property {RenderMethod} [RenderMethod=replace] - The method to use when projecting the renderable to the DOM ('replace', 'append', 'prepend', 'append_once', 'virtual-assignment').
+       * @property {string} [TestAddress] - The address to use for testing the renderable.
+       * @property {string} [TransactionHash] - The transaction hash for the root renderable.
+       * @property {string} [RootRenderableViewHash] - The hash of the root renderable.
+       * @property {string} [Content] - The rendered content for this renderable, if applicable.
+       */
+
+      /**
+       * Represents a view in the Pict ecosystem.
+       */
+      class PictView extends libFableServiceBase {
+        /**
+         * @param {any} pFable - The Fable object that this service is attached to.
+         * @param {any} [pOptions] - (optional) The options for this service.
+         * @param {string} [pServiceHash] - (optional) The hash of the service.
+         */
+        constructor(pFable, pOptions, pServiceHash) {
+          // Intersect default options, parent constructor, service information
+          let tmpOptions = Object.assign({}, JSON.parse(JSON.stringify(defaultPictViewSettings)), pOptions);
+          super(pFable, tmpOptions, pServiceHash);
+          //FIXME: add types to fable and ancillaries
+          /** @type {any} */
+          this.fable;
+          /** @type {any} */
+          this.options;
+          /** @type {String} */
+          this.UUID;
+          /** @type {String} */
+          this.Hash;
+          /** @type {any} */
+          this.log;
+          const tmpHashIsUUID = this.Hash === this.UUID;
+          //NOTE: since many places are using the view UUID as the HTML element ID, we prefix it to avoid starting with a number
+          this.UUID = "V-".concat(this.UUID);
+          if (tmpHashIsUUID) {
+            this.Hash = this.UUID;
+          }
+          if (!this.options.ViewIdentifier) {
+            this.options.ViewIdentifier = "AutoViewID-".concat(this.fable.getUUID());
+          }
+          this.serviceType = 'PictView';
+          /** @type {Record<string, any>} */
+          this._Package = libPackage;
+          // Convenience and consistency naming
+          /** @type {import('pict') & { log: any, instantiateServiceProviderWithoutRegistration: (hash: String) => any, instantiateServiceProviderIfNotExists: (hash: string) => any, TransactionTracking: import('pict/types/source/services/Fable-Service-TransactionTracking') }} */
+          this.pict = this.fable;
+          // Wire in the essential Pict application state
+          this.AppData = this.pict.AppData;
+          this.Bundle = this.pict.Bundle;
+
+          /** @type {PictTimestamp} */
+          this.initializeTimestamp = false;
+          /** @type {PictTimestamp} */
+          this.lastSolvedTimestamp = false;
+          /** @type {PictTimestamp} */
+          this.lastRenderedTimestamp = false;
+          /** @type {PictTimestamp} */
+          this.lastMarshalFromViewTimestamp = false;
+          /** @type {PictTimestamp} */
+          this.lastMarshalToViewTimestamp = false;
+          this.pict.instantiateServiceProviderIfNotExists('TransactionTracking');
+
+          // Load all templates from the array in the options
+          // Templates are in the form of {Hash:'Some-Template-Hash',Template:'Template content',Source:'TemplateSource'}
+          for (let i = 0; i < this.options.Templates.length; i++) {
+            let tmpTemplate = this.options.Templates[i];
+            if (!('Hash' in tmpTemplate) || !('Template' in tmpTemplate)) {
+              this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not load Template ").concat(i, " in the options array."), tmpTemplate);
+            } else {
+              if (!tmpTemplate.Source) {
+                tmpTemplate.Source = "PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " options object.");
+              }
+              this.pict.TemplateProvider.addTemplate(tmpTemplate.Hash, tmpTemplate.Template, tmpTemplate.Source);
+            }
+          }
+
+          // Load all default templates from the array in the options
+          // Templates are in the form of {Prefix:'',Postfix:'-List-Row',Template:'Template content',Source:'TemplateSourceString'}
+          for (let i = 0; i < this.options.DefaultTemplates.length; i++) {
+            let tmpDefaultTemplate = this.options.DefaultTemplates[i];
+            if (!('Postfix' in tmpDefaultTemplate) || !('Template' in tmpDefaultTemplate)) {
+              this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not load Default Template ").concat(i, " in the options array."), tmpDefaultTemplate);
+            } else {
+              if (!tmpDefaultTemplate.Source) {
+                tmpDefaultTemplate.Source = "PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " options object.");
+              }
+              this.pict.TemplateProvider.addDefaultTemplate(tmpDefaultTemplate.Prefix, tmpDefaultTemplate.Postfix, tmpDefaultTemplate.Template, tmpDefaultTemplate.Source);
+            }
+          }
+
+          // Load the CSS if it's available
+          if (this.options.CSS) {
+            let tmpCSSHash = this.options.CSSHash ? this.options.CSSHash : "View-".concat(this.options.ViewIdentifier);
+            let tmpCSSProvider = this.options.CSSProvider ? this.options.CSSProvider : tmpCSSHash;
+            this.pict.CSSMap.addCSS(tmpCSSHash, this.options.CSS, tmpCSSProvider, this.options.CSSPriority);
+          }
+
+          // Load all renderables
+          // Renderables are launchable renderable instructions with templates
+          // They look as such: {Identifier:'ContentEntry', TemplateHash:'Content-Entry-Section-Main', ContentDestinationAddress:'#ContentSection', RecordAddress:'AppData.Content.DefaultText', ManifestTransformation:'ManyfestHash', ManifestDestinationAddress:'AppData.Content.DataToTransformContent'}
+          // The only parts that are necessary are Identifier and Template
+          // A developer can then do render('ContentEntry') and it just kinda works.  Or they can override the ContentDestinationAddress
+          /** @type {Record<String, Renderable>} */
+          this.renderables = {};
+          for (let i = 0; i < this.options.Renderables.length; i++) {
+            /** @type {Renderable} */
+            let tmpRenderable = this.options.Renderables[i];
+            this.addRenderable(tmpRenderable);
+          }
+        }
+
+        /**
+         * Adds a renderable to the view.
+         *
+         * @param {string | Renderable} pRenderableHash - The hash of the renderable, or a renderable object.
+         * @param {string} [pTemplateHash] - (optional) The hash of the template for the renderable.
+         * @param {string} [pDefaultTemplateRecordAddress] - (optional) The default data address for the template.
+         * @param {string} [pDefaultDestinationAddress] - (optional) The default destination address for the renderable.
+         * @param {RenderMethod} [pRenderMethod=replace] - (optional) The method to use when rendering the renderable (ex. 'replace').
+         */
+        addRenderable(pRenderableHash, pTemplateHash, pDefaultTemplateRecordAddress, pDefaultDestinationAddress, pRenderMethod) {
+          /** @type {Renderable} */
+          let tmpRenderable;
+          if (typeof pRenderableHash == 'object') {
+            // The developer passed in the renderable as an object.
+            // Use theirs instead!
+            tmpRenderable = pRenderableHash;
+          } else {
+            /** @type {RenderMethod} */
+            let tmpRenderMethod = typeof pRenderMethod !== 'string' ? pRenderMethod : 'replace';
+            tmpRenderable = {
+              RenderableHash: pRenderableHash,
+              TemplateHash: pTemplateHash,
+              DefaultTemplateRecordAddress: pDefaultTemplateRecordAddress,
+              ContentDestinationAddress: pDefaultDestinationAddress,
+              RenderMethod: tmpRenderMethod
+            };
+          }
+          if (typeof tmpRenderable.RenderableHash != 'string' || typeof tmpRenderable.TemplateHash != 'string') {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not load Renderable; RenderableHash or TemplateHash are invalid."), tmpRenderable);
+          } else {
+            if (this.pict.LogNoisiness > 0) {
+              this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " adding renderable [").concat(tmpRenderable.RenderableHash, "] pointed to template ").concat(tmpRenderable.TemplateHash, "."));
+            }
+            this.renderables[tmpRenderable.RenderableHash] = tmpRenderable;
+          }
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                        Code Section: Initialization                        */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * Lifecycle hook that triggers before the view is initialized.
+         */
+        onBeforeInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onBeforeInitialize:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers before the view is initialized (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onBeforeInitializeAsync(fCallback) {
+          this.onBeforeInitialize();
+          return fCallback();
+        }
+
+        /**
+         * Lifecycle hook that triggers when the view is initialized.
+         */
+        onInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onInitialize:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers when the view is initialized (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onInitializeAsync(fCallback) {
+          this.onInitialize();
+          return fCallback();
+        }
+
+        /**
+         * Performs view initialization.
+         */
+        initialize() {
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow VIEW [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " initialize:"));
+          }
+          if (!this.initializeTimestamp) {
+            this.onBeforeInitialize();
+            this.onInitialize();
+            this.onAfterInitialize();
+            this.initializeTimestamp = this.pict.log.getTimeStamp();
+            return true;
+          } else {
+            this.log.warn("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " initialize called but initialization is already completed.  Aborting."));
+            return false;
+          }
+        }
+
+        /**
+         * Performs view initialization (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        initializeAsync(fCallback) {
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow VIEW [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " initializeAsync:"));
+          }
+          if (!this.initializeTimestamp) {
+            let tmpAnticipate = this.pict.instantiateServiceProviderWithoutRegistration('Anticipate');
+            if (this.pict.LogNoisiness > 0) {
+              this.log.info("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " beginning initialization..."));
+            }
+            tmpAnticipate.anticipate(this.onBeforeInitializeAsync.bind(this));
+            tmpAnticipate.anticipate(this.onInitializeAsync.bind(this));
+            tmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));
+            tmpAnticipate.wait(/** @param {Error} pError */
+            pError => {
+              if (pError) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " initialization failed: ").concat(pError.message || pError), {
+                  stack: pError.stack
+                });
+              }
+              this.initializeTimestamp = this.pict.log.getTimeStamp();
+              if (this.pict.LogNoisiness > 0) {
+                this.log.info("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " initialization complete."));
+              }
+              return fCallback();
+            });
+          } else {
+            this.log.warn("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " async initialize called but initialization is already completed.  Aborting."));
+            // TODO: Should this be an error?
+            return fCallback();
+          }
+        }
+        onAfterInitialize() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onAfterInitialize:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers after the view is initialized (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onAfterInitializeAsync(fCallback) {
+          this.onAfterInitialize();
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                            Code Section: Render                            */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * Lifecycle hook that triggers before the view is rendered.
+         *
+         * @param {Renderable} pRenderable - The renderable that will be rendered.
+         */
+        onBeforeRender(pRenderable) {
+          // Overload this to mess with stuff before the content gets generated from the template
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onBeforeRender:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers before the view is rendered (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         * @param {Renderable} pRenderable - The renderable that will be rendered.
+         */
+        onBeforeRenderAsync(fCallback, pRenderable) {
+          this.onBeforeRender(pRenderable);
+          return fCallback();
+        }
+
+        /**
+         * Lifecycle hook that triggers before the view is projected into the DOM.
+         *
+         * @param {Renderable} pRenderable - The renderable that will be projected.
+         */
+        onBeforeProject(pRenderable) {
+          // Overload this to mess with stuff before the content gets generated from the template
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onBeforeProject:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers before the view is projected into the DOM (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         * @param {Renderable} pRenderable - The renderable that will be projected.
+         */
+        onBeforeProjectAsync(fCallback, pRenderable) {
+          this.onBeforeProject(pRenderable);
+          return fCallback();
+        }
+
+        /**
+         * Builds the render options for a renderable.
+         *
+         * For DRY purposes on the three flavors of render.
+         *
+         * @param {string|ErrorCallback} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string|ErrorCallback} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|object|ErrorCallback} [pTemplateRecordAddress] - The address of (or actual obejct) where the data for the template is stored.
+         */
+        buildRenderOptions(pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress) {
+          let tmpRenderOptions = {
+            Valid: true
+          };
+          tmpRenderOptions.RenderableHash = typeof pRenderableHash === 'string' ? pRenderableHash : typeof this.options.DefaultRenderable == 'string' ? this.options.DefaultRenderable : false;
+          if (!tmpRenderOptions.RenderableHash) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not find a suitable RenderableHash ").concat(tmpRenderOptions.RenderableHash, " (param ").concat(pRenderableHash, "because it is not a valid renderable."));
+            tmpRenderOptions.Valid = false;
+          }
+          tmpRenderOptions.Renderable = this.renderables[tmpRenderOptions.RenderableHash];
+          if (!tmpRenderOptions.Renderable) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render ").concat(tmpRenderOptions.RenderableHash, " (param ").concat(pRenderableHash, ") because it does not exist."));
+            tmpRenderOptions.Valid = false;
+          }
+          tmpRenderOptions.DestinationAddress = typeof pRenderDestinationAddress === 'string' ? pRenderDestinationAddress : typeof tmpRenderOptions.Renderable.ContentDestinationAddress === 'string' ? tmpRenderOptions.Renderable.ContentDestinationAddress : typeof this.options.DefaultDestinationAddress === 'string' ? this.options.DefaultDestinationAddress : false;
+          if (!tmpRenderOptions.DestinationAddress) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render ").concat(tmpRenderOptions.RenderableHash, " (param ").concat(pRenderableHash, ") because it does not have a valid destination address (param ").concat(pRenderDestinationAddress, ")."));
+            tmpRenderOptions.Valid = false;
+          }
+          if (typeof pTemplateRecordAddress === 'object') {
+            tmpRenderOptions.RecordAddress = 'Passed in as object';
+            tmpRenderOptions.Record = pTemplateRecordAddress;
+          } else {
+            tmpRenderOptions.RecordAddress = typeof pTemplateRecordAddress === 'string' ? pTemplateRecordAddress : typeof tmpRenderOptions.Renderable.DefaultTemplateRecordAddress === 'string' ? tmpRenderOptions.Renderable.DefaultTemplateRecordAddress : typeof this.options.DefaultTemplateRecordAddress === 'string' ? this.options.DefaultTemplateRecordAddress : false;
+            tmpRenderOptions.Record = typeof tmpRenderOptions.RecordAddress === 'string' ? this.pict.DataProvider.getDataByAddress(tmpRenderOptions.RecordAddress) : undefined;
+          }
+          return tmpRenderOptions;
+        }
+
+        /**
+         * Assigns the content to the destination address.
+         *
+         * For DRY purposes on the three flavors of render.
+         *
+         * @param {Renderable} pRenderable - The renderable to render.
+         * @param {string} pRenderDestinationAddress - The address where the renderable will be rendered.
+         * @param {string} pContent - The content to render.
+         * @returns {boolean} - Returns true if the content was assigned successfully.
+         * @memberof PictView
+         */
+        assignRenderContent(pRenderable, pRenderDestinationAddress, pContent) {
+          return this.pict.ContentAssignment.projectContent(pRenderable.RenderMethod, pRenderDestinationAddress, pContent, pRenderable.TestAddress);
+        }
+
+        /**
+         * Render a renderable from this view.
+         *
+         * @param {string} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|object} [pTemplateRecordAddress] - The address where the data for the template is stored.
+         * @param {Renderable} [pRootRenderable] - The root renderable for the render operation, if applicable.
+         * @return {boolean}
+         */
+        render(pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, pRootRenderable) {
+          return this.renderWithScope(this, pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, pRootRenderable);
+        }
+
+        /**
+         * Render a renderable from this view, providing a specifici scope for the template.
+         *
+         * @param {any} pScope - The scope to use for the template rendering.
+         * @param {string} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|object} [pTemplateRecordAddress] - The address where the data for the template is stored.
+         * @param {Renderable} [pRootRenderable] - The root renderable for the render operation, if applicable.
+         * @return {boolean}
+         */
+        renderWithScope(pScope, pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, pRootRenderable) {
+          let tmpRenderableHash = typeof pRenderableHash === 'string' ? pRenderableHash : typeof this.options.DefaultRenderable == 'string' ? this.options.DefaultRenderable : false;
+          if (!tmpRenderableHash) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, ") because it is not a valid renderable."));
+            return false;
+          }
+
+          /** @type {Renderable} */
+          let tmpRenderable;
+          if (tmpRenderableHash == '__Virtual') {
+            tmpRenderable = {
+              RenderableHash: '__Virtual',
+              TemplateHash: this.renderables[this.options.DefaultRenderable].TemplateHash,
+              ContentDestinationAddress: typeof pRenderDestinationAddress === 'string' ? pRenderDestinationAddress : typeof tmpRenderable.ContentDestinationAddress === 'string' ? tmpRenderable.ContentDestinationAddress : typeof this.options.DefaultDestinationAddress === 'string' ? this.options.DefaultDestinationAddress : null,
+              RenderMethod: 'virtual-assignment',
+              TransactionHash: pRootRenderable && pRootRenderable.TransactionHash,
+              RootRenderableViewHash: pRootRenderable && pRootRenderable.RootRenderableViewHash
+            };
+          } else {
+            tmpRenderable = Object.assign({}, this.renderables[tmpRenderableHash]);
+            tmpRenderable.ContentDestinationAddress = typeof pRenderDestinationAddress === 'string' ? pRenderDestinationAddress : typeof tmpRenderable.ContentDestinationAddress === 'string' ? tmpRenderable.ContentDestinationAddress : typeof this.options.DefaultDestinationAddress === 'string' ? this.options.DefaultDestinationAddress : null;
+          }
+          if (!tmpRenderable.TransactionHash) {
+            tmpRenderable.TransactionHash = "ViewRender-V-".concat(this.options.ViewIdentifier, "-R-").concat(tmpRenderableHash, "-U-").concat(this.pict.getUUID());
+            tmpRenderable.RootRenderableViewHash = this.Hash;
+            this.pict.TransactionTracking.registerTransaction(tmpRenderable.TransactionHash);
+          }
+          if (!tmpRenderable) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, ") because it does not exist."));
+            return false;
+          }
+          if (!tmpRenderable.ContentDestinationAddress) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, ") because it does not have a valid destination address."));
+            return false;
+          }
+          let tmpRecordAddress;
+          let tmpRecord;
+          if (typeof pTemplateRecordAddress === 'object') {
+            tmpRecord = pTemplateRecordAddress;
+            tmpRecordAddress = 'Passed in as object';
+          } else {
+            tmpRecordAddress = typeof pTemplateRecordAddress === 'string' ? pTemplateRecordAddress : typeof tmpRenderable.DefaultTemplateRecordAddress === 'string' ? tmpRenderable.DefaultTemplateRecordAddress : typeof this.options.DefaultTemplateRecordAddress === 'string' ? this.options.DefaultTemplateRecordAddress : false;
+            tmpRecord = typeof tmpRecordAddress === 'string' ? this.pict.DataProvider.getDataByAddress(tmpRecordAddress) : undefined;
+          }
+
+          // Execute the developer-overridable pre-render behavior
+          this.onBeforeRender(tmpRenderable);
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow VIEW [".concat(this.UUID, "]::[").concat(this.Hash, "] Renderable[").concat(tmpRenderableHash, "] Destination[").concat(tmpRenderable.ContentDestinationAddress, "] TemplateRecordAddress[").concat(tmpRecordAddress, "] render:"));
+          }
+          if (this.pict.LogNoisiness > 0) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " Beginning Render of Renderable[").concat(tmpRenderableHash, "] to Destination [").concat(tmpRenderable.ContentDestinationAddress, "]..."));
+          }
+          // Generate the content output from the template and data
+          tmpRenderable.Content = this.pict.parseTemplateByHash(tmpRenderable.TemplateHash, tmpRecord, null, [this], pScope, {
+            RootRenderable: typeof pRootRenderable === 'object' ? pRootRenderable : tmpRenderable
+          });
+          if (this.pict.LogNoisiness > 0) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " Assigning Renderable[").concat(tmpRenderableHash, "] content length ").concat(tmpRenderable.Content.length, " to Destination [").concat(tmpRenderable.ContentDestinationAddress, "] using render method [").concat(tmpRenderable.RenderMethod, "]."));
+          }
+          this.onBeforeProject(tmpRenderable);
+          this.onProject(tmpRenderable);
+          if (tmpRenderable.RenderMethod !== 'virtual-assignment') {
+            this.onAfterProject(tmpRenderable);
+
+            // Execute the developer-overridable post-render behavior
+            this.onAfterRender(tmpRenderable);
+          }
+          return true;
+        }
+
+        /**
+         * Render a renderable from this view.
+         *
+         * @param {string|ErrorCallback} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string|ErrorCallback} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|object|ErrorCallback} [pTemplateRecordAddress] - The address where the data for the template is stored.
+         * @param {Renderable|ErrorCallback} [pRootRenderable] - The root renderable for the render operation, if applicable.
+         * @param {ErrorCallback} [fCallback] - The callback to call when the async operation is complete.
+         *
+         * @return {void}
+         */
+        renderAsync(pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, pRootRenderable, fCallback) {
+          return this.renderWithScopeAsync(this, pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, pRootRenderable, fCallback);
+        }
+
+        /**
+         * Render a renderable from this view.
+         *
+         * @param {any} pScope - The scope to use for the template rendering.
+         * @param {string|ErrorCallback} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string|ErrorCallback} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|object|ErrorCallback} [pTemplateRecordAddress] - The address where the data for the template is stored.
+         * @param {Renderable|ErrorCallback} [pRootRenderable] - The root renderable for the render operation, if applicable.
+         * @param {ErrorCallback} [fCallback] - The callback to call when the async operation is complete.
+         *
+         * @return {void}
+         */
+        renderWithScopeAsync(pScope, pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, pRootRenderable, fCallback) {
+          let tmpRenderableHash = typeof pRenderableHash === 'string' ? pRenderableHash : typeof this.options.DefaultRenderable == 'string' ? this.options.DefaultRenderable : false;
+
+          // Allow the callback to be passed in as the last parameter no matter what
+          /** @type {ErrorCallback} */
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : typeof pTemplateRecordAddress === 'function' ? pTemplateRecordAddress : typeof pRenderDestinationAddress === 'function' ? pRenderDestinationAddress : typeof pRenderableHash === 'function' ? pRenderableHash : typeof pRootRenderable === 'function' ? pRootRenderable : null;
+          if (!tmpCallback) {
+            this.log.warn("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " renderAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          if (!tmpRenderableHash) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not asynchronously render ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, "because it is not a valid renderable."));
+            return tmpCallback(new Error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not asynchronously render ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, "because it is not a valid renderable.")));
+          }
+
+          /** @type {Renderable} */
+          let tmpRenderable;
+          if (tmpRenderableHash == '__Virtual') {
+            tmpRenderable = {
+              RenderableHash: '__Virtual',
+              TemplateHash: this.renderables[this.options.DefaultRenderable].TemplateHash,
+              ContentDestinationAddress: typeof pRenderDestinationAddress === 'string' ? pRenderDestinationAddress : typeof this.options.DefaultDestinationAddress === 'string' ? this.options.DefaultDestinationAddress : null,
+              RenderMethod: 'virtual-assignment',
+              TransactionHash: pRootRenderable && typeof pRootRenderable !== 'function' && pRootRenderable.TransactionHash,
+              RootRenderableViewHash: pRootRenderable && typeof pRootRenderable !== 'function' && pRootRenderable.RootRenderableViewHash
+            };
+          } else {
+            tmpRenderable = Object.assign({}, this.renderables[tmpRenderableHash]);
+            tmpRenderable.ContentDestinationAddress = typeof pRenderDestinationAddress === 'string' ? pRenderDestinationAddress : typeof tmpRenderable.ContentDestinationAddress === 'string' ? tmpRenderable.ContentDestinationAddress : typeof this.options.DefaultDestinationAddress === 'string' ? this.options.DefaultDestinationAddress : null;
+          }
+          if (!tmpRenderable.TransactionHash) {
+            tmpRenderable.TransactionHash = "ViewRender-V-".concat(this.options.ViewIdentifier, "-R-").concat(tmpRenderableHash, "-U-").concat(this.pict.getUUID());
+            tmpRenderable.RootRenderableViewHash = this.Hash;
+            this.pict.TransactionTracking.registerTransaction(tmpRenderable.TransactionHash);
+          }
+          if (!tmpRenderable) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, ") because it does not exist."));
+            return tmpCallback(new Error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, ") because it does not exist.")));
+          }
+          if (!tmpRenderable.ContentDestinationAddress) {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, ") because it does not have a valid destination address."));
+            return tmpCallback(new Error("Could not render ".concat(tmpRenderableHash)));
+          }
+          let tmpRecordAddress;
+          let tmpRecord;
+          if (typeof pTemplateRecordAddress === 'object') {
+            tmpRecord = pTemplateRecordAddress;
+            tmpRecordAddress = 'Passed in as object';
+          } else {
+            tmpRecordAddress = typeof pTemplateRecordAddress === 'string' ? pTemplateRecordAddress : typeof tmpRenderable.DefaultTemplateRecordAddress === 'string' ? tmpRenderable.DefaultTemplateRecordAddress : typeof this.options.DefaultTemplateRecordAddress === 'string' ? this.options.DefaultTemplateRecordAddress : false;
+            tmpRecord = typeof tmpRecordAddress === 'string' ? this.pict.DataProvider.getDataByAddress(tmpRecordAddress) : undefined;
+          }
+          if (this.pict.LogControlFlow) {
+            this.log.trace("PICT-ControlFlow VIEW [".concat(this.UUID, "]::[").concat(this.Hash, "] Renderable[").concat(tmpRenderableHash, "] Destination[").concat(tmpRenderable.ContentDestinationAddress, "] TemplateRecordAddress[").concat(tmpRecordAddress, "] renderAsync:"));
+          }
+          if (this.pict.LogNoisiness > 2) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " Beginning Asynchronous Render (callback-style)..."));
+          }
+          let tmpAnticipate = this.fable.newAnticipate();
+          tmpAnticipate.anticipate(fOnBeforeRenderCallback => {
+            this.onBeforeRenderAsync(fOnBeforeRenderCallback, tmpRenderable);
+          });
+          tmpAnticipate.anticipate(fAsyncTemplateCallback => {
+            // Render the template (asynchronously)
+            this.pict.parseTemplateByHash(tmpRenderable.TemplateHash, tmpRecord, (pError, pContent) => {
+              if (pError) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render (asynchronously) ").concat(tmpRenderableHash, " (param ").concat(pRenderableHash, ") because it did not parse the template."), pError);
+                return fAsyncTemplateCallback(pError);
+              }
+              tmpRenderable.Content = pContent;
+              return fAsyncTemplateCallback();
+            }, [this], pScope, {
+              RootRenderable: typeof pRootRenderable === 'object' ? pRootRenderable : tmpRenderable
+            });
+          });
+          tmpAnticipate.anticipate(fNext => {
+            this.onBeforeProjectAsync(fNext, tmpRenderable);
+          });
+          tmpAnticipate.anticipate(fNext => {
+            this.onProjectAsync(fNext, tmpRenderable);
+          });
+          if (tmpRenderable.RenderMethod !== 'virtual-assignment') {
+            tmpAnticipate.anticipate(fNext => {
+              this.onAfterProjectAsync(fNext, tmpRenderable);
+            });
+
+            // Execute the developer-overridable post-render behavior
+            tmpAnticipate.anticipate(fNext => {
+              this.onAfterRenderAsync(fNext, tmpRenderable);
+            });
+          }
+          tmpAnticipate.wait(tmpCallback);
+        }
+
+        /**
+         * Renders the default renderable.
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        renderDefaultAsync(fCallback) {
+          // Render the default renderable
+          this.renderAsync(fCallback);
+        }
+
+        /**
+         * @param {string} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|object} [pTemplateRecordAddress] - The address of (or actual obejct) where the data for the template is stored.
+         */
+        basicRender(pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress) {
+          return this.basicRenderWithScope(this, pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress);
+        }
+
+        /**
+         * @param {any} pScope - The scope to use for the template rendering.
+         * @param {string} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|object} [pTemplateRecordAddress] - The address of (or actual obejct) where the data for the template is stored.
+         */
+        basicRenderWithScope(pScope, pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress) {
+          let tmpRenderOptions = this.buildRenderOptions(pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress);
+          if (tmpRenderOptions.Valid) {
+            this.assignRenderContent(tmpRenderOptions.Renderable, tmpRenderOptions.DestinationAddress, this.pict.parseTemplateByHash(tmpRenderOptions.Renderable.TemplateHash, tmpRenderOptions.Record, null, [this], pScope, {
+              RootRenderable: tmpRenderOptions.Renderable
+            }));
+            return true;
+          } else {
+            this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not perform a basic render of ").concat(tmpRenderOptions.RenderableHash, " because it is not valid."));
+            return false;
+          }
+        }
+
+        /**
+         * @param {string|ErrorCallback} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string|ErrorCallback} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|Object|ErrorCallback} [pTemplateRecordAddress] - The address of (or actual obejct) where the data for the template is stored.
+         * @param {ErrorCallback} [fCallback] - The callback to call when the async operation is complete.
+         */
+        basicRenderAsync(pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, fCallback) {
+          return this.basicRenderWithScopeAsync(this, pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, fCallback);
+        }
+
+        /**
+         * @param {any} pScope - The scope to use for the template rendering.
+         * @param {string|ErrorCallback} [pRenderableHash] - The hash of the renderable to render.
+         * @param {string|ErrorCallback} [pRenderDestinationAddress] - The address where the renderable will be rendered.
+         * @param {string|Object|ErrorCallback} [pTemplateRecordAddress] - The address of (or actual obejct) where the data for the template is stored.
+         * @param {ErrorCallback} [fCallback] - The callback to call when the async operation is complete.
+         */
+        basicRenderWithScopeAsync(pScope, pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress, fCallback) {
+          // Allow the callback to be passed in as the last parameter no matter what
+          /** @type {ErrorCallback} */
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : typeof pTemplateRecordAddress === 'function' ? pTemplateRecordAddress : typeof pRenderDestinationAddress === 'function' ? pRenderDestinationAddress : typeof pRenderableHash === 'function' ? pRenderableHash : null;
+          if (!tmpCallback) {
+            this.log.warn("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " basicRenderAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " basicRenderAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          const tmpRenderOptions = this.buildRenderOptions(pRenderableHash, pRenderDestinationAddress, pTemplateRecordAddress);
+          if (tmpRenderOptions.Valid) {
+            this.pict.parseTemplateByHash(tmpRenderOptions.Renderable.TemplateHash, tmpRenderOptions.Record,
+            /**
+             * @param {Error} [pError] - The error that occurred during template parsing.
+             * @param {string} [pContent] - The content that was rendered from the template.
+             */
+            (pError, pContent) => {
+              if (pError) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not render (asynchronously) ").concat(tmpRenderOptions.RenderableHash, " because it did not parse the template."), pError);
+                return tmpCallback(pError);
+              }
+              this.assignRenderContent(tmpRenderOptions.Renderable, tmpRenderOptions.DestinationAddress, pContent);
+              return tmpCallback();
+            }, [this], pScope, {
+              RootRenderable: tmpRenderOptions.Renderable
+            });
+          } else {
+            let tmpErrorMessage = "PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " could not perform a basic render of ").concat(tmpRenderOptions.RenderableHash, " because it is not valid.");
+            this.log.error(tmpErrorMessage);
+            return tmpCallback(new Error(tmpErrorMessage));
+          }
+        }
+
+        /**
+         * @param {Renderable} pRenderable - The renderable that was rendered.
+         */
+        onProject(pRenderable) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onProject:"));
+          }
+          if (pRenderable.RenderMethod === 'virtual-assignment') {
+            this.pict.TransactionTracking.pushToTransactionQueue(pRenderable.TransactionHash, {
+              ViewHash: this.Hash,
+              Renderable: pRenderable
+            }, 'Deferred-Post-Content-Assignment');
+          }
+          if (this.pict.LogNoisiness > 0) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " Assigning Renderable[").concat(pRenderable.RenderableHash, "] content length ").concat(pRenderable.Content.length, " to Destination [").concat(pRenderable.ContentDestinationAddress, "] using Async render method ").concat(pRenderable.RenderMethod, "."));
+          }
+
+          // Assign the content to the destination address
+          this.pict.ContentAssignment.projectContent(pRenderable.RenderMethod, pRenderable.ContentDestinationAddress, pRenderable.Content, pRenderable.TestAddress);
+          this.lastRenderedTimestamp = this.pict.log.getTimeStamp();
+        }
+
+        /**
+         * Lifecycle hook that triggers after the view is projected into the DOM (async flow).
+         *
+         * @param {(error?: Error, content?: string) => void} fCallback - The callback to call when the async operation is complete.
+         * @param {Renderable} pRenderable - The renderable that is being projected.
+         */
+        onProjectAsync(fCallback, pRenderable) {
+          this.onProject(pRenderable);
+          return fCallback();
+        }
+
+        /**
+         * Lifecycle hook that triggers after the view is rendered.
+         *
+         * @param {Renderable} pRenderable - The renderable that was rendered.
+         */
+        onAfterRender(pRenderable) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onAfterRender:"));
+          }
+          if (pRenderable && pRenderable.RootRenderableViewHash === this.Hash) {
+            const tmpTransactionQueue = this.pict.TransactionTracking.clearTransactionQueue(pRenderable.TransactionHash) || [];
+            for (const tmpEvent of tmpTransactionQueue) {
+              const tmpView = this.pict.views[tmpEvent.Data.ViewHash];
+              if (!tmpView) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onAfterRender: Could not find view for transaction hash ").concat(pRenderable.TransactionHash, " and ViewHash ").concat(tmpEvent.Data.ViewHash, "."));
+                continue;
+              }
+              tmpView.onAfterProject();
+
+              // Execute the developer-overridable post-render behavior
+              tmpView.onAfterRender(tmpEvent.Data.Renderable);
+            }
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers after the view is rendered (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         * @param {Renderable} pRenderable - The renderable that was rendered.
+         */
+        onAfterRenderAsync(fCallback, pRenderable) {
+          this.onAfterRender(pRenderable);
+          const tmpAnticipate = this.fable.newAnticipate();
+          if (pRenderable && pRenderable.RootRenderableViewHash === this.Hash) {
+            const queue = this.pict.TransactionTracking.clearTransactionQueue(pRenderable.TransactionHash) || [];
+            for (const event of queue) {
+              /** @type {PictView} */
+              const tmpView = this.pict.views[event.Data.ViewHash];
+              if (!tmpView) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onAfterRenderAsync: Could not find view for transaction hash ").concat(pRenderable.TransactionHash, " and ViewHash ").concat(event.Data.ViewHash, "."));
+                continue;
+              }
+              tmpAnticipate.anticipate(tmpView.onAfterProjectAsync.bind(tmpView));
+              tmpAnticipate.anticipate(fNext => {
+                tmpView.onAfterRenderAsync(fNext, event.Data.Renderable);
+              });
+
+              // Execute the developer-overridable post-render behavior
+            }
+          }
+          return tmpAnticipate.wait(fCallback);
+        }
+
+        /**
+         * Lifecycle hook that triggers after the view is projected into the DOM.
+         *
+         * @param {Renderable} pRenderable - The renderable that was projected.
+         */
+        onAfterProject(pRenderable) {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onAfterProject:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers after the view is projected into the DOM (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         * @param {Renderable} pRenderable - The renderable that was projected.
+         */
+        onAfterProjectAsync(fCallback, pRenderable) {
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                            Code Section: Solver                            */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * Lifecycle hook that triggers before the view is solved.
+         */
+        onBeforeSolve() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onBeforeSolve:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers before the view is solved (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onBeforeSolveAsync(fCallback) {
+          this.onBeforeSolve();
+          return fCallback();
+        }
+
+        /**
+         * Lifecycle hook that triggers when the view is solved.
+         */
+        onSolve() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onSolve:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers when the view is solved (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onSolveAsync(fCallback) {
+          this.onSolve();
+          return fCallback();
+        }
+
+        /**
+         * Performs view solving and triggers lifecycle hooks.
+         *
+         * @return {boolean} - True if the view was solved successfully, false otherwise.
+         */
+        solve() {
+          if (this.pict.LogNoisiness > 2) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " executing solve() function..."));
+          }
+          this.onBeforeSolve();
+          this.onSolve();
+          this.onAfterSolve();
+          this.lastSolvedTimestamp = this.pict.log.getTimeStamp();
+          return true;
+        }
+
+        /**
+         * Performs view solving and triggers lifecycle hooks (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        solveAsync(fCallback) {
+          let tmpAnticipate = this.pict.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+          /** @type {ErrorCallback} */
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : null;
+          if (!tmpCallback) {
+            this.log.warn("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " solveAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " solveAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          tmpAnticipate.anticipate(this.onBeforeSolveAsync.bind(this));
+          tmpAnticipate.anticipate(this.onSolveAsync.bind(this));
+          tmpAnticipate.anticipate(this.onAfterSolveAsync.bind(this));
+          tmpAnticipate.wait(pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " solveAsync() complete."));
+            }
+            this.lastSolvedTimestamp = this.pict.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * Lifecycle hook that triggers after the view is solved.
+         */
+        onAfterSolve() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onAfterSolve:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers after the view is solved (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onAfterSolveAsync(fCallback) {
+          this.onAfterSolve();
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Marshal From View                        */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * Lifecycle hook that triggers before data is marshaled from the view.
+         *
+         * @return {boolean} - True if the operation was successful, false otherwise.
+         */
+        onBeforeMarshalFromView() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onBeforeMarshalFromView:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers before data is marshaled from the view (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onBeforeMarshalFromViewAsync(fCallback) {
+          this.onBeforeMarshalFromView();
+          return fCallback();
+        }
+
+        /**
+         * Lifecycle hook that triggers when data is marshaled from the view.
+         */
+        onMarshalFromView() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onMarshalFromView:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers when data is marshaled from the view (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onMarshalFromViewAsync(fCallback) {
+          this.onMarshalFromView();
+          return fCallback();
+        }
+
+        /**
+         * Marshals data from the view.
+         *
+         * @return {boolean} - True if the operation was successful, false otherwise.
+         */
+        marshalFromView() {
+          if (this.pict.LogNoisiness > 2) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " executing solve() function..."));
+          }
+          this.onBeforeMarshalFromView();
+          this.onMarshalFromView();
+          this.onAfterMarshalFromView();
+          this.lastMarshalFromViewTimestamp = this.pict.log.getTimeStamp();
+          return true;
+        }
+
+        /**
+         * Marshals data from the view (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        marshalFromViewAsync(fCallback) {
+          let tmpAnticipate = this.pict.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+          /** @type {ErrorCallback} */
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : null;
+          if (!tmpCallback) {
+            this.log.warn("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalFromViewAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalFromViewAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          tmpAnticipate.anticipate(this.onBeforeMarshalFromViewAsync.bind(this));
+          tmpAnticipate.anticipate(this.onMarshalFromViewAsync.bind(this));
+          tmpAnticipate.anticipate(this.onAfterMarshalFromViewAsync.bind(this));
+          tmpAnticipate.wait(pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " marshalFromViewAsync() complete."));
+            }
+            this.lastMarshalFromViewTimestamp = this.pict.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * Lifecycle hook that triggers after data is marshaled from the view.
+         */
+        onAfterMarshalFromView() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onAfterMarshalFromView:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers after data is marshaled from the view (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onAfterMarshalFromViewAsync(fCallback) {
+          this.onAfterMarshalFromView();
+          return fCallback();
+        }
+
+        /* -------------------------------------------------------------------------- */
+        /*                     Code Section: Marshal To View                          */
+        /* -------------------------------------------------------------------------- */
+        /**
+         * Lifecycle hook that triggers before data is marshaled into the view.
+         */
+        onBeforeMarshalToView() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onBeforeMarshalToView:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers before data is marshaled into the view (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onBeforeMarshalToViewAsync(fCallback) {
+          this.onBeforeMarshalToView();
+          return fCallback();
+        }
+
+        /**
+         * Lifecycle hook that triggers when data is marshaled into the view.
+         */
+        onMarshalToView() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onMarshalToView:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers when data is marshaled into the view (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onMarshalToViewAsync(fCallback) {
+          this.onMarshalToView();
+          return fCallback();
+        }
+
+        /**
+         * Marshals data into the view.
+         *
+         * @return {boolean} - True if the operation was successful, false otherwise.
+         */
+        marshalToView() {
+          if (this.pict.LogNoisiness > 2) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " executing solve() function..."));
+          }
+          this.onBeforeMarshalToView();
+          this.onMarshalToView();
+          this.onAfterMarshalToView();
+          this.lastMarshalToViewTimestamp = this.pict.log.getTimeStamp();
+          return true;
+        }
+
+        /**
+         * Marshals data into the view (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        marshalToViewAsync(fCallback) {
+          let tmpAnticipate = this.pict.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+          /** @type {ErrorCallback} */
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : null;
+          if (!tmpCallback) {
+            this.log.warn("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalToViewAsync was called without a valid callback.  A callback will be generated but this could lead to race conditions."));
+            tmpCallback = pError => {
+              if (pError) {
+                this.log.error("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Name, " marshalToViewAsync Auto Callback Error: ").concat(pError), pError);
+              }
+            };
+          }
+          tmpAnticipate.anticipate(this.onBeforeMarshalToViewAsync.bind(this));
+          tmpAnticipate.anticipate(this.onMarshalToViewAsync.bind(this));
+          tmpAnticipate.anticipate(this.onAfterMarshalToViewAsync.bind(this));
+          tmpAnticipate.wait(pError => {
+            if (this.pict.LogNoisiness > 2) {
+              this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " marshalToViewAsync() complete."));
+            }
+            this.lastMarshalToViewTimestamp = this.pict.log.getTimeStamp();
+            return tmpCallback(pError);
+          });
+        }
+
+        /**
+         * Lifecycle hook that triggers after data is marshaled into the view.
+         */
+        onAfterMarshalToView() {
+          if (this.pict.LogNoisiness > 3) {
+            this.log.trace("PictView [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.ViewIdentifier, " onAfterMarshalToView:"));
+          }
+          return true;
+        }
+
+        /**
+         * Lifecycle hook that triggers after data is marshaled into the view (async flow).
+         *
+         * @param {ErrorCallback} fCallback - The callback to call when the async operation is complete.
+         */
+        onAfterMarshalToViewAsync(fCallback) {
+          this.onAfterMarshalToView();
+          return fCallback();
+        }
+
+        /** @return {boolean} - True if the object is a PictView. */
+        get isPictView() {
+          return true;
+        }
+      }
+      module.exports = PictView;
+    }, {
+      "../package.json": 7,
+      "fable-serviceproviderbase": 2
+    }],
+    9: [function (require, module, exports) {
+      module.exports = {
+        "Name": "Pict Docuserve",
+        "Hash": "Docuserve",
+        "MainViewportViewIdentifier": "Docuserve-Layout",
+        "AutoSolveAfterInitialize": true,
+        "AutoRenderMainViewportViewAfterInitialize": false,
+        "AutoRenderViewsAfterInitialize": false,
+        "pict_configuration": {
+          "Product": "Docuserve-Pict-Application"
+        }
+      };
+    }, {}],
+    10: [function (require, module, exports) {
+      const libPictApplication = require('pict-application');
+
+      // Provider
+      const libDocumentationProvider = require('./providers/Pict-Provider-Docuserve-Documentation.js');
+
+      // Views
+      const libViewLayout = require('./views/PictView-Docuserve-Layout.js');
+      const libViewTopBar = require('./views/PictView-Docuserve-TopBar.js');
+      const libViewSidebar = require('./views/PictView-Docuserve-Sidebar.js');
+      const libViewSplash = require('./views/PictView-Docuserve-Splash.js');
+      const libViewContent = require('./views/PictView-Docuserve-Content.js');
+      class DocuserveApplication extends libPictApplication {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+
+          // Add the documentation provider
+          this.pict.addProvider('Docuserve-Documentation', libDocumentationProvider.default_configuration, libDocumentationProvider);
+
+          // Add views
+          this.pict.addView('Docuserve-Layout', libViewLayout.default_configuration, libViewLayout);
+          this.pict.addView('Docuserve-TopBar', libViewTopBar.default_configuration, libViewTopBar);
+          this.pict.addView('Docuserve-Sidebar', libViewSidebar.default_configuration, libViewSidebar);
+          this.pict.addView('Docuserve-Splash', libViewSplash.default_configuration, libViewSplash);
+          this.pict.addView('Docuserve-Content', libViewContent.default_configuration, libViewContent);
+        }
+        onAfterInitializeAsync(fCallback) {
+          // Initialize application state
+          this.pict.AppData.Docuserve = {
+            CatalogLoaded: false,
+            Catalog: null,
+            CoverLoaded: false,
+            Cover: null,
+            SidebarLoaded: false,
+            SidebarGroups: [],
+            TopBarLoaded: false,
+            TopBar: null,
+            ErrorPageLoaded: false,
+            ErrorPageHTML: null,
+            CurrentGroup: '',
+            CurrentModule: '',
+            CurrentPath: '',
+            // Whether the sidebar is currently visible
+            SidebarVisible: true,
+            // Base URL for local docs (relative to where the app is served)
+            DocsBaseURL: '',
+            // URL for the catalog JSON
+            CatalogURL: 'retold-catalog.json'
+          };
+
+          // Load the catalog, then render the layout
+          let tmpDocProvider = this.pict.providers['Docuserve-Documentation'];
+          tmpDocProvider.loadCatalog(() => {
+            // Render the layout shell, which triggers child view rendering
+            this.pict.views['Docuserve-Layout'].render();
+            return super.onAfterInitializeAsync(fCallback);
+          });
+        }
+
+        /**
+         * Read the current window.location.hash and dispatch to the correct handler.
+         *
+         * Route patterns:
+         *   #/Home                         -> showView('Docuserve-Splash')
+         *   #/page/<docpath>               -> navigateToPage(docpath)
+         *   #/doc/<group>/<module>          -> navigateToModule(group, module)
+         *   #/doc/<group>/<module>/<path>   -> navigateToModulePath(group, module, path)
+         */
+        resolveHash() {
+          let tmpHash = (window.location.hash || '').replace(/^#\/?/, '');
+          if (!tmpHash || tmpHash === 'Home') {
+            this.showView('Docuserve-Splash');
+            return;
+          }
+          let tmpParts = tmpHash.split('/');
+          if (tmpParts[0] === 'page' && tmpParts.length >= 2) {
+            // Rejoin everything after 'page/' in case the path has slashes
+            let tmpDocPath = tmpParts.slice(1).join('/');
+            this.navigateToPage(tmpDocPath);
+            return;
+          }
+          if (tmpParts[0] === 'doc' && tmpParts.length >= 3) {
+            let tmpGroup = tmpParts[1];
+            let tmpModule = tmpParts[2];
+            if (tmpParts.length >= 4) {
+              let tmpPath = tmpParts.slice(3).join('/');
+              this.navigateToModulePath(tmpGroup, tmpModule, tmpPath);
+            } else {
+              this.navigateToModule(tmpGroup, tmpModule);
+            }
+            return;
+          }
+
+          // Unknown route — treat as a page
+          this.navigateToPage(tmpHash);
+        }
+
+        /**
+         * Navigate to a hash route.
+         *
+         * Sets window.location.hash, which triggers the hashchange listener in the
+         * layout view, which calls resolveHash() automatically.
+         *
+         * @param {string} pRoute - The route path (e.g. '/Home', '/page/quick-start')
+         */
+        navigateTo(pRoute) {
+          window.location.hash = pRoute;
+        }
+
+        /**
+         * Show a specific view in the content area.
+         *
+         * @param {string} pViewIdentifier - The view identifier to render
+         */
+        showView(pViewIdentifier) {
+          if (pViewIdentifier in this.pict.views) {
+            this.pict.AppData.Docuserve.CurrentGroup = '';
+            this.pict.AppData.Docuserve.CurrentModule = '';
+            this.pict.AppData.Docuserve.CurrentPath = '';
+            this.pict.views[pViewIdentifier].render();
+
+            // Update sidebar to clear module nav and refresh active states
+            this.pict.views['Docuserve-Sidebar'].clearModuleNav();
+            this.pict.views['Docuserve-Sidebar'].renderSidebarGroups();
+          }
+        }
+
+        /**
+         * Navigate to a module's documentation.
+         *
+         * @param {string} pGroup - The group key
+         * @param {string} pModule - The module name
+         */
+        navigateToModule(pGroup, pModule) {
+          this.navigateToModulePath(pGroup, pModule, 'README.md');
+        }
+
+        /**
+         * Navigate to a specific path within a module's documentation.
+         *
+         * @param {string} pGroup - The group key
+         * @param {string} pModule - The module name
+         * @param {string} pPath - The document path
+         */
+        navigateToModulePath(pGroup, pModule, pPath) {
+          let tmpDocProvider = this.pict.providers['Docuserve-Documentation'];
+          let tmpContentView = this.pict.views['Docuserve-Content'];
+          let tmpSidebarView = this.pict.views['Docuserve-Sidebar'];
+
+          // Update current navigation state
+          this.pict.AppData.Docuserve.CurrentGroup = pGroup;
+          this.pict.AppData.Docuserve.CurrentModule = pModule;
+          this.pict.AppData.Docuserve.CurrentPath = pPath;
+
+          // Render the content view shell and show loading
+          tmpContentView.render();
+          tmpContentView.showLoading();
+
+          // Update sidebar to show active module and module-specific nav
+          tmpSidebarView.renderSidebarGroups();
+          tmpSidebarView.renderModuleNav(pGroup, pModule);
+
+          // Resolve the document URL and fetch it
+          let tmpURL = tmpDocProvider.resolveDocumentURL(pGroup, pModule, pPath || 'README.md');
+          if (!tmpURL) {
+            tmpContentView.displayContent(tmpDocProvider.getErrorPageHTML(pGroup + '/' + pModule));
+            return;
+          }
+          tmpDocProvider.fetchDocument(tmpURL, (pError, pHTML) => {
+            // fetchDocument always provides displayable HTML in pHTML,
+            // even on error, so we can use it directly.
+            tmpContentView.displayContent(pHTML);
+          });
+        }
+
+        /**
+         * Navigate to a local documentation page (e.g. architecture.md).
+         *
+         * @param {string} pDocPath - The doc path without extension
+         */
+        navigateToPage(pDocPath) {
+          let tmpDocProvider = this.pict.providers['Docuserve-Documentation'];
+          let tmpContentView = this.pict.views['Docuserve-Content'];
+          let tmpSidebarView = this.pict.views['Docuserve-Sidebar'];
+
+          // Update state
+          this.pict.AppData.Docuserve.CurrentGroup = '';
+          this.pict.AppData.Docuserve.CurrentModule = '';
+          this.pict.AppData.Docuserve.CurrentPath = pDocPath;
+
+          // Render the content view shell and show loading
+          tmpContentView.render();
+          tmpContentView.showLoading();
+
+          // Clear module-specific sidebar nav
+          tmpSidebarView.clearModuleNav();
+          tmpSidebarView.renderSidebarGroups();
+
+          // Fetch the local document
+          let tmpPath = pDocPath;
+          if (!tmpPath.match(/\.md$/)) {
+            tmpPath = tmpPath + '.md';
+          }
+          tmpDocProvider.fetchLocalDocument(tmpPath, (pError, pHTML) => {
+            // fetchDocument always provides displayable HTML in pHTML,
+            // even on error, so we can use it directly.
+            tmpContentView.displayContent(pHTML);
+          });
+        }
+      }
+      module.exports = DocuserveApplication;
+      module.exports.default_configuration = require('./Pict-Application-Docuserve-Configuration.json');
+    }, {
+      "./Pict-Application-Docuserve-Configuration.json": 9,
+      "./providers/Pict-Provider-Docuserve-Documentation.js": 11,
+      "./views/PictView-Docuserve-Content.js": 12,
+      "./views/PictView-Docuserve-Layout.js": 13,
+      "./views/PictView-Docuserve-Sidebar.js": 14,
+      "./views/PictView-Docuserve-Splash.js": 15,
+      "./views/PictView-Docuserve-TopBar.js": 16,
+      "pict-application": 4
+    }],
+    11: [function (require, module, exports) {
+      const libPictProvider = require('pict-provider');
+
+      /**
+       * Documentation Provider for Docuserve
+       *
+       * Loads the Indoctrinate-generated catalog and keyword index,
+       * fetches markdown documents from local paths or raw GitHub URLs,
+       * and parses them into HTML for rendering.
+       */
+      class DocuserveDocumentationProvider extends libPictProvider {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+          this._Catalog = null;
+          this._ContentCache = {};
+        }
+
+        /**
+         * Load all documentation data sources: catalog, cover.md, _sidebar.md.
+         *
+         * Loads the catalog first (it provides the fallback data), then attempts
+         * to load cover.md and _sidebar.md in parallel.  If those markdown files
+         * exist they drive the splash and sidebar views; otherwise the catalog
+         * data is used as a fallback.
+         *
+         * @param {Function} fCallback - Callback when all loading is complete
+         */
+        loadCatalog(fCallback) {
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : () => {};
+          let tmpCatalogURL = this.pict.AppData.Docuserve.CatalogURL || 'retold-catalog.json';
+          fetch(tmpCatalogURL).then(pResponse => {
+            if (!pResponse.ok) {
+              this.log.warn("Docuserve: Could not load catalog from [".concat(tmpCatalogURL, "]."));
+              return null;
+            }
+            return pResponse.json();
+          }).then(pCatalog => {
+            if (pCatalog) {
+              this._Catalog = pCatalog;
+              this.pict.AppData.Docuserve.Catalog = pCatalog;
+              this.pict.AppData.Docuserve.CatalogLoaded = true;
+
+              // Build sidebar navigation data from the catalog as default
+              this.buildSidebarData(pCatalog);
+            }
+
+            // Now try to load cover.md, _sidebar.md, _topbar.md, and errorpage.md in parallel
+            let tmpPending = 4;
+            let tmpFinish = () => {
+              tmpPending--;
+              if (tmpPending <= 0) {
+                return tmpCallback();
+              }
+            };
+            this.loadCover(tmpFinish);
+            this.loadSidebar(tmpFinish);
+            this.loadTopbar(tmpFinish);
+            this.loadErrorPage(tmpFinish);
+          }).catch(pError => {
+            this.log.warn("Docuserve: Error loading catalog: ".concat(pError));
+            return tmpCallback();
+          });
+        }
+
+        /**
+         * Fetch and parse cover.md into structured data for the splash view.
+         *
+         * The expected cover.md format follows the docsify convention:
+         *   # Title
+         *   > Tagline
+         *   Description paragraph text.
+         *   - **Group** — description
+         *   [Link Text](url)
+         *
+         * Parsed result stored in this.pict.AppData.Docuserve.Cover:
+         *   { Title, Tagline, Description, Highlights: [{Label, Text}], Actions: [{Text, Href}] }
+         *
+         * @param {Function} fCallback - Callback when done
+         */
+        loadCover(fCallback) {
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : () => {};
+          let tmpDocsBase = this.pict.AppData.Docuserve.DocsBaseURL || '';
+          fetch(tmpDocsBase + 'cover.md').then(pResponse => {
+            if (!pResponse.ok) {
+              return null;
+            }
+            return pResponse.text();
+          }).then(pMarkdown => {
+            if (!pMarkdown) {
+              this.log.info('Docuserve: No cover.md found; splash will use catalog data.');
+              return tmpCallback();
+            }
+            this.pict.AppData.Docuserve.Cover = this.parseCover(pMarkdown);
+            this.pict.AppData.Docuserve.CoverLoaded = true;
+            return tmpCallback();
+          }).catch(pError => {
+            this.log.warn("Docuserve: Error loading cover.md: ".concat(pError));
+            return tmpCallback();
+          });
+        }
+
+        /**
+         * Parse cover.md markdown text into a structured object.
+         *
+         * @param {string} pMarkdown - Raw cover.md content
+         * @returns {Object} Parsed cover data
+         */
+        parseCover(pMarkdown) {
+          let tmpCover = {
+            Title: '',
+            Tagline: '',
+            Description: '',
+            Highlights: [],
+            Actions: []
+          };
+          let tmpLines = pMarkdown.split('\n');
+          for (let i = 0; i < tmpLines.length; i++) {
+            let tmpLine = tmpLines[i].trim();
+            if (!tmpLine) {
+              continue;
+            }
+
+            // Heading — the title
+            let tmpHeadingMatch = tmpLine.match(/^#+\s+(.+)/);
+            if (tmpHeadingMatch) {
+              tmpCover.Title = tmpHeadingMatch[1].trim();
+              continue;
+            }
+
+            // Blockquote — the tagline
+            let tmpBlockquoteMatch = tmpLine.match(/^>\s*(.*)/);
+            if (tmpBlockquoteMatch) {
+              tmpCover.Tagline = tmpBlockquoteMatch[1].trim();
+              continue;
+            }
+
+            // Bullet list — highlights (e.g. "- **Fable** — Core ecosystem, DI, config")
+            let tmpBulletMatch = tmpLine.match(/^[-*+]\s+(.*)/);
+            if (tmpBulletMatch) {
+              let tmpBulletContent = tmpBulletMatch[1];
+              // Try to split on bold label: **Label** — rest
+              let tmpLabelMatch = tmpBulletContent.match(/^\*\*([^*]+)\*\*\s*[-—:]\s*(.*)/);
+              if (tmpLabelMatch) {
+                tmpCover.Highlights.push({
+                  Label: tmpLabelMatch[1].trim(),
+                  Text: tmpLabelMatch[2].trim()
+                });
+              } else {
+                tmpCover.Highlights.push({
+                  Label: '',
+                  Text: tmpBulletContent.trim()
+                });
+              }
+              continue;
+            }
+
+            // Bare link — action button (e.g. "[Get Started](getting-started.md)")
+            let tmpLinkMatch = tmpLine.match(/^\[([^\]]+)\]\(([^)]+)\)\s*$/);
+            if (tmpLinkMatch) {
+              tmpCover.Actions.push({
+                Text: tmpLinkMatch[1].trim(),
+                Href: tmpLinkMatch[2].trim()
+              });
+              continue;
+            }
+
+            // Otherwise it's description text
+            if (!tmpCover.Description) {
+              tmpCover.Description = tmpLine;
+            } else {
+              tmpCover.Description += ' ' + tmpLine;
+            }
+          }
+          return tmpCover;
+        }
+
+        /**
+         * Fetch and parse _sidebar.md into structured navigation data.
+         *
+         * The expected _sidebar.md format follows the docsify convention:
+         *   - [Home](/)
+         *   - Group Title
+         *     - [module-name](/group/module/)
+         *   - [Group Title](group.md)
+         *     - [module-name](/group/module/)
+         *
+         * If _sidebar.md is successfully loaded and parsed, its data replaces
+         * the catalog-inferred SidebarGroups in AppData.
+         *
+         * @param {Function} fCallback - Callback when done
+         */
+        loadSidebar(fCallback) {
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : () => {};
+          let tmpDocsBase = this.pict.AppData.Docuserve.DocsBaseURL || '';
+          fetch(tmpDocsBase + '_sidebar.md').then(pResponse => {
+            if (!pResponse.ok) {
+              return null;
+            }
+            return pResponse.text();
+          }).then(pMarkdown => {
+            if (!pMarkdown) {
+              this.log.info('Docuserve: No _sidebar.md found; sidebar will use catalog data.');
+              return tmpCallback();
+            }
+            let tmpSidebarData = this.parseSidebarMarkdown(pMarkdown);
+            if (tmpSidebarData && tmpSidebarData.length > 0) {
+              this.pict.AppData.Docuserve.SidebarGroups = tmpSidebarData;
+              this.pict.AppData.Docuserve.SidebarLoaded = true;
+            }
+            return tmpCallback();
+          }).catch(pError => {
+            this.log.warn("Docuserve: Error loading _sidebar.md: ".concat(pError));
+            return tmpCallback();
+          });
+        }
+
+        /**
+         * Fetch and parse _topbar.md into structured data for the top bar view.
+         *
+         * The expected _topbar.md format:
+         *   # Brand Name
+         *   - [Link Text](url)
+         *   - [Link Text](url)
+         *
+         * The heading becomes the brand/title shown on the left.  List items become
+         * navigation links.  External links (starting with http) render on the
+         * right side; internal links render in the centre nav area.
+         *
+         * Parsed result stored in this.pict.AppData.Docuserve.TopBar:
+         *   { Brand, NavLinks: [{Text, Href, External}], ExternalLinks: [{Text, Href}] }
+         *
+         * @param {Function} fCallback - Callback when done
+         */
+        loadTopbar(fCallback) {
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : () => {};
+          let tmpDocsBase = this.pict.AppData.Docuserve.DocsBaseURL || '';
+          fetch(tmpDocsBase + '_topbar.md').then(pResponse => {
+            if (!pResponse.ok) {
+              return null;
+            }
+            return pResponse.text();
+          }).then(pMarkdown => {
+            if (!pMarkdown) {
+              this.log.info('Docuserve: No _topbar.md found; top bar will use defaults.');
+              return tmpCallback();
+            }
+            this.pict.AppData.Docuserve.TopBar = this.parseTopbar(pMarkdown);
+            this.pict.AppData.Docuserve.TopBarLoaded = true;
+            return tmpCallback();
+          }).catch(pError => {
+            this.log.warn("Docuserve: Error loading _topbar.md: ".concat(pError));
+            return tmpCallback();
+          });
+        }
+
+        /**
+         * Parse _topbar.md markdown text into a structured object.
+         *
+         * @param {string} pMarkdown - Raw _topbar.md content
+         * @returns {Object} Parsed top bar data { Brand, NavLinks, ExternalLinks }
+         */
+        parseTopbar(pMarkdown) {
+          let tmpTopBar = {
+            Brand: '',
+            NavLinks: [],
+            ExternalLinks: []
+          };
+          let tmpLines = pMarkdown.split('\n');
+          for (let i = 0; i < tmpLines.length; i++) {
+            let tmpLine = tmpLines[i].trim();
+            if (!tmpLine) {
+              continue;
+            }
+
+            // Heading — the brand name
+            let tmpHeadingMatch = tmpLine.match(/^#+\s+(.+)/);
+            if (tmpHeadingMatch) {
+              tmpTopBar.Brand = tmpHeadingMatch[1].trim();
+              continue;
+            }
+
+            // Bullet list item with link
+            let tmpBulletMatch = tmpLine.match(/^[-*+]\s+(.*)/);
+            if (tmpBulletMatch) {
+              let tmpContent = tmpBulletMatch[1].trim();
+              let tmpLinkMatch = tmpContent.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+              if (tmpLinkMatch) {
+                let tmpText = tmpLinkMatch[1].trim();
+                let tmpHref = tmpLinkMatch[2].trim();
+
+                // External links (http/https) go to the right side
+                if (tmpHref.match(/^https?:\/\//)) {
+                  tmpTopBar.ExternalLinks.push({
+                    Text: tmpText,
+                    Href: tmpHref
+                  });
+                } else {
+                  // Internal link — convert to hash route
+                  let tmpRoute = this.convertSidebarLink(tmpHref);
+                  tmpTopBar.NavLinks.push({
+                    Text: tmpText,
+                    Href: tmpRoute
+                  });
+                }
+              }
+              continue;
+            }
+          }
+          return tmpTopBar;
+        }
+
+        /**
+         * Fetch and parse errorpage.md into HTML for use as a custom error page.
+         *
+         * The errorpage.md is a standard markdown file.  If it contains the
+         * placeholder `{{path}}` anywhere in its source, that token will be
+         * replaced with the actual requested path at display time (via
+         * getErrorPageHTML).
+         *
+         * @param {Function} fCallback - Callback when done
+         */
+        loadErrorPage(fCallback) {
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : () => {};
+          let tmpDocsBase = this.pict.AppData.Docuserve.DocsBaseURL || '';
+          fetch(tmpDocsBase + 'errorpage.md').then(pResponse => {
+            if (!pResponse.ok) {
+              return null;
+            }
+            return pResponse.text();
+          }).then(pMarkdown => {
+            if (!pMarkdown) {
+              this.log.info('Docuserve: No errorpage.md found; errors will use default page.');
+              return tmpCallback();
+            }
+            this.pict.AppData.Docuserve.ErrorPageHTML = this.parseMarkdown(pMarkdown);
+            this.pict.AppData.Docuserve.ErrorPageLoaded = true;
+            return tmpCallback();
+          }).catch(pError => {
+            this.log.warn("Docuserve: Error loading errorpage.md: ".concat(pError));
+            return tmpCallback();
+          });
+        }
+
+        /**
+         * Get the error page HTML for a given requested path.
+         *
+         * If a custom errorpage.md was loaded, its parsed HTML is returned with
+         * the `{{path}}` placeholder replaced by the actual requested path.
+         * Otherwise a default not-found HTML block is returned.
+         *
+         * @param {string} pRequestedPath - The path that was not found
+         * @returns {string} HTML to display
+         */
+        getErrorPageHTML(pRequestedPath) {
+          let tmpPath = pRequestedPath || 'unknown';
+          if (this.pict.AppData.Docuserve.ErrorPageLoaded && this.pict.AppData.Docuserve.ErrorPageHTML) {
+            // Replace the {{path}} placeholder with the actual requested path
+            return this.pict.AppData.Docuserve.ErrorPageHTML.replace(/\{\{path\}\}/g, this.escapeHTML(tmpPath));
+          }
+
+          // Default fallback
+          return '<div class="docuserve-not-found">' + '<h2>Page Not Found</h2>' + '<p>The document <code>' + this.escapeHTML(tmpPath) + '</code> could not be loaded.</p>' + '<p><a href="#/Home">Return to the home page</a></p>' + '</div>';
+        }
+
+        /**
+         * Parse _sidebar.md into the SidebarGroups format the sidebar view consumes.
+         *
+         * Returns an array of group objects:
+         *   [{ Name, Key, Route, Modules: [{ Name, HasDocs, Group, Route }] }]
+         *
+         * Top-level items (no indent) become groups.  Indented child items become
+         * modules within the preceding group.  The special "Home" entry is stored
+         * as a group with no modules.
+         *
+         * @param {string} pMarkdown - Raw _sidebar.md content
+         * @returns {Array} Parsed sidebar groups
+         */
+        parseSidebarMarkdown(pMarkdown) {
+          let tmpGroups = [];
+          let tmpCurrentGroup = null;
+          let tmpLines = pMarkdown.split('\n');
+          for (let i = 0; i < tmpLines.length; i++) {
+            let tmpLine = tmpLines[i];
+            if (!tmpLine.trim()) {
+              continue;
+            }
+
+            // Detect indent level: child items have 2+ leading spaces
+            let tmpIndentMatch = tmpLine.match(/^(\s*)/);
+            let tmpIndent = tmpIndentMatch ? tmpIndentMatch[1].length : 0;
+            let tmpContent = tmpLine.trim();
+
+            // Must start with a list marker
+            let tmpListMatch = tmpContent.match(/^[-*+]\s+(.*)/);
+            if (!tmpListMatch) {
+              continue;
+            }
+            let tmpItemContent = tmpListMatch[1].trim();
+
+            // Parse link if present: [Text](href)
+            let tmpLinkMatch = tmpItemContent.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+            if (tmpIndent < 2) {
+              // Top-level item — this is a group header or standalone link
+              if (tmpLinkMatch) {
+                let tmpName = tmpLinkMatch[1].trim();
+                let tmpHref = tmpLinkMatch[2].trim();
+
+                // Derive a group key from the href or name
+                let tmpKey = this.deriveGroupKey(tmpName, tmpHref);
+                let tmpRoute = this.convertSidebarLink(tmpHref);
+                tmpCurrentGroup = {
+                  Name: tmpName,
+                  Key: tmpKey,
+                  Route: tmpRoute,
+                  Modules: []
+                };
+                tmpGroups.push(tmpCurrentGroup);
+              } else {
+                // Plain text group header (no link)
+                let tmpName = tmpItemContent;
+                let tmpKey = tmpName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+                tmpCurrentGroup = {
+                  Name: tmpName,
+                  Key: tmpKey,
+                  Route: '',
+                  Modules: []
+                };
+                tmpGroups.push(tmpCurrentGroup);
+              }
+            } else if (tmpCurrentGroup) {
+              // Indented item — this is a module within the current group
+              if (tmpLinkMatch) {
+                let tmpModuleName = tmpLinkMatch[1].trim();
+                let tmpModuleHref = tmpLinkMatch[2].trim();
+                let tmpModuleRoute = this.convertSidebarLink(tmpModuleHref);
+                tmpCurrentGroup.Modules.push({
+                  Name: tmpModuleName,
+                  HasDocs: true,
+                  Group: tmpCurrentGroup.Key,
+                  Route: tmpModuleRoute
+                });
+              } else {
+                // Plain text child entry (no docs link)
+                tmpCurrentGroup.Modules.push({
+                  Name: tmpItemContent,
+                  HasDocs: false,
+                  Group: tmpCurrentGroup.Key,
+                  Route: ''
+                });
+              }
+            }
+          }
+          return tmpGroups;
+        }
+
+        /**
+         * Convert a docsify-style sidebar link href into a docuserve hash route.
+         *
+         * Handles these forms:
+         *   /                        -> #/Home
+         *   /group/module/           -> #/doc/group/module
+         *   /group/module/path.md    -> #/doc/group/module/path.md
+         *   something.md             -> #/page/something
+         *
+         * @param {string} pHref - The original sidebar link href
+         * @returns {string} The converted hash route
+         */
+        convertSidebarLink(pHref) {
+          if (!pHref) {
+            return '';
+          }
+
+          // Root home link
+          if (pHref === '/') {
+            return '#/Home';
+          }
+
+          // Strip leading/trailing slashes for parsing
+          let tmpPath = pHref.replace(/^\//, '').replace(/\/$/, '');
+          if (!tmpPath) {
+            return '#/Home';
+          }
+          let tmpParts = tmpPath.split('/');
+
+          // Check if it's a module path (group/module)
+          if (tmpParts.length >= 2) {
+            let tmpGroupKeys = ['fable', 'meadow', 'orator', 'pict', 'utility'];
+            if (tmpGroupKeys.indexOf(tmpParts[0]) >= 0) {
+              return '#/doc/' + tmpPath;
+            }
+          }
+
+          // Local page reference
+          if (tmpPath.match(/\.md$/)) {
+            return '#/page/' + tmpPath.replace(/\.md$/, '');
+          }
+          return '#/page/' + tmpPath;
+        }
+
+        /**
+         * Derive a short group key from a sidebar group name or href.
+         *
+         * @param {string} pName - The display name (e.g. "Fable — Core Ecosystem")
+         * @param {string} pHref - The link href (e.g. "fable.md")
+         * @returns {string} A short key (e.g. "fable")
+         */
+        deriveGroupKey(pName, pHref) {
+          // Try href first — "fable.md" -> "fable"
+          if (pHref && pHref !== '/') {
+            let tmpFromHref = pHref.replace(/^\//, '').replace(/\.md$/, '').replace(/\/$/, '');
+            if (tmpFromHref && !tmpFromHref.includes('/')) {
+              return tmpFromHref.toLowerCase();
+            }
+          }
+
+          // Fall back to first word of name lowercased
+          let tmpFirstWord = pName.split(/[\s—\-:]+/)[0];
+          return tmpFirstWord.toLowerCase().replace(/[^a-z0-9]/g, '');
+        }
+
+        /**
+         * Build structured sidebar data from the catalog for the sidebar view.
+         *
+         * @param {Object} pCatalog - The parsed retold-catalog.json
+         */
+        buildSidebarData(pCatalog) {
+          let tmpSidebarGroups = [];
+          for (let i = 0; i < pCatalog.Groups.length; i++) {
+            let tmpGroup = pCatalog.Groups[i];
+            let tmpGroupEntry = {
+              Name: tmpGroup.Name,
+              Key: tmpGroup.Key,
+              Description: tmpGroup.Description,
+              Modules: []
+            };
+            for (let j = 0; j < tmpGroup.Modules.length; j++) {
+              let tmpModule = tmpGroup.Modules[j];
+              tmpGroupEntry.Modules.push({
+                Name: tmpModule.Name,
+                HasDocs: tmpModule.HasDocs,
+                Group: tmpGroup.Key,
+                Route: '#/doc/' + tmpGroup.Key + '/' + tmpModule.Name
+              });
+            }
+            tmpSidebarGroups.push(tmpGroupEntry);
+          }
+          this.pict.AppData.Docuserve.SidebarGroups = tmpSidebarGroups;
+        }
+
+        /**
+         * Resolve a document URL from group/module/path to a fetchable URL.
+         *
+         * @param {string} pGroup - The group key (e.g. 'fable')
+         * @param {string} pModule - The module name (e.g. 'fable')
+         * @param {string} pPath - The document path within the module docs (e.g. 'README.md')
+         * @returns {string} The resolved URL
+         */
+        resolveDocumentURL(pGroup, pModule, pPath) {
+          if (!this._Catalog) {
+            return null;
+          }
+          let tmpOrg = this._Catalog.GitHubOrg || 'stevenvelozo';
+          let tmpDefaultBranch = this._Catalog.DefaultBranch || 'master';
+
+          // Find the module in the catalog
+          for (let i = 0; i < this._Catalog.Groups.length; i++) {
+            let tmpGroup = this._Catalog.Groups[i];
+            if (tmpGroup.Key !== pGroup) {
+              continue;
+            }
+            for (let j = 0; j < tmpGroup.Modules.length; j++) {
+              let tmpModule = tmpGroup.Modules[j];
+              if (tmpModule.Name !== pModule) {
+                continue;
+              }
+              let tmpBranch = tmpModule.Branch || tmpDefaultBranch;
+              let tmpDocPath = pPath || 'README.md';
+              return 'https://raw.githubusercontent.com/' + tmpOrg + '/' + tmpModule.Repo + '/' + tmpBranch + '/docs/' + tmpDocPath;
+            }
+          }
+          return null;
+        }
+
+        /**
+         * Get the module-specific sidebar entries for a given group/module.
+         *
+         * @param {string} pGroup - The group key
+         * @param {string} pModule - The module name
+         * @returns {Array|null} The sidebar entries or null
+         */
+        getModuleSidebar(pGroup, pModule) {
+          if (!this._Catalog) {
+            return null;
+          }
+          for (let i = 0; i < this._Catalog.Groups.length; i++) {
+            let tmpGroup = this._Catalog.Groups[i];
+            if (tmpGroup.Key !== pGroup) {
+              continue;
+            }
+            for (let j = 0; j < tmpGroup.Modules.length; j++) {
+              let tmpModule = tmpGroup.Modules[j];
+              if (tmpModule.Name !== pModule) {
+                continue;
+              }
+              return tmpModule.Sidebar || null;
+            }
+          }
+          return null;
+        }
+
+        /**
+         * Fetch a markdown document and convert it to HTML.
+         *
+         * @param {string} pURL - The URL to fetch
+         * @param {Function} fCallback - Callback receiving (error, htmlContent)
+         */
+        fetchDocument(pURL, fCallback) {
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : () => {};
+          if (!pURL) {
+            return tmpCallback('No URL provided', '');
+          }
+
+          // Check cache
+          if (this._ContentCache[pURL]) {
+            return tmpCallback(null, this._ContentCache[pURL]);
+          }
+          fetch(pURL).then(pResponse => {
+            if (!pResponse.ok) {
+              return null;
+            }
+            return pResponse.text();
+          }).then(pMarkdown => {
+            if (!pMarkdown) {
+              return tmpCallback('Document not found', this.getErrorPageHTML(pURL));
+            }
+            let tmpHTML = this.parseMarkdown(pMarkdown);
+            this._ContentCache[pURL] = tmpHTML;
+            return tmpCallback(null, tmpHTML);
+          }).catch(pError => {
+            this.log.warn("Docuserve: Error fetching document [".concat(pURL, "]: ").concat(pError));
+            return tmpCallback(pError, this.getErrorPageHTML(pURL));
+          });
+        }
+
+        /**
+         * Fetch a local document relative to the docs folder.
+         *
+         * @param {string} pPath - The relative path (e.g. 'architecture.md')
+         * @param {Function} fCallback - Callback receiving (error, htmlContent)
+         */
+        fetchLocalDocument(pPath, fCallback) {
+          let tmpDocsBase = this.pict.AppData.Docuserve.DocsBaseURL || '';
+          let tmpURL = tmpDocsBase + pPath;
+          this.fetchDocument(tmpURL, fCallback);
+        }
+
+        /**
+         * Parse a markdown string into HTML.
+         *
+         * This is a basic markdown parser that handles the most common constructs:
+         * headings, paragraphs, code blocks, inline code, links, bold, italic,
+         * lists, blockquotes, and horizontal rules.
+         *
+         * @param {string} pMarkdown - The raw markdown text
+         * @returns {string} The parsed HTML
+         */
+        parseMarkdown(pMarkdown) {
+          if (!pMarkdown) {
+            return '';
+          }
+          let tmpLines = pMarkdown.split('\n');
+          let tmpHTML = [];
+          let tmpInCodeBlock = false;
+          let tmpCodeLang = '';
+          let tmpCodeLines = [];
+          let tmpInList = false;
+          let tmpListType = '';
+          let tmpInBlockquote = false;
+          let tmpBlockquoteLines = [];
+          for (let i = 0; i < tmpLines.length; i++) {
+            let tmpLine = tmpLines[i];
+
+            // Code blocks (fenced)
+            if (tmpLine.match(/^```/)) {
+              if (tmpInCodeBlock) {
+                // End code block
+                tmpHTML.push('<pre><code class="language-' + this.escapeHTML(tmpCodeLang) + '">' + this.escapeHTML(tmpCodeLines.join('\n')) + '</code></pre>');
+                tmpInCodeBlock = false;
+                tmpCodeLang = '';
+                tmpCodeLines = [];
+              } else {
+                // Close any open list or blockquote
+                if (tmpInList) {
+                  tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+                  tmpInList = false;
+                }
+                if (tmpInBlockquote) {
+                  tmpHTML.push('<blockquote>' + this.parseMarkdown(tmpBlockquoteLines.join('\n')) + '</blockquote>');
+                  tmpInBlockquote = false;
+                  tmpBlockquoteLines = [];
+                }
+                // Start code block
+                tmpCodeLang = tmpLine.replace(/^```/, '').trim();
+                tmpInCodeBlock = true;
+              }
+              continue;
+            }
+            if (tmpInCodeBlock) {
+              tmpCodeLines.push(tmpLine);
+              continue;
+            }
+
+            // Blockquotes
+            if (tmpLine.match(/^>\s?/)) {
+              if (!tmpInBlockquote) {
+                // Close any open list
+                if (tmpInList) {
+                  tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+                  tmpInList = false;
+                }
+                tmpInBlockquote = true;
+                tmpBlockquoteLines = [];
+              }
+              tmpBlockquoteLines.push(tmpLine.replace(/^>\s?/, ''));
+              continue;
+            } else if (tmpInBlockquote) {
+              tmpHTML.push('<blockquote>' + this.parseMarkdown(tmpBlockquoteLines.join('\n')) + '</blockquote>');
+              tmpInBlockquote = false;
+              tmpBlockquoteLines = [];
+            }
+
+            // Horizontal rule
+            if (tmpLine.match(/^(-{3,}|\*{3,}|_{3,})\s*$/)) {
+              if (tmpInList) {
+                tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+                tmpInList = false;
+              }
+              tmpHTML.push('<hr>');
+              continue;
+            }
+
+            // Headings
+            let tmpHeadingMatch = tmpLine.match(/^(#{1,6})\s+(.+)/);
+            if (tmpHeadingMatch) {
+              if (tmpInList) {
+                tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+                tmpInList = false;
+              }
+              let tmpLevel = tmpHeadingMatch[1].length;
+              let tmpText = this.parseInline(tmpHeadingMatch[2]);
+              let tmpID = tmpHeadingMatch[2].toLowerCase().replace(/[^\w\s-]/g, '').replace(/\s+/g, '-');
+              tmpHTML.push('<h' + tmpLevel + ' id="' + tmpID + '">' + tmpText + '</h' + tmpLevel + '>');
+              continue;
+            }
+
+            // Unordered list items
+            let tmpULMatch = tmpLine.match(/^(\s*)[-*+]\s+(.*)/);
+            if (tmpULMatch) {
+              if (!tmpInList || tmpListType !== 'ul') {
+                if (tmpInList) {
+                  tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+                }
+                tmpHTML.push('<ul>');
+                tmpInList = true;
+                tmpListType = 'ul';
+              }
+              tmpHTML.push('<li>' + this.parseInline(tmpULMatch[2]) + '</li>');
+              continue;
+            }
+
+            // Ordered list items
+            let tmpOLMatch = tmpLine.match(/^(\s*)\d+\.\s+(.*)/);
+            if (tmpOLMatch) {
+              if (!tmpInList || tmpListType !== 'ol') {
+                if (tmpInList) {
+                  tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+                }
+                tmpHTML.push('<ol>');
+                tmpInList = true;
+                tmpListType = 'ol';
+              }
+              tmpHTML.push('<li>' + this.parseInline(tmpOLMatch[2]) + '</li>');
+              continue;
+            }
+
+            // Close list if we've left list items
+            if (tmpInList && tmpLine.trim() !== '') {
+              tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+              tmpInList = false;
+            }
+
+            // Empty line
+            if (tmpLine.trim() === '') {
+              continue;
+            }
+
+            // Table detection
+            if (tmpLine.match(/^\|/) && i + 1 < tmpLines.length && tmpLines[i + 1].match(/^\|[\s-:|]+\|/)) {
+              // Close any open list
+              if (tmpInList) {
+                tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+                tmpInList = false;
+              }
+              let tmpTableHTML = '<table>';
+
+              // Header row
+              let tmpHeaders = tmpLine.split('|').filter(pCell => {
+                return pCell.trim() !== '';
+              });
+              tmpTableHTML += '<thead><tr>';
+              for (let h = 0; h < tmpHeaders.length; h++) {
+                tmpTableHTML += '<th>' + this.parseInline(tmpHeaders[h].trim()) + '</th>';
+              }
+              tmpTableHTML += '</tr></thead>';
+
+              // Skip separator row
+              i++;
+
+              // Body rows
+              tmpTableHTML += '<tbody>';
+              while (i + 1 < tmpLines.length && tmpLines[i + 1].match(/^\|/)) {
+                i++;
+                let tmpCells = tmpLines[i].split('|').filter(pCell => {
+                  return pCell.trim() !== '';
+                });
+                tmpTableHTML += '<tr>';
+                for (let c = 0; c < tmpCells.length; c++) {
+                  tmpTableHTML += '<td>' + this.parseInline(tmpCells[c].trim()) + '</td>';
+                }
+                tmpTableHTML += '</tr>';
+              }
+              tmpTableHTML += '</tbody></table>';
+              tmpHTML.push(tmpTableHTML);
+              continue;
+            }
+
+            // Regular paragraph
+            tmpHTML.push('<p>' + this.parseInline(tmpLine) + '</p>');
+          }
+
+          // Close any trailing open elements
+          if (tmpInList) {
+            tmpHTML.push(tmpListType === 'ul' ? '</ul>' : '</ol>');
+          }
+          if (tmpInBlockquote) {
+            tmpHTML.push('<blockquote>' + this.parseMarkdown(tmpBlockquoteLines.join('\n')) + '</blockquote>');
+          }
+          if (tmpInCodeBlock) {
+            tmpHTML.push('<pre><code>' + this.escapeHTML(tmpCodeLines.join('\n')) + '</code></pre>');
+          }
+          return tmpHTML.join('\n');
+        }
+
+        /**
+         * Parse inline markdown elements (bold, italic, code, links, images).
+         *
+         * @param {string} pText - The text to parse
+         * @returns {string} HTML with inline elements
+         */
+        parseInline(pText) {
+          if (!pText) {
+            return '';
+          }
+          let tmpResult = pText;
+
+          // Inline code (backticks) - handle first to avoid interfering with other patterns
+          tmpResult = tmpResult.replace(/`([^`]+)`/g, '<code>$1</code>');
+
+          // Images
+          tmpResult = tmpResult.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">');
+
+          // Links
+          tmpResult = tmpResult.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (pMatch, pLinkText, pHref) => {
+            // Convert internal doc links to hash routes
+            if (pHref.match(/^\//) || pHref.match(/^[^:]+\.md/)) {
+              let tmpRoute = this.convertDocLink(pHref);
+              return '<a href="' + tmpRoute + '">' + pLinkText + '</a>';
+            }
+            return '<a href="' + pHref + '" target="_blank" rel="noopener">' + pLinkText + '</a>';
+          });
+
+          // Bold
+          tmpResult = tmpResult.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+          tmpResult = tmpResult.replace(/__([^_]+)__/g, '<strong>$1</strong>');
+
+          // Italic
+          tmpResult = tmpResult.replace(/\*([^*]+)\*/g, '<em>$1</em>');
+          tmpResult = tmpResult.replace(/_([^_]+)_/g, '<em>$1</em>');
+          return tmpResult;
+        }
+
+        /**
+         * Convert a docsify-style internal link to a hash route for docuserve.
+         *
+         * @param {string} pHref - The original link href
+         * @returns {string} The converted hash route
+         */
+        convertDocLink(pHref) {
+          // Remove leading slash
+          let tmpPath = pHref.replace(/^\//, '');
+
+          // If it looks like a module path (group/module/), convert to our route format
+          let tmpParts = tmpPath.split('/');
+          if (tmpParts.length >= 2) {
+            // Check if first segment matches a known group key
+            let tmpGroupKeys = ['fable', 'meadow', 'orator', 'pict', 'utility'];
+            if (tmpGroupKeys.indexOf(tmpParts[0]) >= 0) {
+              return '#/doc/' + tmpPath;
+            }
+          }
+
+          // Local doc page
+          if (tmpPath.match(/\.md$/)) {
+            let tmpPageKey = tmpPath.replace(/\.md$/, '');
+            return '#/page/' + tmpPageKey;
+          }
+          return '#/page/' + tmpPath;
+        }
+
+        /**
+         * Escape HTML special characters.
+         *
+         * @param {string} pText - The text to escape
+         * @returns {string} The escaped text
+         */
+        escapeHTML(pText) {
+          if (!pText) {
+            return '';
+          }
+          return pText.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+        }
+      }
+      module.exports = DocuserveDocumentationProvider;
+      module.exports.default_configuration = {
+        ProviderIdentifier: "Docuserve-Documentation",
+        AutoInitialize: true,
+        AutoInitializeOrdinal: 0
+      };
+    }, {
+      "pict-provider": 6
+    }],
+    12: [function (require, module, exports) {
+      const libPictView = require('pict-view');
+      const _ViewConfiguration = {
+        ViewIdentifier: "Docuserve-Content",
+        DefaultRenderable: "Docuserve-Content-Display",
+        DefaultDestinationAddress: "#Docuserve-Content-Container",
+        AutoRender: false,
+        CSS: /*css*/"\n\t\t.docuserve-content {\n\t\t\tpadding: 2em 3em;\n\t\t\tmax-width: 900px;\n\t\t\tmargin: 0 auto;\n\t\t}\n\t\t.docuserve-content-loading {\n\t\t\tdisplay: flex;\n\t\t\talign-items: center;\n\t\t\tjustify-content: center;\n\t\t\tmin-height: 200px;\n\t\t\tcolor: #999;\n\t\t\tfont-size: 1em;\n\t\t}\n\t\t.docuserve-content h1 {\n\t\t\tfont-size: 2em;\n\t\t\tcolor: #2c3e50;\n\t\t\tborder-bottom: 1px solid #eee;\n\t\t\tpadding-bottom: 0.3em;\n\t\t\tmargin-top: 0;\n\t\t}\n\t\t.docuserve-content h2 {\n\t\t\tfont-size: 1.5em;\n\t\t\tcolor: #2c3e50;\n\t\t\tborder-bottom: 1px solid #f0f0f0;\n\t\t\tpadding-bottom: 0.25em;\n\t\t\tmargin-top: 1.5em;\n\t\t}\n\t\t.docuserve-content h3 {\n\t\t\tfont-size: 1.25em;\n\t\t\tcolor: #333;\n\t\t\tmargin-top: 1.25em;\n\t\t}\n\t\t.docuserve-content h4, .docuserve-content h5, .docuserve-content h6 {\n\t\t\tcolor: #555;\n\t\t\tmargin-top: 1em;\n\t\t}\n\t\t.docuserve-content p {\n\t\t\tline-height: 1.7;\n\t\t\tcolor: #444;\n\t\t\tmargin: 0.75em 0;\n\t\t}\n\t\t.docuserve-content a {\n\t\t\tcolor: #42b983;\n\t\t\ttext-decoration: none;\n\t\t}\n\t\t.docuserve-content a:hover {\n\t\t\ttext-decoration: underline;\n\t\t}\n\t\t.docuserve-content pre {\n\t\t\tbackground: #2c3e50;\n\t\t\tcolor: #ecf0f1;\n\t\t\tpadding: 1.25em;\n\t\t\tborder-radius: 6px;\n\t\t\toverflow-x: auto;\n\t\t\tline-height: 1.5;\n\t\t\tfont-size: 0.9em;\n\t\t}\n\t\t.docuserve-content code {\n\t\t\tbackground: #f4f4f5;\n\t\t\tpadding: 0.15em 0.4em;\n\t\t\tborder-radius: 3px;\n\t\t\tfont-size: 0.9em;\n\t\t\tcolor: #e74c3c;\n\t\t}\n\t\t.docuserve-content pre code {\n\t\t\tbackground: none;\n\t\t\tpadding: 0;\n\t\t\tcolor: inherit;\n\t\t\tfont-size: inherit;\n\t\t}\n\t\t.docuserve-content blockquote {\n\t\t\tborder-left: 4px solid #42b983;\n\t\t\tmargin: 1em 0;\n\t\t\tpadding: 0.5em 1em;\n\t\t\tbackground: #f9f9f9;\n\t\t\tcolor: #666;\n\t\t}\n\t\t.docuserve-content blockquote p {\n\t\t\tmargin: 0.25em 0;\n\t\t}\n\t\t.docuserve-content ul, .docuserve-content ol {\n\t\t\tpadding-left: 2em;\n\t\t\tline-height: 1.8;\n\t\t}\n\t\t.docuserve-content li {\n\t\t\tmargin: 0.25em 0;\n\t\t\tcolor: #444;\n\t\t}\n\t\t.docuserve-content hr {\n\t\t\tborder: none;\n\t\t\tborder-top: 1px solid #eee;\n\t\t\tmargin: 2em 0;\n\t\t}\n\t\t.docuserve-content table {\n\t\t\twidth: 100%;\n\t\t\tborder-collapse: collapse;\n\t\t\tmargin: 1em 0;\n\t\t}\n\t\t.docuserve-content table th {\n\t\t\tbackground: #f5f7fa;\n\t\t\tborder: 1px solid #e0e0e0;\n\t\t\tpadding: 0.6em 0.8em;\n\t\t\ttext-align: left;\n\t\t\tfont-weight: 600;\n\t\t\tcolor: #2c3e50;\n\t\t}\n\t\t.docuserve-content table td {\n\t\t\tborder: 1px solid #e0e0e0;\n\t\t\tpadding: 0.5em 0.8em;\n\t\t\tcolor: #444;\n\t\t}\n\t\t.docuserve-content table tr:nth-child(even) {\n\t\t\tbackground: #fafafa;\n\t\t}\n\t\t.docuserve-content img {\n\t\t\tmax-width: 100%;\n\t\t\theight: auto;\n\t\t}\n\t\t.docuserve-not-found {\n\t\t\ttext-align: center;\n\t\t\tpadding: 3em 1em;\n\t\t\tcolor: #666;\n\t\t}\n\t\t.docuserve-not-found h2 {\n\t\t\tcolor: #999;\n\t\t\tfont-size: 1.5em;\n\t\t\tborder-bottom: none;\n\t\t}\n\t\t.docuserve-not-found code {\n\t\t\tbackground: #f4f4f5;\n\t\t\tpadding: 0.15em 0.4em;\n\t\t\tborder-radius: 3px;\n\t\t\tfont-size: 0.9em;\n\t\t\tcolor: #e74c3c;\n\t\t}\n\t",
+        Templates: [{
+          Hash: "Docuserve-Content-Template",
+          Template: /*html*/"\n<div class=\"docuserve-content\" id=\"Docuserve-Content-Body\">\n\t<div class=\"docuserve-content-loading\">Loading documentation...</div>\n</div>\n"
+        }],
+        Renderables: [{
+          RenderableHash: "Docuserve-Content-Display",
+          TemplateHash: "Docuserve-Content-Template",
+          DestinationAddress: "#Docuserve-Content-Container",
+          RenderMethod: "replace"
+        }]
+      };
+      class DocuserveContentView extends libPictView {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+        }
+
+        /**
+         * Display parsed HTML content in the content area.
+         *
+         * @param {string} pHTMLContent - The HTML to display
+         */
+        displayContent(pHTMLContent) {
+          this.pict.ContentAssignment.assignContent('#Docuserve-Content-Body', pHTMLContent);
+
+          // Scroll to top of content area
+          let tmpContentContainer = document.getElementById('Docuserve-Content-Container');
+          if (tmpContentContainer) {
+            tmpContentContainer.scrollTop = 0;
+          }
+        }
+
+        /**
+         * Show a loading indicator.
+         */
+        showLoading() {
+          this.pict.ContentAssignment.assignContent('#Docuserve-Content-Body', '<div class="docuserve-content-loading">Loading documentation...</div>');
+        }
+      }
+      module.exports = DocuserveContentView;
+      module.exports.default_configuration = _ViewConfiguration;
+    }, {
+      "pict-view": 8
+    }],
+    13: [function (require, module, exports) {
+      const libPictView = require('pict-view');
+      const _ViewConfiguration = {
+        ViewIdentifier: "Docuserve-Layout",
+        DefaultRenderable: "Docuserve-Layout-Shell",
+        DefaultDestinationAddress: "#Docuserve-Application-Container",
+        AutoRender: false,
+        CSS: /*css*/"\n\t\t#Docuserve-Application-Container {\n\t\t\tdisplay: flex;\n\t\t\tflex-direction: column;\n\t\t\theight: 100vh;\n\t\t\toverflow: hidden;\n\t\t}\n\t\t#Docuserve-TopBar-Container {\n\t\t\tflex-shrink: 0;\n\t\t}\n\t\t.docuserve-body {\n\t\t\tdisplay: flex;\n\t\t\tflex: 1;\n\t\t\tmin-height: 0;\n\t\t}\n\t\t#Docuserve-Sidebar-Container {\n\t\t\tflex-shrink: 0;\n\t\t\twidth: 280px;\n\t\t\toverflow-y: auto;\n\t\t}\n\t\t#Docuserve-Content-Container {\n\t\t\tflex: 1;\n\t\t\tmin-width: 0;\n\t\t\toverflow-y: auto;\n\t\t}\n\t",
+        Templates: [{
+          Hash: "Docuserve-Layout-Shell-Template",
+          Template: /*html*/"\n<div id=\"Docuserve-TopBar-Container\"></div>\n<div class=\"docuserve-body\">\n\t<div id=\"Docuserve-Sidebar-Container\"></div>\n\t<div id=\"Docuserve-Content-Container\"></div>\n</div>\n"
+        }],
+        Renderables: [{
+          RenderableHash: "Docuserve-Layout-Shell",
+          TemplateHash: "Docuserve-Layout-Shell-Template",
+          DestinationAddress: "#Docuserve-Application-Container",
+          RenderMethod: "replace"
+        }]
+      };
+      class DocuserveLayoutView extends libPictView {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+        }
+        onAfterRender(pRenderable, pRenderDestinationAddress, pRecord, pContent) {
+          // After the layout shell is rendered, render the child views into their containers
+          this.pict.views['Docuserve-TopBar'].render();
+          this.pict.views['Docuserve-Sidebar'].render();
+
+          // Show the splash screen initially
+          this.pict.views['Docuserve-Splash'].render();
+
+          // Inject all view CSS into the PICT-CSS style element
+          this.pict.CSSMap.injectCSS();
+
+          // Resolve the current hash on initial load
+          this.pict.PictApplication.resolveHash();
+
+          // Listen for hash changes so that plain <a href="#/..."> links trigger
+          // navigation.  This covers sidebar links, splash action buttons,
+          // in-content links, and browser back/forward navigation.
+          if (!this._HashChangeListenerBound) {
+            this._HashChangeListenerBound = true;
+            let tmpSelf = this;
+            window.addEventListener('hashchange', () => {
+              tmpSelf.pict.PictApplication.resolveHash();
+            });
+          }
+          return super.onAfterRender(pRenderable, pRenderDestinationAddress, pRecord, pContent);
+        }
+      }
+      module.exports = DocuserveLayoutView;
+      module.exports.default_configuration = _ViewConfiguration;
+    }, {
+      "pict-view": 8
+    }],
+    14: [function (require, module, exports) {
+      const libPictView = require('pict-view');
+      const _ViewConfiguration = {
+        ViewIdentifier: "Docuserve-Sidebar",
+        DefaultRenderable: "Docuserve-Sidebar-Content",
+        DefaultDestinationAddress: "#Docuserve-Sidebar-Container",
+        AutoRender: false,
+        CSS: /*css*/"\n\t\t.docuserve-sidebar {\n\t\t\tbackground-color: #f8f9fa;\n\t\t\tborder-right: 1px solid #e0e0e0;\n\t\t\tpadding: 1em 0;\n\t\t\theight: 100%;\n\t\t\tposition: relative;\n\t\t}\n\t\t.docuserve-sidebar-close {\n\t\t\tposition: absolute;\n\t\t\ttop: 0.5em;\n\t\t\tright: 0.5em;\n\t\t\tbackground: none;\n\t\t\tborder: none;\n\t\t\tcolor: #999;\n\t\t\tfont-size: 1.2em;\n\t\t\tcursor: pointer;\n\t\t\tpadding: 0.2em 0.4em;\n\t\t\tline-height: 1;\n\t\t}\n\t\t.docuserve-sidebar-close:hover {\n\t\t\tcolor: #42b983;\n\t\t}\n\t\t.docuserve-sidebar-search {\n\t\t\tpadding: 0 1em 1em 1em;\n\t\t\tborder-bottom: 1px solid #e9ecef;\n\t\t\tmargin-bottom: 0.5em;\n\t\t}\n\t\t.docuserve-sidebar-search input {\n\t\t\twidth: 100%;\n\t\t\tpadding: 0.5em 0.75em;\n\t\t\tborder: 1px solid #ddd;\n\t\t\tborder-radius: 4px;\n\t\t\tfont-size: 0.85em;\n\t\t\toutline: none;\n\t\t\tbox-sizing: border-box;\n\t\t}\n\t\t.docuserve-sidebar-search input:focus {\n\t\t\tborder-color: #42b983;\n\t\t}\n\t\t.docuserve-sidebar-home {\n\t\t\tpadding: 0.5em 1.25em;\n\t\t\tfont-weight: 600;\n\t\t\tfont-size: 0.85em;\n\t\t\ttext-transform: uppercase;\n\t\t\tletter-spacing: 0.03em;\n\t\t}\n\t\t.docuserve-sidebar-home a {\n\t\t\tcolor: #666;\n\t\t\ttext-decoration: none;\n\t\t\tcursor: pointer;\n\t\t\tuser-select: none;\n\t\t}\n\t\t.docuserve-sidebar-home a:hover {\n\t\t\tcolor: #42b983;\n\t\t}\n\t\t.docuserve-sidebar-group {\n\t\t\tmargin-top: 0.25em;\n\t\t}\n\t\t.docuserve-sidebar-group-title {\n\t\t\tdisplay: block;\n\t\t\tpadding: 0.5em 1.25em;\n\t\t\tfont-weight: 600;\n\t\t\tfont-size: 0.85em;\n\t\t\tcolor: #666;\n\t\t\ttext-decoration: none;\n\t\t\ttext-transform: uppercase;\n\t\t\tletter-spacing: 0.03em;\n\t\t\tcursor: pointer;\n\t\t\tuser-select: none;\n\t\t}\n\t\t.docuserve-sidebar-group-title:hover {\n\t\t\tcolor: #42b983;\n\t\t}\n\t\t.docuserve-sidebar-modules {\n\t\t\tlist-style: none;\n\t\t\tmargin: 0;\n\t\t\tpadding: 0;\n\t\t}\n\t\t.docuserve-sidebar-modules li {\n\t\t\tpadding: 0;\n\t\t}\n\t\t.docuserve-sidebar-modules a {\n\t\t\tdisplay: block;\n\t\t\tpadding: 0.3em 1.25em 0.3em 2em;\n\t\t\tcolor: #555;\n\t\t\ttext-decoration: none;\n\t\t\tfont-size: 0.85em;\n\t\t\ttransition: background-color 0.1s, color 0.1s;\n\t\t\tcursor: pointer;\n\t\t}\n\t\t.docuserve-sidebar-modules a:hover {\n\t\t\tbackground-color: #e9ecef;\n\t\t\tcolor: #42b983;\n\t\t}\n\t\t.docuserve-sidebar-modules a.active {\n\t\t\tcolor: #42b983;\n\t\t\tfont-weight: 600;\n\t\t\tbackground-color: #e8f5e9;\n\t\t}\n\t\t.docuserve-sidebar-modules .no-docs {\n\t\t\tdisplay: block;\n\t\t\tpadding: 0.3em 1.25em 0.3em 2em;\n\t\t\tcolor: #bbb;\n\t\t\tfont-size: 0.85em;\n\t\t}\n\t\t.docuserve-sidebar-module-nav {\n\t\t\tborder-top: 1px solid #e9ecef;\n\t\t\tmargin-top: 0.5em;\n\t\t\tpadding-top: 0.5em;\n\t\t}\n\t\t.docuserve-sidebar-module-nav-section {\n\t\t\tpadding: 0.4em 1.25em;\n\t\t\tfont-weight: 600;\n\t\t\tfont-size: 0.8em;\n\t\t\tcolor: #888;\n\t\t\ttext-transform: uppercase;\n\t\t\tletter-spacing: 0.02em;\n\t\t}\n\t\t.docuserve-sidebar-module-nav a {\n\t\t\tdisplay: block;\n\t\t\tpadding: 0.25em 1.25em 0.25em 2.25em;\n\t\t\tcolor: #555;\n\t\t\ttext-decoration: none;\n\t\t\tfont-size: 0.82em;\n\t\t\ttransition: background-color 0.1s, color 0.1s;\n\t\t\tcursor: pointer;\n\t\t}\n\t\t.docuserve-sidebar-module-nav a:hover {\n\t\t\tbackground-color: #e9ecef;\n\t\t\tcolor: #42b983;\n\t\t}\n\t",
+        Templates: [{
+          Hash: "Docuserve-Sidebar-Template",
+          Template: /*html*/"\n<div class=\"docuserve-sidebar\">\n\t<button class=\"docuserve-sidebar-close\" onclick=\"{~P~}.views['Docuserve-Sidebar'].toggleSidebar()\">&times;</button>\n\t<div class=\"docuserve-sidebar-home\">\n\t\t<a onclick=\"{~P~}.PictApplication.navigateTo('/Home')\">Home</a>\n\t</div>\n\t<div id=\"Docuserve-Sidebar-Groups\"></div>\n\t<div id=\"Docuserve-Sidebar-ModuleNav\"></div>\n</div>\n"
+        }],
+        Renderables: [{
+          RenderableHash: "Docuserve-Sidebar-Content",
+          TemplateHash: "Docuserve-Sidebar-Template",
+          DestinationAddress: "#Docuserve-Sidebar-Container",
+          RenderMethod: "replace"
+        }]
+      };
+      class DocusserveSidebarView extends libPictView {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+        }
+        onAfterRender(pRenderable, pRenderDestinationAddress, pRecord, pContent) {
+          this.renderSidebarGroups();
+          return super.onAfterRender(pRenderable, pRenderDestinationAddress, pRecord, pContent);
+        }
+
+        /**
+         * Render the sidebar group navigation from catalog data.
+         */
+        renderSidebarGroups() {
+          let tmpGroups = this.pict.AppData.Docuserve.SidebarGroups;
+          if (!tmpGroups || tmpGroups.length < 1) {
+            this.pict.ContentAssignment.assignContent('#Docuserve-Sidebar-Groups', '<p style="padding: 1em; color: #999; font-size: 0.85em;">Loading catalog...</p>');
+            return;
+          }
+          let tmpHTML = '';
+          for (let i = 0; i < tmpGroups.length; i++) {
+            let tmpGroup = tmpGroups[i];
+            tmpHTML += '<div class="docuserve-sidebar-group">';
+
+            // Determine the route for the group title: use the group's own route,
+            // or fall back to the first module with docs.
+            let tmpGroupRoute = tmpGroup.Route || '';
+            if (!tmpGroupRoute) {
+              for (let k = 0; k < tmpGroup.Modules.length; k++) {
+                if (tmpGroup.Modules[k].HasDocs && tmpGroup.Modules[k].Route) {
+                  tmpGroupRoute = tmpGroup.Modules[k].Route;
+                  break;
+                }
+              }
+            }
+            if (tmpGroupRoute) {
+              tmpHTML += '<a class="docuserve-sidebar-group-title" href="' + tmpGroupRoute + '">' + this.escapeHTML(tmpGroup.Name) + '</a>';
+            } else {
+              tmpHTML += '<div class="docuserve-sidebar-group-title">' + this.escapeHTML(tmpGroup.Name) + '</div>';
+            }
+            tmpHTML += '<ul class="docuserve-sidebar-modules">';
+            for (let j = 0; j < tmpGroup.Modules.length; j++) {
+              let tmpModule = tmpGroup.Modules[j];
+              if (tmpModule.HasDocs) {
+                let tmpActiveClass = '';
+                if (this.pict.AppData.Docuserve.CurrentGroup === tmpModule.Group && this.pict.AppData.Docuserve.CurrentModule === tmpModule.Name) {
+                  tmpActiveClass = ' class="active"';
+                }
+                tmpHTML += '<li><a' + tmpActiveClass + ' href="' + tmpModule.Route + '">' + this.escapeHTML(tmpModule.Name) + '</a></li>';
+              } else {
+                tmpHTML += '<li><span class="no-docs">' + this.escapeHTML(tmpModule.Name) + '</span></li>';
+              }
+            }
+            tmpHTML += '</ul>';
+            tmpHTML += '</div>';
+          }
+          this.pict.ContentAssignment.assignContent('#Docuserve-Sidebar-Groups', tmpHTML);
+        }
+
+        /**
+         * Render module-specific sub-navigation when viewing a module.
+         *
+         * @param {string} pGroup - The group key
+         * @param {string} pModule - The module name
+         */
+        renderModuleNav(pGroup, pModule) {
+          let tmpDocProvider = this.pict.providers['Docuserve-Documentation'];
+          if (!tmpDocProvider) {
+            return;
+          }
+          let tmpSidebar = tmpDocProvider.getModuleSidebar(pGroup, pModule);
+          if (!tmpSidebar) {
+            this.pict.ContentAssignment.assignContent('#Docuserve-Sidebar-ModuleNav', '');
+            return;
+          }
+          let tmpRoutePrefix = '#/doc/' + pGroup + '/' + pModule + '/';
+          let tmpHTML = '<div class="docuserve-sidebar-module-nav">';
+          for (let i = 0; i < tmpSidebar.length; i++) {
+            let tmpEntry = tmpSidebar[i];
+            if (tmpEntry.Children) {
+              tmpHTML += '<div class="docuserve-sidebar-module-nav-section">' + this.escapeHTML(tmpEntry.Title) + '</div>';
+              for (let j = 0; j < tmpEntry.Children.length; j++) {
+                let tmpChild = tmpEntry.Children[j];
+                if (tmpChild.Path) {
+                  tmpHTML += '<a href="' + tmpRoutePrefix + tmpChild.Path + '">' + this.escapeHTML(tmpChild.Title) + '</a>';
+                }
+              }
+            } else if (tmpEntry.Path) {
+              tmpHTML += '<a href="' + tmpRoutePrefix + tmpEntry.Path + '">' + this.escapeHTML(tmpEntry.Title) + '</a>';
+            }
+          }
+          tmpHTML += '</div>';
+          this.pict.ContentAssignment.assignContent('#Docuserve-Sidebar-ModuleNav', tmpHTML);
+        }
+
+        /**
+         * Toggle the sidebar visibility and update the top bar hamburger button.
+         */
+        toggleSidebar() {
+          this.pict.AppData.Docuserve.SidebarVisible = !this.pict.AppData.Docuserve.SidebarVisible;
+          let tmpContainer = document.getElementById('Docuserve-Sidebar-Container');
+          let tmpToggle = document.getElementById('Docuserve-TopBar-Toggle');
+          if (this.pict.AppData.Docuserve.SidebarVisible) {
+            if (tmpContainer) tmpContainer.style.display = '';
+            if (tmpToggle) tmpToggle.style.display = 'none';
+          } else {
+            if (tmpContainer) tmpContainer.style.display = 'none';
+            if (tmpToggle) tmpToggle.style.display = 'inline-block';
+          }
+        }
+
+        /**
+         * Clear the module-specific sub-navigation.
+         */
+        clearModuleNav() {
+          this.pict.ContentAssignment.assignContent('#Docuserve-Sidebar-ModuleNav', '');
+        }
+
+        /**
+         * Escape HTML special characters.
+         *
+         * @param {string} pText - The text to escape
+         * @returns {string} The escaped text
+         */
+        escapeHTML(pText) {
+          if (!pText) {
+            return '';
+          }
+          return pText.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+        }
+      }
+      module.exports = DocusserveSidebarView;
+      module.exports.default_configuration = _ViewConfiguration;
+    }, {
+      "pict-view": 8
+    }],
+    15: [function (require, module, exports) {
+      const libPictView = require('pict-view');
+      const _ViewConfiguration = {
+        ViewIdentifier: "Docuserve-Splash",
+        DefaultRenderable: "Docuserve-Splash-Content",
+        DefaultDestinationAddress: "#Docuserve-Content-Container",
+        AutoRender: false,
+        CSS: /*css*/"\n\t\t.docuserve-splash {\n\t\t\tdisplay: flex;\n\t\t\tflex-direction: column;\n\t\t\talign-items: center;\n\t\t\tjustify-content: center;\n\t\t\tmin-height: calc(100vh - 56px);\n\t\t\tpadding: 3em 2em;\n\t\t\ttext-align: center;\n\t\t\tbackground: linear-gradient(135deg, #f5f7fa 0%, #e8f5e9 100%);\n\t\t}\n\t\t.docuserve-splash h1 {\n\t\t\tfont-size: 3em;\n\t\t\tfont-weight: 700;\n\t\t\tcolor: #2c3e50;\n\t\t\tmargin: 0 0 0.25em 0;\n\t\t}\n\t\t.docuserve-splash-tagline {\n\t\t\tfont-size: 1.25em;\n\t\t\tcolor: #666;\n\t\t\tmargin-bottom: 1.5em;\n\t\t\tfont-style: italic;\n\t\t}\n\t\t.docuserve-splash-description {\n\t\t\tfont-size: 1em;\n\t\t\tcolor: #555;\n\t\t\tmax-width: 600px;\n\t\t\tline-height: 1.7;\n\t\t\tmargin-bottom: 2em;\n\t\t}\n\t\t.docuserve-splash-highlights {\n\t\t\tdisplay: grid;\n\t\t\tgrid-template-columns: repeat(auto-fit, minmax(200px, 1fr));\n\t\t\tgap: 1.25em;\n\t\t\tmax-width: 900px;\n\t\t\twidth: 100%;\n\t\t\tmargin-bottom: 2.5em;\n\t\t}\n\t\t.docuserve-splash-highlight-card {\n\t\t\tbackground: #fff;\n\t\t\tborder: 1px solid #e0e0e0;\n\t\t\tborder-radius: 8px;\n\t\t\tpadding: 1.25em;\n\t\t\ttext-align: left;\n\t\t\ttransition: box-shadow 0.2s, border-color 0.2s;\n\t\t}\n\t\t.docuserve-splash-highlight-card:hover {\n\t\t\tbox-shadow: 0 4px 16px rgba(0, 0, 0, 0.08);\n\t\t\tborder-color: #42b983;\n\t\t}\n\t\t.docuserve-splash-highlight-card h3 {\n\t\t\tmargin: 0 0 0.5em 0;\n\t\t\tcolor: #2c3e50;\n\t\t\tfont-size: 1em;\n\t\t}\n\t\t.docuserve-splash-highlight-card p {\n\t\t\tmargin: 0;\n\t\t\tcolor: #777;\n\t\t\tfont-size: 0.85em;\n\t\t\tline-height: 1.5;\n\t\t}\n\t\t.docuserve-splash-actions {\n\t\t\tdisplay: flex;\n\t\t\tgap: 1em;\n\t\t\tflex-wrap: wrap;\n\t\t\tjustify-content: center;\n\t\t}\n\t\t.docuserve-splash-actions a {\n\t\t\tdisplay: inline-block;\n\t\t\tpadding: 0.7em 1.5em;\n\t\t\tborder-radius: 6px;\n\t\t\tfont-size: 0.95em;\n\t\t\tfont-weight: 600;\n\t\t\ttext-decoration: none;\n\t\t\ttransition: background-color 0.15s, color 0.15s;\n\t\t\tcursor: pointer;\n\t\t}\n\t\t.docuserve-splash-actions .primary {\n\t\t\tbackground-color: #42b983;\n\t\t\tcolor: #fff;\n\t\t}\n\t\t.docuserve-splash-actions .primary:hover {\n\t\t\tbackground-color: #38a373;\n\t\t}\n\t\t.docuserve-splash-actions .secondary {\n\t\t\tbackground-color: #fff;\n\t\t\tcolor: #2c3e50;\n\t\t\tborder: 1px solid #ddd;\n\t\t}\n\t\t.docuserve-splash-actions .secondary:hover {\n\t\t\tborder-color: #42b983;\n\t\t\tcolor: #42b983;\n\t\t}\n\t",
+        Templates: [{
+          Hash: "Docuserve-Splash-Template",
+          Template: /*html*/"\n<div class=\"docuserve-splash\">\n\t<h1 id=\"Docuserve-Splash-Title\"></h1>\n\t<div class=\"docuserve-splash-tagline\" id=\"Docuserve-Splash-Tagline\"></div>\n\t<div class=\"docuserve-splash-description\" id=\"Docuserve-Splash-Description\"></div>\n\t<div class=\"docuserve-splash-highlights\" id=\"Docuserve-Splash-Highlights\"></div>\n\t<div class=\"docuserve-splash-actions\" id=\"Docuserve-Splash-Actions\"></div>\n</div>\n"
+        }],
+        Renderables: [{
+          RenderableHash: "Docuserve-Splash-Content",
+          TemplateHash: "Docuserve-Splash-Template",
+          DestinationAddress: "#Docuserve-Content-Container",
+          RenderMethod: "replace"
+        }]
+      };
+      class DocusserveSplashView extends libPictView {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+        }
+        onAfterRender(pRenderable, pRenderDestinationAddress, pRecord, pContent) {
+          let tmpDocuserve = this.pict.AppData.Docuserve;
+          if (tmpDocuserve.CoverLoaded && tmpDocuserve.Cover) {
+            this.renderFromCover(tmpDocuserve.Cover);
+          } else {
+            this.renderFromCatalog(tmpDocuserve);
+          }
+          return super.onAfterRender(pRenderable, pRenderDestinationAddress, pRecord, pContent);
+        }
+
+        /**
+         * Render the splash screen from parsed cover.md data.
+         *
+         * @param {Object} pCover - The parsed cover data { Title, Tagline, Description, Highlights, Actions }
+         */
+        renderFromCover(pCover) {
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Title', this.escapeHTML(pCover.Title));
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Tagline', this.escapeHTML(pCover.Tagline));
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Description', this.escapeHTML(pCover.Description));
+
+          // Render highlight cards
+          let tmpHighlightsHTML = '';
+          for (let i = 0; i < pCover.Highlights.length; i++) {
+            let tmpHighlight = pCover.Highlights[i];
+            tmpHighlightsHTML += '<div class="docuserve-splash-highlight-card">';
+            if (tmpHighlight.Label) {
+              tmpHighlightsHTML += '<h3>' + this.escapeHTML(tmpHighlight.Label) + '</h3>';
+            }
+            tmpHighlightsHTML += '<p>' + this.escapeHTML(tmpHighlight.Text) + '</p>';
+            tmpHighlightsHTML += '</div>';
+          }
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Highlights', tmpHighlightsHTML);
+
+          // Render action buttons
+          let tmpActionsHTML = '';
+          let tmpDocProvider = this.pict.providers['Docuserve-Documentation'];
+          for (let i = 0; i < pCover.Actions.length; i++) {
+            let tmpAction = pCover.Actions[i];
+            let tmpClass = i === 0 ? 'primary' : 'secondary';
+            let tmpHref = tmpAction.Href;
+
+            // External links open in new tab
+            if (tmpHref.match(/^https?:\/\//)) {
+              tmpActionsHTML += '<a class="' + tmpClass + '" href="' + this.escapeHTML(tmpHref) + '" target="_blank" rel="noopener">' + this.escapeHTML(tmpAction.Text) + '</a>';
+            } else {
+              // Internal links go through the app router
+              let tmpRoute = tmpDocProvider.convertSidebarLink(tmpHref);
+              tmpActionsHTML += '<a class="' + tmpClass + '" href="' + this.escapeHTML(tmpRoute) + '">' + this.escapeHTML(tmpAction.Text) + '</a>';
+            }
+          }
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Actions', tmpActionsHTML);
+        }
+
+        /**
+         * Render the splash screen from catalog data as a fallback when cover.md
+         * is not available.
+         *
+         * @param {Object} pDocuserve - The AppData.Docuserve state
+         */
+        renderFromCatalog(pDocuserve) {
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Title', 'Retold');
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Tagline', 'Documentation');
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Description', '');
+
+          // Build highlight cards from catalog groups
+          let tmpHighlightsHTML = '';
+          let tmpGroups = pDocuserve.SidebarGroups || [];
+          for (let i = 0; i < tmpGroups.length; i++) {
+            let tmpGroup = tmpGroups[i];
+            // Skip groups with no modules (like "Home" or "Getting Started")
+            if (!tmpGroup.Modules || tmpGroup.Modules.length < 1) {
+              continue;
+            }
+            let tmpDescription = tmpGroup.Description || tmpGroup.Modules.length + ' modules';
+            tmpHighlightsHTML += '<div class="docuserve-splash-highlight-card">';
+            tmpHighlightsHTML += '<h3>' + this.escapeHTML(tmpGroup.Name) + '</h3>';
+            tmpHighlightsHTML += '<p>' + this.escapeHTML(tmpDescription) + '</p>';
+            tmpHighlightsHTML += '</div>';
+          }
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Highlights', tmpHighlightsHTML);
+
+          // Default action buttons
+          this.pict.ContentAssignment.assignContent('#Docuserve-Splash-Actions', '');
+        }
+
+        /**
+         * Escape HTML special characters.
+         *
+         * @param {string} pText - The text to escape
+         * @returns {string} The escaped text
+         */
+        escapeHTML(pText) {
+          if (!pText) {
+            return '';
+          }
+          return pText.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+        }
+      }
+      module.exports = DocusserveSplashView;
+      module.exports.default_configuration = _ViewConfiguration;
+    }, {
+      "pict-view": 8
+    }],
+    16: [function (require, module, exports) {
+      const libPictView = require('pict-view');
+      const _ViewConfiguration = {
+        ViewIdentifier: "Docuserve-TopBar",
+        DefaultRenderable: "Docuserve-TopBar-Content",
+        DefaultDestinationAddress: "#Docuserve-TopBar-Container",
+        AutoRender: false,
+        CSS: /*css*/"\n\t\t.docuserve-topbar {\n\t\t\tdisplay: flex;\n\t\t\talign-items: center;\n\t\t\tjustify-content: space-between;\n\t\t\tbackground-color: #2c3e50;\n\t\t\tcolor: #ecf0f1;\n\t\t\tpadding: 0 1.5em;\n\t\t\theight: 56px;\n\t\t\tbox-shadow: 0 2px 4px rgba(0, 0, 0, 0.15);\n\t\t\tposition: sticky;\n\t\t\ttop: 0;\n\t\t\tz-index: 100;\n\t\t}\n\t\t.docuserve-topbar-brand {\n\t\t\tfont-size: 1.25em;\n\t\t\tfont-weight: 600;\n\t\t\tletter-spacing: 0.02em;\n\t\t\tcolor: #ecf0f1;\n\t\t\ttext-decoration: none;\n\t\t\tcursor: pointer;\n\t\t}\n\t\t.docuserve-topbar-brand:hover {\n\t\t\tcolor: #fff;\n\t\t}\n\t\t.docuserve-topbar-nav {\n\t\t\tdisplay: flex;\n\t\t\talign-items: center;\n\t\t\tgap: 0.25em;\n\t\t}\n\t\t.docuserve-topbar-nav a {\n\t\t\tcolor: #bdc3c7;\n\t\t\ttext-decoration: none;\n\t\t\tpadding: 0.5em 0.75em;\n\t\t\tborder-radius: 4px;\n\t\t\tfont-size: 0.9em;\n\t\t\ttransition: background-color 0.15s, color 0.15s;\n\t\t\tcursor: pointer;\n\t\t}\n\t\t.docuserve-topbar-nav a:hover {\n\t\t\tbackground-color: #34495e;\n\t\t\tcolor: #fff;\n\t\t}\n\t\t.docuserve-topbar-links {\n\t\t\tdisplay: flex;\n\t\t\talign-items: center;\n\t\t\tgap: 0.5em;\n\t\t}\n\t\t.docuserve-topbar-links a {\n\t\t\tcolor: #95a5a6;\n\t\t\ttext-decoration: none;\n\t\t\tfont-size: 0.85em;\n\t\t\tpadding: 0.4em 0.6em;\n\t\t\tborder-radius: 4px;\n\t\t\ttransition: background-color 0.15s, color 0.15s;\n\t\t}\n\t\t.docuserve-topbar-links a:hover {\n\t\t\tbackground-color: #34495e;\n\t\t\tcolor: #ecf0f1;\n\t\t}\n\t\t.docuserve-topbar-toggle {\n\t\t\tdisplay: none;\n\t\t\tbackground: none;\n\t\t\tborder: none;\n\t\t\tcolor: #bdc3c7;\n\t\t\tfont-size: 1.3em;\n\t\t\tcursor: pointer;\n\t\t\tpadding: 0.3em 0.5em;\n\t\t\tmargin-left: 0.5em;\n\t\t\tline-height: 1;\n\t\t}\n\t\t.docuserve-topbar-toggle:hover {\n\t\t\tcolor: #fff;\n\t\t}\n\t\t.docuserve-topbar-right {\n\t\t\tdisplay: flex;\n\t\t\talign-items: center;\n\t\t}\n\t",
+        Templates: [{
+          Hash: "Docuserve-TopBar-Template",
+          Template: /*html*/"\n<div class=\"docuserve-topbar\">\n\t<a id=\"Docuserve-TopBar-Brand\" class=\"docuserve-topbar-brand\" href=\"#/Home\"></a>\n\t<div id=\"Docuserve-TopBar-Nav\" class=\"docuserve-topbar-nav\"></div>\n\t<div class=\"docuserve-topbar-right\">\n\t\t<div id=\"Docuserve-TopBar-Links\" class=\"docuserve-topbar-links\"></div>\n\t\t<button id=\"Docuserve-TopBar-Toggle\" class=\"docuserve-topbar-toggle\" onclick=\"{~P~}.views['Docuserve-Sidebar'].toggleSidebar()\">&#9776;</button>\n\t</div>\n</div>\n"
+        }],
+        Renderables: [{
+          RenderableHash: "Docuserve-TopBar-Content",
+          TemplateHash: "Docuserve-TopBar-Template",
+          DestinationAddress: "#Docuserve-TopBar-Container",
+          RenderMethod: "replace"
+        }]
+      };
+      class DocuserveTopBarView extends libPictView {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+        }
+        onAfterRender(pRenderable, pRenderDestinationAddress, pRecord, pContent) {
+          this.renderTopBarContent();
+          return super.onAfterRender(pRenderable, pRenderDestinationAddress, pRecord, pContent);
+        }
+
+        /**
+         * Populate the top bar from _topbar.md data or fall back to defaults.
+         */
+        renderTopBarContent() {
+          let tmpDocuserve = this.pict.AppData.Docuserve;
+          let tmpBrandEl = document.getElementById('Docuserve-TopBar-Brand');
+          let tmpNavEl = document.getElementById('Docuserve-TopBar-Nav');
+          let tmpLinksEl = document.getElementById('Docuserve-TopBar-Links');
+          if (!tmpBrandEl || !tmpNavEl || !tmpLinksEl) {
+            return;
+          }
+          if (tmpDocuserve.TopBarLoaded && tmpDocuserve.TopBar) {
+            // Data-driven from _topbar.md
+            let tmpTopBar = tmpDocuserve.TopBar;
+
+            // Brand
+            tmpBrandEl.textContent = tmpTopBar.Brand || 'Documentation';
+
+            // Navigation links (centre)
+            let tmpNavHTML = '<a href="#/Home">Home</a>';
+            for (let i = 0; i < tmpTopBar.NavLinks.length; i++) {
+              let tmpLink = tmpTopBar.NavLinks[i];
+              tmpNavHTML += '<a href="' + tmpLink.Href + '">' + this.escapeHTML(tmpLink.Text) + '</a>';
+            }
+            tmpNavEl.innerHTML = tmpNavHTML;
+
+            // External links (right side)
+            let tmpLinksHTML = '';
+            for (let i = 0; i < tmpTopBar.ExternalLinks.length; i++) {
+              let tmpLink = tmpTopBar.ExternalLinks[i];
+              tmpLinksHTML += '<a href="' + this.escapeHTML(tmpLink.Href) + '" target="_blank" rel="noopener">' + this.escapeHTML(tmpLink.Text) + '</a>';
+            }
+            tmpLinksEl.innerHTML = tmpLinksHTML;
+          } else {
+            // Fallback: use brand from cover or a default, and just show Home
+            let tmpBrand = 'Documentation';
+            if (tmpDocuserve.CoverLoaded && tmpDocuserve.Cover && tmpDocuserve.Cover.Title) {
+              tmpBrand = tmpDocuserve.Cover.Title;
+            } else if (tmpDocuserve.CatalogLoaded && tmpDocuserve.Catalog && tmpDocuserve.Catalog.Name) {
+              tmpBrand = tmpDocuserve.Catalog.Name;
+            }
+            tmpBrandEl.textContent = tmpBrand;
+            tmpNavEl.innerHTML = '<a href="#/Home">Home</a>';
+            tmpLinksEl.innerHTML = '';
+          }
+        }
+
+        /**
+         * Escape HTML special characters.
+         */
+        escapeHTML(pText) {
+          if (!pText) {
+            return '';
+          }
+          return pText.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+        }
+      }
+      module.exports = DocuserveTopBarView;
+      module.exports.default_configuration = _ViewConfiguration;
+    }, {
+      "pict-view": 8
+    }]
+  }, {}, [10])(10);
+});
+//# sourceMappingURL=pict-docuserve.js.map