0.16.0 sisudoc (src/sisudoc sisudoc spine)

- src/sisudoc (replaces src/doc_reform)
- sisudoc spine (used more)

3 files changed, 1563 insertions, 0 deletions

diff --git a/src/sisudoc/io_in/paths_source.d b/src/sisudoc/io_in/paths_source.d
new file mode 100644
index 0000000..071abff
--- /dev/null
+++ b/src/sisudoc/io_in/paths_source.d
@@ -0,0 +1,888 @@
+/+
+- Name: SisuDoc Spine, Doc Reform [a part of]
+  - Description: documents, structuring, processing, publishing, search
+    - static content generator
+
+  - Author: Ralph Amissah
+    [ralph.amissah@gmail.com]
+
+  - Copyright: (C) 2015 - 2024 Ralph Amissah, All Rights Reserved.
+
+  - License: AGPL 3 or later:
+
+    Spine (SiSU), a framework for document structuring, publishing and
+    search
+
+    Copyright (C) Ralph Amissah
+
+    This program is free software: you can redistribute it and/or modify it
+    under the terms of the GNU AFERO General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    This program is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+    more details.
+
+    You should have received a copy of the GNU General Public License along with
+    this program. If not, see [https://www.gnu.org/licenses/].
+
+    If you have Internet connection, the latest version of the AGPL should be
+    available at these locations:
+    [https://www.fsf.org/licensing/licenses/agpl.html]
+    [https://www.gnu.org/licenses/agpl.html]
+
+  - Spine (by Doc Reform, related to SiSU) uses standard:
+    - docReform markup syntax
+      - standard SiSU markup syntax with modified headers and minor modifications
+    - docReform object numbering
+      - standard SiSU object citation numbering & system
+
+  - Homepages:
+    [https://www.sisudoc.org]
+    [https://www.doc-reform.org]
+
+  - Git
+    [https://git.sisudoc.org/]
+
++/
+/++
+  read configuration files<BR>
+  - read config files<BR>
+  meta_config_files.d
++/
+module sisudoc.io_in.paths_source;
+@safe:
+import
+  std.array,
+  std.file,
+  std.path,
+  std.regex,
+  std.stdio,
+  std.conv : to;
+import
+  sisudoc.meta.defaults,
+  sisudoc.meta.rgx_files;
+template PodManifest() {
+  mixin spineRgxFiles;
+  static auto rgx_files = RgxFiles();
+  auto PodManifest(O)(
+    O       _opt_action,
+    string  _pth=""
+  ) {
+    struct ManifestFile_ {
+      string pod_manifest_filename() {
+        return "pod.manifest";
+      }
+      string pod_manifest_path() {
+        string _manifest_path;
+        if ((isValidPath(_pth) && exists(_pth) != 0 && _pth.isDir)
+        && (exists(_pth.chainPath(pod_manifest_filename).array) != 0
+        && (_pth.chainPath(pod_manifest_filename).array).isFile)) {
+          _manifest_path = _pth;
+        } else if (_pth.match(rgx_files.src_pth_contents)
+        && exists(_pth) != 0 && _pth.isFile) {
+          _manifest_path = _pth.dirName;
+        } else if (_pth.match(rgx_files.src_pth_pod_sst_or_ssm)
+        && exists(_pth) != 0 && (_pth.isFile)) {
+          if (auto m = _pth.match(rgx_files.src_pth_pod_sst_or_ssm)) {
+            _manifest_path = m.captures["podpath"];
+          }
+        } else  {
+          if (_opt_action.vox_gt1 || _opt_action.debug_do) {
+            writeln("WARNING, src is not a pod, issue with manifest_path: ", _pth); // remove? unless can distinguish pod
+          }
+          _manifest_path = "";
+        }
+        return _manifest_path;
+      }
+      string pods_collection_root_path() {
+        return (pod_manifest_path.length > 0) ? ((chainPath(pod_manifest_path, "..")).asNormalizedPath).array.to!string : "";
+      }
+      string pod_manifest_file_with_path() {
+        string _k;
+        if  (exists(pod_manifest_path.chainPath(pod_manifest_filename).array)!=0) {
+          _k = pod_manifest_path.chainPath(pod_manifest_filename).array;
+        } else if (exists(pod_manifest_path)!=0) {
+          _k = pod_manifest_path;
+        }
+        if (exists(_k)==0) {
+          writeln("ERROR >> Processing Skipped! Manifest not found: ", _k);
+          _k = null;
+        }
+        return _k;
+      }
+    }
+    return ManifestFile_();
+  }
+}
+template PathMatters() {
+  mixin InternalMarkup;
+  mixin spineRgxFiles;
+  static auto rgx_files = RgxFiles();
+  static auto mkup = InlineMarkup();
+  auto PathMatters(O,E)(
+    O        _opt_action,
+    E        _env,
+    string   _pth,
+    string   _fns              = "",
+    char[][] _manifest_fn_list = [[]],
+  ) {
+    auto _manifested = PodManifest!()(_opt_action, _pth);
+    struct ManifestMatters_ {
+      auto env() {
+        auto _env = _env;
+        struct Env_ {
+          auto pwd() {
+            return _env["pwd"];
+          }
+          auto home() {
+            return _env["home"];
+          }
+        }
+        return Env_();
+      }
+      auto opt() {
+        struct Opt_ {
+          auto action() {
+            return _opt_action;
+          }
+        }
+        return Opt_();
+      }
+      bool src_is_pod() {
+        return (_manifested.pod_manifest_path.length > 0) ? true : false;
+      }
+      auto pod() {
+        struct Pod_ {
+          bool src_is_pod() {
+            return (_manifested.pod_manifest_path.length > 0) ? true : false;
+          }
+          string collection_root() {
+            return _manifested.pods_collection_root_path;
+          }
+          string manifest_filename() {
+            return _manifested.pod_manifest_filename;
+          }
+          string manifest_path() {
+            return _manifested.pod_manifest_path;
+          }
+          string pod_name_with_path() {
+            return _manifested.pod_manifest_path.baseName;
+          }
+          string manifest_file_with_path() {
+            return _manifested.pod_manifest_file_with_path;
+          }
+          string[] config_dr_document_make_dirs() {
+            string[] _config_dirs;
+            return _config_dirs;
+          }
+          string[] config_local_site_dirs() {
+            string[] _config_dirs;
+            return _config_dirs;
+          }
+          string[] image_dirs() {
+            string[] _image_dirs;
+            return _image_dirs;
+          }
+          auto manifest_list_of_filenames() {
+            return _manifest_fn_list;
+          }
+          string[] manifest_list_of_languages() {
+            string[] _lngs;
+            foreach (filename_; manifest_list_of_filenames) {
+              string _k = "en";
+              if (auto m = (filename_).match(rgx_files.language_code_and_filename)) {
+                _k = m.captures[1].to!string;
+              }
+              _lngs ~= _k; // all the languages from the manifest list of filenames with paths
+            }
+            return _lngs;
+          }
+        }
+        return Pod_();
+      }
+      auto src() {
+        string _fns = _fns; // required here by dmd & not by ldc (for D:2078)
+        auto _opt_action = _opt_action;
+        auto _env = _env;
+        struct SRC_ {
+          bool is_pod() {
+            return (_manifested.pod_manifest_path.length > 0) ? true : false;
+          }
+          string path_and_fn() {
+            return _fns;
+          }
+          string pod_name_with_path() {
+            return (is_pod) ? _manifested.pod_manifest_path : "";
+          }
+          string pods_collection_root_path() {
+            return (is_pod) ? _manifested.pods_collection_root_path : "";
+          }
+          string pod_name() {
+            return pod_name_with_path.baseName;
+          }
+          string filename() {
+            return path_and_fn.baseName;
+          }
+          string filename_base() {
+            return filename.stripExtension;
+          }
+          string filename_extension() {
+            return filename.match(rgx_files.src_pth_sst_or_ssm).captures["extension"];
+          }
+          string lng() {
+            string _k;
+            if (auto m = path_and_fn.match(rgx_files.language_code_and_filename)) {
+              _k = m.captures[1];
+            } else {_k = "en"; }
+            return _k;
+          }
+          string doc_uid() {
+            string _uid;
+            if (is_pod && !(pod_name_with_path.empty)) {
+              if (pod_name_with_path.baseName == filename_base) {
+                _uid = filename_base ~ "." ~ filename_extension ~ mkup.uid_sep ~ lng;
+              } else {
+                _uid = pod_name_with_path.baseName ~ mkup.uid_sep ~ filename_base ~ "." ~ filename_extension ~ mkup.uid_sep ~ lng;
+              }
+            } else {
+              _uid = mkup.uid_sep ~ filename_base ~ "." ~ filename_extension ~ mkup.uid_sep ~ lng;
+            }
+            return _uid;
+          }
+          string doc_uid_out() {
+            string _uid;
+            if (is_pod && !(pod_name_with_path.empty)) {
+              if (pod_name_with_path.baseName == filename_base) {
+                _uid = filename_base ~ "." ~ lng;
+              } else {
+                _uid = pod_name_with_path.baseName ~ mkup.uid_sep ~ filename_base ~ "." ~ lng;
+              }
+            } else {
+              _uid = "_" ~ filename_base ~ "." ~ lng;
+            }
+            return _uid;
+          }
+          string docname_composite_unique_per_src_doc() {
+            string _fn;
+            if (pod_name_with_path.baseName == filename_base) {
+              _fn = filename_base ~ mkup.uid_sep ~ filename_extension ~ mkup.uid_sep ~ lng;
+            } else if (!(pod_name_with_path.empty)) {
+              _fn = pod_name_with_path.baseName ~ mkup.uid_sep ~ filename_base ~ mkup.uid_sep ~ filename_extension ~ mkup.uid_sep ~ lng;
+            } else {
+              _fn = "_" ~ mkup.uid_sep ~ filename_base ~ mkup.uid_sep ~ filename_extension ~ mkup.uid_sep ~ lng;
+            }
+            return _fn;
+          }
+          string docname_composite_unique_per_src_pod() {
+          /+
+            z pod name if any + src filename (without lng code)
+             filename ~ mkup.uid_sep ~ lng
+             * unique per src pod
+             used by
+             - pod (multilingual collection)
+             - sqlite discrete index (multilingual collection)
+          +/
+            string _fn;
+            if (pod_name_with_path.baseName == filename_base) {
+              _fn = filename_base ~ mkup.uid_sep ~ filename_extension;
+            } else if (!(pod_name_with_path.empty)) {
+              _fn = pod_name_with_path.baseName ~ mkup.uid_sep ~ filename_base ~ mkup.uid_sep ~ filename_extension;
+            } else {
+              _fn = "_" ~ mkup.uid_sep ~ filename_base ~ mkup.uid_sep ~ filename_extension;
+            }
+            return _fn;
+          }
+          string language() {
+            return lng();
+          }
+          string file_with_absolute_path() {
+            return _env["pwd"].chainPath(path_and_fn).array;
+          }
+          string absolute_path_to_src() {
+            return (_env["pwd"].chainPath(path_and_fn)).dirName.array;
+          }
+          string path_to_doc_root_path_to_lang_and_filename() {
+            return _env["pwd"].chainPath(path_and_fn).array;
+          }
+          string base_dir() {
+            string _dir;
+            if (
+              auto m = (absolute_path_to_src)
+              .match(regex(r"[/](?P<dir>(?:[a-zA-Z0-9._-]+))/pod/" ~ filename.stripExtension))
+            ) {
+              _dir = ((path_and_fn.chainPath("../../")).asNormalizedPath).array;
+              assert(_dir == m.captures["dir"]);
+            } else {
+              _dir = ((path_and_fn.chainPath("../../../")).asNormalizedPath).array;
+              assert(_dir == absolute_path_to_src
+                .match(rgx_files.src_base_parent_dir_name).captures["dir"]);
+            }
+            if (_opt_action.debug_do) {
+              writeln("--> (base_dir)  ", _dir);
+            }
+            return _dir;
+          }
+          string base_parent_dir_path() {
+            string _dir;
+            if (
+              auto m = (absolute_path_to_src)
+              .match(regex(r"[/](?P<dir>(?:[a-zA-Z0-9._-]+))/pod/" ~ filename.stripExtension))
+            ) {
+              _dir = ((path_and_fn.chainPath("../../")).asNormalizedPath).array;
+            } else {
+              _dir = ((path_and_fn.chainPath("../../../")).asNormalizedPath).array;
+            }
+            return _dir;
+          }
+          string base_dir_path() {
+            string _dir;
+            if (
+              auto m = (absolute_path_to_src)
+              .match(rgx_files.src_formalised_file_path_parts)
+            ) {
+              _dir = ((m.captures["pth"]).asNormalizedPath).array;
+            } else if (
+             auto m = (absolute_path_to_src)
+             .match(regex(r"[/](?P<dir>(?:[a-zA-Z0-9._-]+))/pod/" ~ filename.stripExtension))
+            ) {
+              _dir = ((path_and_fn.chainPath("../")).asNormalizedPath).array;
+            } else {
+              _dir = ((path_and_fn.chainPath("../../")).asNormalizedPath).array;
+            }
+            if (_opt_action.debug_do) {
+              writeln("--> (base_dir_path) ", _dir);
+            }
+            return _dir;
+          }
+          string media_dir_path() {
+            string _dir = ((base_dir_path.chainPath("media")).asNormalizedPath).array;
+            return _dir;
+          }
+          string image_dir_path() {
+            string _paths;
+            string[] _possible_img_pths = [ "./image", "../image", "../../image" ];
+            string _img_pth_found = "";
+            if (is_pod) {
+              _img_pth_found = ((file_with_absolute_path.dirName ~ "/../../image").asNormalizedPath).array;
+            } else {
+              string _img_pth(string _possible_img_pth) {
+                return ((file_with_absolute_path.dirName ~ "/" ~ _possible_img_pth).asNormalizedPath).array;
+              }
+              foreach(_possible_img_pth; _possible_img_pths) {
+                if (exists(_img_pth(_possible_img_pth))) {
+                  _img_pth_found = _img_pth(_possible_img_pth);
+                  break;
+                } else {
+                  _paths ~= " " ~ _img_pth(_possible_img_pth);
+                }
+              }
+            }
+            if (_img_pth_found.empty) {
+              writeln("WARNING not image path found, searched: ", _paths);
+            }
+            return _img_pth_found;
+          }
+          auto conf_dir_path() {
+            return ((base_dir_path.chainPath("conf")).asNormalizedPath).array;
+          }
+          auto base_parent_dir() {
+            string _dir;
+            if (
+              auto m = (absolute_path_to_src)
+              .match(regex(r"[/](?P<dir>(?:[a-zA-Z0-9._-]+))/pod/" ~ filename.stripExtension))
+            ) {
+              _dir = m.captures["dir"];
+            } else {
+              _dir = (absolute_path_to_src).match(rgx_files.src_base_parent_dir_name).captures["dir"];
+            }
+            if (_opt_action.debug_do) {
+              writeln("--> (base_parent_dir) ", _dir);
+            }
+            return _dir;
+          }
+          string[] config_dirs() {
+            string[] _config_dirs;
+            if (is_pod) {
+            } else {}
+            return _config_dirs;
+          }
+          string[] image_dirs() {
+            string[] _image_dirs;
+            if (is_pod) {
+            } else {}
+            return _image_dirs;
+          }
+        }
+        return SRC_();
+      }
+      auto output() {
+        /+
+          - command line if output path set
+          - config file if found and set set
+            - search for and if exists read config
+              - default paths to config related to:
+                - source markup path;
+                - current dir;
+                - home dir
+              - get output path if set
+          - (program) default within current directory?
+        +/
+        auto _env = _env;
+        struct Out_ {
+          auto path() {
+            auto _output_path = _env["pwd"];
+            if ((_opt_action.output_dir_set.length > 0)
+              && isValidPath(_opt_action.output_dir_set)
+            ) {
+              _output_path = ((_opt_action.output_dir_set).asNormalizedPath).array;
+              if (!exists(_output_path)) {
+                try {
+                  _output_path.mkdirRecurse;
+                // } catch (ErrnoException ex) {
+                } catch (Exception ex) {
+                  // Handle error
+                }
+              }
+              assert(_output_path.isDir,
+                "not a directory: " ~ _output_path);
+              // TODO always test that is a directory and it is writable
+            }
+            return _output_path;
+          }
+        }
+        return Out_();
+      }
+    }
+    return ManifestMatters_();
+  }
+}
+template configFilePaths() {
+  auto configFilePaths(M,E)(
+    M      _manifested,
+    E      _env,
+    string _cli_config_path_set = ""
+  ) {
+    struct ConfFilePaths {
+      string config_filename_document() {
+        return "dr_document_make";
+      }
+      string config_filename_site() {
+        return "config_local_site";
+      }
+      auto possible_config_path_locations() {
+        struct _ConfFilePaths {
+          string[] dr_document_make() {
+            /+ FIX clean up conf paths ↓ +/
+            /+ config local site (file system only, not in pod) +/
+            /+ return paths +/
+            string[] _possible_config_path_locations;
+            if (_cli_config_path_set.empty) {
+              if (_manifested.src.is_pod) {
+                /+ config document in pod +/
+                string _dr_doc_conf_pod;
+                string _dr_doc_conf_pod_text;
+                _dr_doc_conf_pod = asNormalizedPath(chainPath(
+                  to!string(_env["pwd"]),
+                  _manifested.pod.manifest_path ~ "/conf"
+                )).array;
+                _dr_doc_conf_pod_text = asNormalizedPath(chainPath(
+                  to!string(_env["pwd"]),
+                  _manifested.pod.manifest_path ~ "/media/text/" ~ _manifested.src.lng ~ "/conf"
+                )).array;
+                /+ return paths +/
+                _possible_config_path_locations = [
+                  _dr_doc_conf_pod_text,
+                  _dr_doc_conf_pod,
+                ];
+              } else {
+                /+ config document (& or local site) on filesystem +/
+                string _dr_doc_conf_pwd   = ((chainPath(to!string(_env["pwd"]), "dr_doc/conf")).asNormalizedPath).array; // think about
+                string _dr_doc_conf_pwd_a = ((chainPath(to!string(_env["pwd"]), "conf")).asNormalizedPath).array;
+                string _dr_doc_conf_pwd_b = ((chainPath(to!string(_env["pwd"]), "../conf")).asNormalizedPath).array;
+                string _dr_doc_conf_pwd_c = ((chainPath(to!string(_env["pwd"]), "../../conf")).asNormalizedPath).array;
+                string _dr_doc_conf_pwd_d = ((chainPath(to!string(_env["pwd"]), "../../../conf")).asNormalizedPath).array;
+                /+ return paths +/
+                _possible_config_path_locations = [
+                  _dr_doc_conf_pwd,
+                  _dr_doc_conf_pwd_a,
+                  _dr_doc_conf_pwd_b,
+                  _dr_doc_conf_pwd_c,
+                  _dr_doc_conf_pwd_d,
+                ];
+              }
+            } else if (_cli_config_path_set.isDir) {
+               _possible_config_path_locations = [_cli_config_path_set ];
+            // } else if (_cli_config_path_set.isFile) { // use file, taken care of elsewhere
+            }
+            /+ FIX clean up conf paths ↑
+            (compare pwd to doc path location, and build config path)
+            +/
+            return _possible_config_path_locations;
+          }
+          string[] config_local_site() {
+            /+ FIX clean up conf paths ↓ +/
+            /+ config local site (file system only, not in pod) +/
+            string[] _possible_config_path_locations;
+            if (_cli_config_path_set.empty) {
+              string _dot_pwd        = ((chainPath(to!string(_env["pwd"]), ".dr")).asNormalizedPath).array;
+              string _underscore_pwd = ((chainPath(to!string(_env["pwd"]), "_dr")).asNormalizedPath).array;
+              string _dot_home       = ((chainPath(to!string(_env["home"]), ".dr")).asNormalizedPath).array;
+              /+ return paths +/
+              if (_manifested.src.is_pod) {
+                string _collection_root_a = ((chainPath(to!string(_manifested.pod.collection_root.to!string), ".dr")).asNormalizedPath).array;
+                string _collection_root_b = ((chainPath(to!string(_manifested.pod.collection_root.to!string), "_dr")).asNormalizedPath).array;
+                _possible_config_path_locations = [
+                  _dot_pwd,
+                  _underscore_pwd,
+                  _collection_root_a,
+                  _collection_root_b,
+                  _dot_home,
+                  "/etc/dr",
+                ];
+              } else {
+                /+ config document (& or local site) on filesystem +/
+                string _dr_doc_conf_pwd   = ((chainPath(to!string(_env["pwd"]), "dr_doc/conf")).asNormalizedPath).array;
+                string _dr_doc_conf_pwd_a = ((chainPath(to!string(_env["pwd"]), "conf")).asNormalizedPath).array;
+                string _dr_doc_conf_pwd_b = ((chainPath(to!string(_env["pwd"]), "../conf")).asNormalizedPath).array;
+                string _dr_doc_conf_pwd_c = ((chainPath(to!string(_env["pwd"]), "../../conf")).asNormalizedPath).array;
+                string _dr_doc_conf_pwd_d = ((chainPath(to!string(_env["pwd"]), "../../../conf")).asNormalizedPath).array;
+                _possible_config_path_locations = [
+                  _dr_doc_conf_pwd,
+                  _dr_doc_conf_pwd_a,
+                  _dr_doc_conf_pwd_b,
+                  _dr_doc_conf_pwd_c,
+                  _dr_doc_conf_pwd_d,
+                  _dot_pwd,
+                  _underscore_pwd,
+                  _dot_home,
+                  "/etc/dr"
+                ];
+              }
+            } else {
+              _possible_config_path_locations = [
+                _cli_config_path_set
+              ];
+            }
+            /+ FIX clean up conf paths ↑
+            (compare pwd to doc path location, and build config path)
+            +/
+            return _possible_config_path_locations;
+          }
+        }
+        return _ConfFilePaths();
+      }
+    }
+    return ConfFilePaths();
+  }
+}
+template spinePathsSRC() {
+  mixin spineRgxFiles;
+  static auto rgx_files = RgxFiles();
+  auto spinePathsSRC(D,Fn)(
+    D   _pwd,
+    Fn  _fn_src_and_path,
+  ) {
+    struct drSrcPaths {
+      auto pwd() {
+        return _pwd;
+      }
+      string language() {
+        // use command line info as well?
+        string _k;
+        if (auto m = _fn_src_and_path.match(rgx_files.language_code_and_filename)) {
+          _k = m.captures[1];
+        } else { /+ unknown until doc_meta read, (could provide & use command line info?) +/
+          _k = "xx"; // original default was "en" but is not known
+        }
+        return _k;
+      }
+      string doc_root() {
+        return "dr_doc";
+      }
+      auto media_root() {
+        return ((doc_root.chainPath("media")).asNormalizedPath).array;
+      }
+      auto conf_root() {
+        return ((doc_root.chainPath("conf")).asNormalizedPath).array;
+      }
+      auto text_root() {
+        return ((media_root.chainPath("text")).asNormalizedPath).array;
+      }
+      auto image_root() {
+        return ((media_root.chainPath("image")).asNormalizedPath).array;
+      }
+      auto doc_src_fn_with_path_for_text_root_and_lng() {
+        return ((text_root.chainPath(language)).asNormalizedPath).array;
+      }
+      auto doc_src_fn() {
+        return ((_fn_src_and_path.baseName).asNormalizedPath).array;
+      }
+      auto doc_src_with_path() {
+        return ((pwd.chainPath(_fn_src_and_path)).asNormalizedPath).array;
+      }
+    }
+    return drSrcPaths();
+  }
+}
+
+
+template spinePathsPods() {
+  string _suffix = ".zip";
+  auto spinePathsPods(M)(M doc_matters) {
+    string _base_dir_pod = (doc_matters.output_path.length > 0)
+    ? doc_matters.output_path ~ "/pod"
+    : "/pod";
+    string _base_dir_doc = "dr_doc";
+    struct _PodPaths {
+      string base_filename_(string fn_src) {
+        return  fn_src.baseName.stripExtension;
+      }
+      string internal_base() {
+        return "pod";
+      }
+      string pod_dir_() {
+        return _base_dir_pod;
+      }
+      string dr_doc_dir_() {
+        return _base_dir_doc;
+      }
+      string pod_filename_(string fn_src) {
+        return _base_dir_pod.chainPath(base_filename_(fn_src) ~ _suffix).array;
+      }
+      string base_filesystem_(string fn_src) {
+        string pth = _base_dir_pod.chainPath(base_filename_(fn_src)).array;
+        assert(pth == _base_dir_pod ~ "/"  ~ base_filename_(fn_src),
+          pth ~ " == "  ~ _base_dir_pod ~ "/" ~ base_filename_(fn_src) ~ "?");
+        return pth;
+      }
+      string output_pod_manifest_file(string fn_src) {
+        return base_filesystem_(fn_src).chainPath("pod.manifest").array;
+      }
+      string base_pod_(string fn_src) {
+        return _base_dir_pod.chainPath(base_filename_(fn_src)).array; // change this
+      }
+      auto base_filename(string fn_src) {
+        auto pth_1_ = base_filename_(fn_src);
+        auto pth_2_ = base_filename_(fn_src);
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto pod_filename(string fn_src) {
+        auto pth_1_ = pod_filename_(fn_src);
+        auto pth_2_ = pod_filename_(fn_src);
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto base(string fn_src) {
+        auto pth_1_ = "";
+        auto pth_2_ = base_filesystem_(fn_src);
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto pod_root(string fn_src) {
+        auto pth_1_ = "pod";
+        auto pth_2_ = ((base(fn_src).filesystem_open_zpod.chainPath("")).asNormalizedPath).array; // "dr_doc"
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto conf_root(string fn_src) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = "conf";
+        auto pth_2_ = ((pod_root(fn_src).filesystem_open_zpod.chainPath("conf")).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto css(string fn_src) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = ((conf_root(fn_src).zpod.chainPath("css")).asNormalizedPath).array;
+        auto pth_2_ = ((conf_root(fn_src).filesystem_open_zpod.chainPath("css")).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto pod_manifest(string fn_src) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = ((pod_root(fn_src).zpod.chainPath("pod.manifest")).asNormalizedPath).array;
+        auto pth_2_ = ((pod_root(fn_src).filesystem_open_zpod.chainPath("pod.manifest")).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto media_root(string fn_src) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = ((pod_root(fn_src).zpod.chainPath("media")).asNormalizedPath).array;
+        auto pth_2_ = ((pod_root(fn_src).filesystem_open_zpod.chainPath("media")).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto text_root(string fn_src) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = ((media_root(fn_src).zpod.chainPath("text")).asNormalizedPath).array;
+        auto pth_2_ = ((media_root(fn_src).filesystem_open_zpod.chainPath("text")).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto doc(string fn_src) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = text_root(fn_src).zpod;
+        auto pth_2_ = text_root(fn_src).filesystem_open_zpod;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto doc_lng(string fn_src, string lng) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = ((text_root(fn_src).zpod.chainPath(lng)).asNormalizedPath).array;
+        auto pth_2_ = ((text_root(fn_src).filesystem_open_zpod.chainPath(lng)).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto image_root(string fn_src) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = ((media_root(fn_src).zpod.chainPath("image")).asNormalizedPath).array;
+        auto pth_2_ = ((media_root(fn_src).filesystem_open_zpod.chainPath("image")).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto fn_pod_filelist(string fn_src) {
+        auto pod_root_ = pod_root(fn_src);
+        auto _manifested = PodManifest!()(doc_matters.opt.action, fn_src).pod_manifest_filename;
+        auto pth_1_ = _manifested;
+        auto pth_2_ = ((pod_root(fn_src).filesystem_open_zpod.chainPath(_manifested)).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto fn_doc(string fn_src, string lng) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = ((doc_lng(fn_src, lng).zpod.chainPath(fn_src.baseName)).asNormalizedPath).array;
+        auto pth_2_ = ((doc_lng(fn_src, lng).filesystem_open_zpod.chainPath(fn_src.baseName)).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+      auto fn_doc_insert(string fn_src, string fn_insert, string lng) {
+        auto pod_root_ = pod_root(fn_src);
+        auto pth_1_ = ((doc_lng(fn_src, lng).zpod.chainPath(fn_insert.baseName)).asNormalizedPath).array;
+        auto pth_2_ = ((doc_lng(fn_src, lng).filesystem_open_zpod.chainPath(fn_insert.baseName)).asNormalizedPath).array;
+        struct _pods {
+          auto zpod() {
+            return pth_1_;
+          }
+          auto filesystem_open_zpod() {
+            // assert(pod_root_.filesystem_open_zpod.chainPath(zpod).array == pth_2_);
+            return pth_2_;
+          }
+        }
+        return _pods();
+      }
+    }
+    return _PodPaths();
+  }
+}
diff --git a/src/sisudoc/io_in/read_config_files.d b/src/sisudoc/io_in/read_config_files.d
new file mode 100644
index 0000000..c71364c
--- /dev/null
+++ b/src/sisudoc/io_in/read_config_files.d
@@ -0,0 +1,279 @@
+/+
+- Name: SisuDoc Spine, Doc Reform [a part of]
+  - Description: documents, structuring, processing, publishing, search
+    - static content generator
+
+  - Author: Ralph Amissah
+    [ralph.amissah@gmail.com]
+
+  - Copyright: (C) 2015 - 2024 Ralph Amissah, All Rights Reserved.
+
+  - License: AGPL 3 or later:
+
+    Spine (SiSU), a framework for document structuring, publishing and
+    search
+
+    Copyright (C) Ralph Amissah
+
+    This program is free software: you can redistribute it and/or modify it
+    under the terms of the GNU AFERO General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    This program is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+    more details.
+
+    You should have received a copy of the GNU General Public License along with
+    this program. If not, see [https://www.gnu.org/licenses/].
+
+    If you have Internet connection, the latest version of the AGPL should be
+    available at these locations:
+    [https://www.fsf.org/licensing/licenses/agpl.html]
+    [https://www.gnu.org/licenses/agpl.html]
+
+  - Spine (by Doc Reform, related to SiSU) uses standard:
+    - docReform markup syntax
+      - standard SiSU markup syntax with modified headers and minor modifications
+    - docReform object numbering
+      - standard SiSU object citation numbering & system
+
+  - Homepages:
+    [https://www.sisudoc.org]
+    [https://www.doc-reform.org]
+
+  - Git
+    [https://git.sisudoc.org/]
+
++/
+/++
+  read configuration files<BR>
+  - read config files<BR>
+  meta_config_files.d
++/
+module sisudoc.io_in.read_config_files;
+@safe:
+import
+  std.file,
+  std.path;
+import
+  sisudoc.meta,
+  sisudoc.io_in.paths_source,
+  sisudoc.meta.rgx_files,
+  sisudoc.meta.rgx;
+template readConfigSite() {
+  @system final auto readConfigSite(Cf,O,Cfg)(Cf _conf_file_details, O _opt_action, Cfg _cfg) {
+    mixin spineRgxIn;
+    static auto rgx = RgxI();
+    string conf_filename = "NONE";
+    string config_file_str;
+    string default_config_file_str = format(q"┃
+flag:
+  act0:                  "--html"
+  act1:                  "--html --epub"
+output:
+  path:                  "%s"
+default:
+  language:              "en"
+  papersize:             "a4"
+  text_wrap:             "80"
+  digest:                "sha256"
+webserv:
+  http:                  "%s"
+  host:                  "%s"
+  data_http:             "%s"
+  data_host:             "%s"
+  data_root_url:         "%s"
+  data_root_path:        "%s"
+  data_root_part:        ""
+  images_root_part:      "image"
+  cgi_search_form_title: "%s"
+  cgi_http:              "%s"
+  cgi_host:              "%s"
+  cgi_bin_url:           "%s"
+  cgi_bin_subpath:       "%s"
+  cgi_bin_path:          "%s"
+  cgi_search_script:     "%s"
+  cgi_port:              ""
+  cgi_user:              ""
+  cgi_action:            "%s"
+  db_sqlite_path:        "%s"
+  db_sqlite_filename:    "%s"
+  db_pg_table:           ""
+  db_pg_user:            ""
+┃",
+  _cfg.processing_path_doc_root, // doc root
+  _cfg.http_request_type,        // http
+  _cfg.http_host,                // host / domain
+  _cfg.http_request_type,        // data "http" or "https"
+  _cfg.http_host,                // data domain "localhost"
+  _cfg.www_url_doc_root,         // data root url "http://locahost" "https://sisudoc.org"
+  _cfg.processing_path_doc_root, // data root path
+  _cfg.cgi_search_form_title,    // cgi title // e.g. "≅ SiSU Spine search"
+  _cfg.http_request_type,        // cgi http
+  _cfg.http_host,                // cgi host
+  _cfg.cgi_url_root,             // cgi bin url
+  _cfg.cgi_bin_subpath,          // cgi bin path
+  _cfg.cgi_bin_root,             // cgi bin path
+  _cfg.cgi_filename,             // cgi filename
+  _cfg.cgi_url_action,           // cgi action
+  _cfg.db_sqlite_path,           // sqlite db path
+  _cfg.db_sqlite_filename,       // sqlite db filename
+);
+    foreach(conf_fn; [_conf_file_details.config_filename_site]) {
+      foreach(pth; _conf_file_details.possible_config_path_locations.config_local_site) {
+        char[] conf_file;
+        conf_filename = conf_fn;
+        if (exists(pth)) {
+          auto f_attrib = pth.getLinkAttributes;
+          if (
+            _conf_file_details.possible_config_path_locations.config_local_site.length == 1
+            && f_attrib.attrIsFile
+          ) {
+            conf_file = pth.to!(char[]);
+            conf_filename = pth.baseName;
+          } else if (f_attrib.attrIsDir) {
+            conf_file = ((chainPath(pth.to!string, conf_fn)).asNormalizedPath).array;
+            conf_filename = conf_fn;
+          }
+          try {
+            if (exists(conf_file)) {
+              if (conf_file.getLinkAttributes.attrIsFile) {
+                if (_opt_action.vox_gt1 || _opt_action.debug_do) {
+                  writeln("config file used: \"", conf_file, "\" (cli flag settings override config file's individual settings)");
+                }
+                config_file_str = conf_file.readText;
+                break;
+              }
+            }
+          } catch (ErrnoException ex) {
+          } catch (FileException ex) {
+          }
+        }
+      }
+      if (config_file_str.length > 0) { break; }
+    }
+    if (config_file_str.length > 0) {
+      import dyaml;
+      Node yaml_root;
+      try {
+        yaml_root = Loader.fromString(config_file_str).load();
+      } catch (Throwable) {
+        import std.stdio;
+        writeln("ERROR failed to read config file content, not parsed as yaml, program default used");
+        conf_filename = "VIRTUAL";
+        config_file_str = default_config_file_str;
+      }
+    }
+    if (config_file_str.length == 0) { /+ use dummy default config file +/
+      // writeln("WARNING config file NOT found, default provided");
+      conf_filename = "VIRTUAL";
+      config_file_str = default_config_file_str;
+    }
+    struct _ConfContent {
+      string filename() {
+        return conf_filename;
+      }
+      string filetype() {
+        string _ft = "";
+        if (content.match(rgx.yaml_config)) {
+          _ft = "yaml";
+        }
+        return _ft;
+      }
+      string content() {
+        return config_file_str;
+      }
+    }
+    return _ConfContent();
+  }
+}
+static template readConfigDoc() {
+  import
+    std.file,
+    std.path;
+  import
+    sisudoc.meta,
+    sisudoc.io_in.paths_source,
+    sisudoc.meta.rgx_files,
+    sisudoc.meta.rgx;
+  @system final auto readConfigDoc(M,E)(M _manifested, E _env) {
+    mixin spineRgxIn;
+    static auto rgx = RgxI();
+    mixin spineRgxFiles;
+    static auto rgx_files = RgxFiles();
+    string config_file_str;
+    string conf_filename = "NONE";
+    auto _conf_file_details = configFilePaths!()(_manifested, _env);
+    string[] possible_config_path_locations = _conf_file_details.possible_config_path_locations.dr_document_make;
+    foreach(conf_fn; [_conf_file_details.config_filename_document]) {
+      foreach(pth; possible_config_path_locations) {
+        char[] conf_file = ((chainPath(pth.to!string, conf_fn)).asNormalizedPath).array;
+        conf_filename = conf_fn;
+        if (config_file_str.length > 0) {
+          break;
+        }
+        try {
+          if (exists(conf_file)) {
+            if (conf_file.getLinkAttributes.attrIsFile) {
+              config_file_str = conf_file.readText;
+              break;
+            }
+          }
+        } catch (ErrnoException ex) {
+        } catch (FileException ex) {
+        }
+      }
+      if (config_file_str.length > 0) { break; }
+    }
+    struct _ConfContent {
+      string filename() {
+        return conf_filename;
+      }
+      string content() {
+        return config_file_str;
+      }
+      string filetype() {
+        string _ft = "";
+        if (content.match(rgx.yaml_config)) {
+          _ft = "yaml";
+        }
+        return _ft;
+      }
+    }
+    return _ConfContent();
+  }
+}
+static template configReadSiteYAML() {
+  import
+    std.file,
+    std.path;
+  import
+    sisudoc.meta,
+    sisudoc.io_in.paths_source,
+    sisudoc.meta.rgx_files,
+    sisudoc.meta.rgx;
+  final YAMLDocument configReadSiteYAML(M,E)(M _manifested, E _env) {
+    string _configuration = configReadInSiteYAML!()(_manifested, _env);
+    auto _conf_file_details = configFilePaths!()(_manifested, _env);
+    string _conf_yaml_fn = _conf_file_details.config_filename_site;
+    YAMLDocument _yaml_conf = configYAML!()(_configuration, _conf_yaml_fn);
+    return _yaml_conf;
+  }
+}
+static template configReadDocYAML() {
+  import
+    std.file,
+    std.path;
+  import
+    sisudoc.meta,
+    sisudoc.io_in.paths_source;
+  final YAMLDocument configReadDocYAML(M,E)(M _manifested, E _env) {
+    string _configuration = configReadInDocYAML!()(_manifested, _env);
+    auto _conf_file_details = configFilePaths!()(_manifested, _env);
+    string _conf_yaml_fn = _conf_file_details.config_filename_document;
+    YAMLDocument _yaml_conf = configYAML!()(_configuration, _conf_yaml_fn);
+    return _yaml_conf;
+  }
+}
diff --git a/src/sisudoc/io_in/read_source_files.d b/src/sisudoc/io_in/read_source_files.d
new file mode 100644
index 0000000..4ba0b4f
--- /dev/null
+++ b/src/sisudoc/io_in/read_source_files.d
@@ -0,0 +1,396 @@
+/+
+- Name: SisuDoc Spine, Doc Reform [a part of]
+  - Description: documents, structuring, processing, publishing, search
+    - static content generator
+
+  - Author: Ralph Amissah
+    [ralph.amissah@gmail.com]
+
+  - Copyright: (C) 2015 - 2024 Ralph Amissah, All Rights Reserved.
+
+  - License: AGPL 3 or later:
+
+    Spine (SiSU), a framework for document structuring, publishing and
+    search
+
+    Copyright (C) Ralph Amissah
+
+    This program is free software: you can redistribute it and/or modify it
+    under the terms of the GNU AFERO General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    This program is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+    more details.
+
+    You should have received a copy of the GNU General Public License along with
+    this program. If not, see [https://www.gnu.org/licenses/].
+
+    If you have Internet connection, the latest version of the AGPL should be
+    available at these locations:
+    [https://www.fsf.org/licensing/licenses/agpl.html]
+    [https://www.gnu.org/licenses/agpl.html]
+
+  - Spine (by Doc Reform, related to SiSU) uses standard:
+    - docReform markup syntax
+      - standard SiSU markup syntax with modified headers and minor modifications
+    - docReform object numbering
+      - standard SiSU object citation numbering & system
+
+  - Homepages:
+    [https://www.sisudoc.org]
+    [https://www.doc-reform.org]
+
+  - Git
+    [https://git.sisudoc.org/]
+
++/
+/++
+  module source_read_source_files;<BR>
+  - open markup files<BR>
+  - if master file scan for addional files to import/insert
++/
+module sisudoc.io_in.read_source_files;
+@safe:
+template spineRawMarkupContent() {
+  import
+    std.file,
+    std.path;
+  import
+    sisudoc.meta,
+    sisudoc.io_in.paths_source,
+    sisudoc.meta.rgx_files,
+    sisudoc.meta.rgx;
+  mixin spineRgxIn;
+  static auto rgx = RgxI();
+  mixin spineRgxFiles;
+  static auto rgx_files = RgxFiles();
+  string[] _images=[];
+  string[] _extract_images(S)(S content_block) {
+    string[] images_;
+    string _content_block = content_block.to!string;
+    if (auto m = _content_block.matchAll(rgx.image)) {
+      images_ ~= m.captures[1].to!string;
+    }
+    return images_;
+  }
+  auto rawsrc = RawMarkupContent();
+  alias ContentsInsertsImages = Tuple!(
+    char[][], "contents",
+    string[], "insert_files",
+    string[], "images"
+  );
+  alias HeaderContentInsertsImages = Tuple!(
+    char[],   "header",
+    char[][], "src_txt",
+    string[], "insert_files",
+    string[], "images"
+  );
+  auto spineRawMarkupContent(O,Fn)(O _opt_action, Fn fn_src) {
+    auto _0_header_1_body_content_2_insert_filelist_tuple
+      = rawsrc.sourceContentSplitIntoHeaderAndBody(_opt_action, rawsrc.sourceContent(fn_src), fn_src);
+    return _0_header_1_body_content_2_insert_filelist_tuple;
+  }
+  struct RawMarkupContent {
+    final sourceContent(in string fn_src) {
+      auto raw = MarkupRawUnit();
+      string source_txt_str
+        = raw.markupSourceReadIn(fn_src);
+      return source_txt_str;
+    }
+    final auto sourceContentSplitIntoHeaderAndBody(O)(
+      O         _opt_action,
+      in string source_txt_str,
+      in string fn_src=""
+    ) {
+      auto raw = MarkupRawUnit();
+      string[] insert_file_list;
+      string[] images_list;
+      HeaderContentInsertsImages t
+        = raw.markupSourceHeaderContentRawLineTupleArray(source_txt_str);
+      char[] header_raw = t.header;
+      char[][] sourcefile_body_content = t.src_txt;
+      if (fn_src.match(rgx_files.src_fn_master)) { // filename with path needed if master file (.ssm) not otherwise
+        auto ins = Inserts();
+        ContentsInsertsImages tu
+          = ins.scan_master_src_for_insert_files_and_import_content(_opt_action, sourcefile_body_content, fn_src);
+        sourcefile_body_content = tu.contents;
+        insert_file_list = tu.insert_files.dup;
+        images_list = tu.images.dup;
+      } else if (_opt_action.source || _opt_action.pod) {
+        auto ins = Inserts();
+        ContentsInsertsImages tu
+          = ins.scan_master_src_for_insert_files_and_import_content(_opt_action, sourcefile_body_content, fn_src);
+        images_list = tu.images.dup;
+      }
+      string header_type = "";
+      t = tuple(
+        header_raw,
+        sourcefile_body_content,
+        insert_file_list,
+        images_list
+      );
+      return t;
+    }
+  }
+  struct MarkupRawUnit {
+    import std.file;
+    final private string readInMarkupSource(in char[] fn_src) {
+      enforce(
+        exists(fn_src) != 0,
+        "file not found: «" ~
+        fn_src ~ "»"
+      );
+      string source_txt_str;
+      try {
+        if (exists(fn_src)) {
+          if (fn_src.getLinkAttributes.attrIsFile) {
+            source_txt_str = fn_src.readText;
+          } else {
+          }
+        }
+      } catch (ErrnoException ex) {
+      } catch (UTFException ex) {
+        // Handle validation errors
+      } catch (FileException ex) {
+        // Handle errors
+      }
+      std.utf.validate(source_txt_str);
+      return source_txt_str;
+    }
+    @trusted final private char[][] header0Content1(in string src_text) { // cast(char[])
+      /+ split string on _first_ match of "^:?A~\s" into [header, content] array/tuple +/
+      char[][] header_and_content;
+      auto m = (cast(char[]) src_text).matchFirst(rgx.heading_a);
+      header_and_content ~= m.pre;
+      header_and_content ~= m.hit ~ m.post;
+      assert(header_and_content.length == 2,
+        "document markup is broken, header body split == "
+        ~ header_and_content.length.to!string
+        ~ "; (header / body array split should == 2 (split is on level A~))"
+      );
+      return header_and_content;
+    }
+    @trusted final private char[][] markupSourceLineArray(in char[] src_text) { // cast(char[])
+      char[][] source_line_arr
+        = (cast(char[]) src_text).split(rgx.newline_eol_strip_preceding);
+      return source_line_arr;
+    }
+    string markupSourceReadIn(in string fn_src) {
+      static auto rgx_files = RgxFiles();
+      enforce(
+        fn_src.match(rgx_files.src_pth_sst_or_ssm),
+        "not a dr markup filename: «" ~
+        fn_src ~ "»"
+      );
+      string source_txt_str = readInMarkupSource(fn_src);
+      return source_txt_str;
+    }
+    HeaderContentInsertsImages markupSourceHeaderContentRawLineTupleArray(in string source_txt_str) {
+      string[] file_insert_list = [];
+      string[] images_list = [];
+      char[][] hc = header0Content1(source_txt_str);
+      char[] header = hc[0];
+      char[] source_txt = hc[1];
+      char[][] source_line_arr = markupSourceLineArray(source_txt);
+      HeaderContentInsertsImages t = tuple(
+        header,
+        source_line_arr,
+        file_insert_list,
+        images_list
+      );
+      return t;
+    }
+    final char[][] getInsertMarkupSourceContentRawLineArray(
+      in char[]    fn_src_insert,
+      Regex!(char) rgx_file
+    ) {
+      enforce(
+        fn_src_insert.match(rgx_file),
+        "not a dr markup filename: «" ~
+        fn_src_insert  ~ "»"
+      );
+      string source_txt_str = readInMarkupSource(fn_src_insert);
+      char[][] source_line_arr = markupSourceLineArray(source_txt_str);
+      return source_line_arr;
+    }
+  }
+  struct Inserts {
+    alias ContentsAndImages = Tuple!(
+      char[][], "insert_contents",
+      string[], "images"
+    );
+    ContentsAndImages scan_subdoc_source(O)(
+      O        _opt_action,
+      char[][] markup_sourcefile_insert_content,
+      string   fn_src
+    ) {
+      char[][] contents_insert;
+      int code_block_status     = 0;
+      enum codeBlock { off, curly, tic, }
+      auto fn_pth_full = fn_src.match(rgx_files.src_pth_sst_or_ssm);
+      auto markup_src_file_path = fn_pth_full.captures[1];
+      foreach (line; markup_sourcefile_insert_content) {
+        if (code_block_status == codeBlock.curly) {
+          if (line.matchFirst(rgx.block_curly_code_close)) {
+            code_block_status = codeBlock.off;
+          }
+          contents_insert ~= line;
+        } else if (line.matchFirst(rgx.block_curly_code_open)) {
+          code_block_status   = codeBlock.curly;
+          contents_insert ~= line;
+        } else if (code_block_status == codeBlock.tic) {
+          if (line.matchFirst(rgx.block_tic_close)) {
+            code_block_status = codeBlock.off;
+          }
+          contents_insert ~= line;
+        } else if (line.matchFirst(rgx.block_tic_code_open)) {
+          code_block_status   = codeBlock.tic;
+          contents_insert ~= line;
+        } else if (auto m = line.match(rgx_files.insert_src_fn_ssi_or_sst)) {
+          auto insert_fn = m.captures[2];
+          auto insert_sub_pth = m.captures[1];
+          auto fn_src_insert
+            = chainPath(markup_src_file_path, insert_sub_pth ~ insert_fn).array;
+          auto raw = MarkupRawUnit();
+          auto markup_sourcesubfile_insert_content
+            = raw.getInsertMarkupSourceContentRawLineArray(fn_src_insert, rgx_files.src_fn_find_inserts);
+          debug(insert_file) {
+            writeln(line);
+            writeln(fn_src_insert);
+            writeln(
+              "  length contents insert array: ",
+              markup_sourcesubfile_insert_content.length
+            );
+          }
+          if (_opt_action.source || _opt_action.pod) {
+            _images ~= _extract_images(markup_sourcesubfile_insert_content);
+          }
+          auto ins = Inserts();
+          /+
+            - 1. load file
+            - 2. read lines
+            - 3. scan lines
+              - a. if filename insert, and insert filename
+                 - repeat 1
+              - b. else
+                 - add line to new array;
+                 - build image list, search for any image files to add to image list
+          +/
+        } else {
+          contents_insert ~= line; // images to extract for image list?
+          if (_opt_action.source || _opt_action.pod) {
+            string[] _image_linelist = _extract_images(line);
+            if (_image_linelist.length > 0) {
+              _images ~= _image_linelist;
+            }
+          }
+        }
+      } // end src subdoc (inserts) loop
+      ContentsAndImages t = tuple(
+        contents_insert,
+        _images
+      );
+      return t;
+    }
+    ContentsInsertsImages scan_master_src_for_insert_files_and_import_content(O)(
+      O        _opt_action,
+      char[][] sourcefile_body_content,
+      string   fn_src
+    ) {
+      import std.algorithm;
+      char[][] contents;
+      int code_block_status     = 0;
+      enum codeBlock { off, curly, tic, }
+      auto fn_pth_full = fn_src.match(rgx_files.src_pth_sst_or_ssm);
+      auto markup_src_file_path = fn_pth_full.captures[1];
+      char[][] contents_insert;
+      string[] _images          =[];
+      string[] insert_file_list =[];
+      foreach (line; sourcefile_body_content) {
+        if (code_block_status == codeBlock.curly) {
+          if (line.matchFirst(rgx.block_curly_code_close)) {
+            code_block_status = codeBlock.off;
+          }
+          contents ~= line;
+        } else if (line.matchFirst(rgx.block_curly_code_open)) {
+          code_block_status = codeBlock.curly;
+          contents ~= line;
+        } else if (code_block_status == codeBlock.tic) {
+          if (line.matchFirst(rgx.block_tic_close)) {
+            code_block_status = codeBlock.off;
+          }
+          contents ~= line;
+        } else if (line.matchFirst(rgx.block_tic_code_open)) {
+          code_block_status = codeBlock.tic;
+          contents ~= line;
+        } else if (auto m = line.match(rgx_files.insert_src_fn_ssi_or_sst)) {
+          auto insert_fn      = m.captures[2];
+          auto insert_sub_pth = m.captures[1];
+          auto fn_src_insert
+            = chainPath(markup_src_file_path, insert_sub_pth ~ insert_fn).array;
+            insert_file_list ~= fn_src_insert.to!string;
+          auto raw = MarkupRawUnit();
+          /+ TODO +/
+          auto markup_sourcefile_insert_content
+            = raw.getInsertMarkupSourceContentRawLineArray(fn_src_insert, rgx_files.src_fn_find_inserts);
+          debug(insert_file) {
+            writeln(line);
+            writeln(fn_src_insert);
+            writeln(
+              "  length contents insert array: ",
+              markup_sourcefile_insert_content.length
+            );
+          }
+          auto ins = Inserts();
+          ContentsAndImages contents_insert_tu = ins.scan_subdoc_source(
+            _opt_action,
+            markup_sourcefile_insert_content,
+            fn_src_insert.to!string
+          );
+          contents ~= contents_insert_tu.insert_contents;
+          if (_opt_action.source || _opt_action.pod) {
+            string[] _image_linelist = _extract_images(contents_insert_tu.images);
+            if (_image_linelist.length > 0) {
+              _images ~= _image_linelist;
+            }
+          }
+          /+
+            - 1. load file
+            - 2. read lines
+            - 3. scan lines
+              - a. if filename insert, and insert filename
+                 - repeat 1
+              - b. else
+                 - add line to new array;
+                 - build image list, search for any image files to add to image list
+          +/
+        } else {
+          contents ~= line;
+          if (_opt_action.source || _opt_action.pod) {
+            string[] _image_linelist = _extract_images(line);
+            if (_image_linelist.length > 0) {
+              _images ~= _image_linelist;
+            }
+          }
+        }
+      } // end src doc loop
+      string[] images = [];
+      foreach(i; uniq(_images.sort())) {
+        images ~= i;
+      }
+      debug(insert_file) {
+        writeln(__LINE__);
+        writeln(contents.length);
+      }
+      ContentsInsertsImages t = tuple(
+        contents,
+        insert_file_list,
+        images
+      );
+      return t;
+    }
+  }
+}