diff --git a/lib/plankton/plankton.d.ts b/lib/plankton/plankton.d.ts
index d1bd34f..f856bdc 100644
--- a/lib/plankton/plankton.d.ts
+++ b/lib/plankton/plankton.d.ts
@@ -733,3 +733,620 @@ declare namespace lib_plankton.call {
         seconds: (null | float);
     }>;
 }
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    interface interface_code<type_from, type_to> {
+        /**
+         * @author fenris
+         */
+        encode(x: type_from): type_to;
+        /**
+         * @author fenris
+         */
+        decode(x: type_to): type_from;
+    }
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    type type_code<type_from, type_to> = {
+        /**
+         * @author fenris
+         */
+        encode: (x: type_from) => type_to;
+        /**
+         * @author fenris
+         */
+        decode: (x: type_to) => type_from;
+    };
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    function inverse_encode<type_from, type_to>(decode: (to: type_to) => type_from, to: type_to): type_from;
+    /**
+     * @author fenris
+     */
+    function inverse_decode<type_from, type_to>(encode: (from: type_from) => type_to, from: type_from): type_to;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    class class_code_inverse<type_from, type_to> implements interface_code<type_to, type_from> {
+        /**
+         * @author fenris
+         */
+        protected subject: interface_code<type_from, type_to>;
+        /**
+         * @author fenris
+         */
+        constructor(subject: interface_code<type_from, type_to>);
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(to: type_to): type_from;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(from: type_from): type_to;
+    }
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    function pair_encode<type_from, type_between, type_to>(encode_first: (from: type_from) => type_between, encode_second: (between: type_between) => type_to, from: type_from): type_to;
+    /**
+     * @author fenris
+     */
+    function pair_decode<type_from, type_between, type_to>(decode_first: (between: type_between) => type_from, decode_second: (to: type_to) => type_between, to: type_to): type_from;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    class class_code_pair<type_from, type_between, type_to> implements interface_code<type_from, type_to> {
+        /**
+         * @author fenris
+         */
+        protected first: interface_code<type_from, type_between>;
+        /**
+         * @author fenris
+         */
+        protected second: interface_code<type_between, type_to>;
+        /**
+         * @author fenris
+         */
+        constructor(first: interface_code<type_from, type_between>, second: interface_code<type_between, type_to>);
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(from: type_from): type_to;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(to: type_to): type_from;
+    }
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    function chain_encode(encode_links: Array<(from: any) => any>, from: any): any;
+    /**
+     * @author fenris
+     */
+    function chain_decode(decode_links: Array<(to: any) => any>, to: any): any;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    class class_code_chain implements interface_code<any, any> {
+        /**
+         * @author fenris
+         */
+        protected links: Array<interface_code<any, any>>;
+        /**
+         * @author fenris
+         */
+        constructor(links: Array<interface_code<any, any>>);
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(from: any): any;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(to: any): any;
+    }
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author Christian Fraß <frass@greenscale.de>
+     */
+    type type_flatten_from = Array<{
+        [name: string]: any;
+    }>;
+    /**
+     * @author Christian Fraß <frass@greenscale.de>
+     */
+    type type_flatten_to = {
+        keys: Array<string>;
+        data: Array<Array<any>>;
+    };
+    /**
+     * @author Christian Fraß <frass@greenscale.de>
+     */
+    function flatten_encode(from: type_flatten_from, keys?: Array<string>): type_flatten_to;
+    /**
+     * @author Christian Fraß <frass@greenscale.de>
+     */
+    function flatten_decode(to: type_flatten_to): type_flatten_from;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    class class_code_flatten implements interface_code<type_flatten_from, type_flatten_to> {
+        /**
+         * @author fenris
+         */
+        constructor();
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(x: type_flatten_from): type_flatten_to;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(x: type_flatten_to): type_flatten_from;
+    }
+}
+declare namespace lib_plankton.json {
+    /**
+     * @author fenris
+     */
+    function encode(x: any, formatted?: boolean): string;
+    /**
+     * @author fenris
+     */
+    function decode(x: string): any;
+}
+declare namespace lib_plankton.json {
+    /**
+     * @author fenris
+     */
+    class class_json implements lib_plankton.code.interface_code<any, string> {
+        /**
+         * @author fenris
+         */
+        constructor();
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(x: any): string;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(x: string): any;
+    }
+}
+declare namespace lib_plankton.file {
+    /**
+     * @author fenris
+     */
+    function read(path: string): Promise<string>;
+    /**
+     * @author fenris
+     */
+    function read_buffer(path: string): Promise<Buffer>;
+    /**
+     * @author fenris
+     */
+    function read_stdin(): Promise<string>;
+    /**
+     * @author fenris
+     */
+    function write(path: string, content: string, options?: {
+        encoding?: string;
+    }): Promise<void>;
+    /**
+     * @author fenris
+     */
+    function write_buffer(path: string, content: Buffer, options?: {}): Promise<void>;
+    /**
+     */
+    function delete_(path: string): Promise<void>;
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    enum enum_level {
+        debug = 0,
+        info = 1,
+        notice = 2,
+        warning = 3,
+        error = 4
+    }
+    /**
+     */
+    function level_order(level1: enum_level, level2: enum_level): boolean;
+    /**
+     */
+    function level_show(level: enum_level): string;
+    /**
+     */
+    type type_entry = {
+        level: enum_level;
+        incident: string;
+        details: Record<string, any>;
+    };
+}
+/**
+ * @deprecated
+ * @todo remove
+ */
+declare namespace lib_plankton.log {
+    function level_push(level: int): void;
+    function level_pop(): void;
+    function indent_push(indent: int): void;
+    function indent_pop(): void;
+    function indent_inc(): void;
+    function indent_dec(): void;
+    /**
+     * @author fenris
+     */
+    function write({ "message": message, "type": type, "prefix": prefix, "level": level, "indent": indent, }: {
+        message?: string;
+        type?: string;
+        prefix?: string;
+        level?: int;
+        indent?: int;
+    }): void;
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    abstract class class_channel {
+        /**
+         */
+        abstract add(entry: type_entry): void;
+    }
+}
+declare namespace lib_plankton.log {
+    /**
+     * output for writing log entries to stdout
+     */
+    class class_channel_stdout extends class_channel {
+        /**
+         */
+        add(entry: type_entry): void;
+    }
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    class class_channel_file extends class_channel {
+        /**
+         * the path of the log file
+         */
+        private path;
+        /**
+         * [constructor]
+         */
+        constructor(path: string);
+        /**
+         */
+        add(entry: type_entry): void;
+    }
+}
+declare namespace lib_plankton.log {
+    /**
+     * output for desktop notifications via "libnotify"
+     */
+    class class_channel_notify extends class_channel {
+        /**
+         */
+        add(entry: type_entry): void;
+    }
+}
+declare namespace lib_plankton.log {
+    /**
+     * decorator for filtering out log entries below a certain level threshold
+     */
+    class class_channel_minlevel extends class_channel {
+        /**
+         */
+        private core;
+        /**
+         */
+        private threshold;
+        /**
+         */
+        constructor(core: class_channel, threshold: enum_level);
+        /**
+         */
+        add(entry: type_entry): void;
+    }
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    function channel_make(description: {
+        kind: string;
+        data?: {
+            [key: string]: any;
+        };
+    }): class_channel;
+    /**
+     */
+    type type_configuration = Array<class_channel>;
+    /**
+     */
+    function conf_default(): type_configuration;
+}
+declare namespace lib_plankton.log {
+    /**
+     * pushes a new configuration on the stack and activates it
+     */
+    function conf_push(channels: type_configuration): void;
+    /**
+     * pops the current active configuration from the stack
+     */
+    function conf_pop(): void;
+    /**
+     * consumes a log entry, i.e. sends it to the currently active outputs
+     */
+    function add(entry: type_entry): void;
+    /**
+     */
+    function debug(incident: string, details?: Record<string, any>): void;
+    /**
+     */
+    function info(incident: string, details?: Record<string, any>): void;
+    /**
+     */
+    function notice(incident: string, details?: Record<string, any>): void;
+    /**
+     */
+    function warning(incident: string, details?: Record<string, any>): void;
+    /**
+     */
+    function error(incident: string, details?: Record<string, any>): void;
+}
+declare namespace lib_plankton.args {
+    /**
+     */
+    enum enum_environment {
+        cli = "cli",
+        url = "url"
+    }
+    /**
+     */
+    enum enum_kind {
+        positional = "positional",
+        volatile = "volatile"
+    }
+    /**
+     */
+    enum enum_type {
+        boolean = "boolean",
+        integer = "int",
+        float = "float",
+        string = "string"
+    }
+    /**
+     */
+    enum enum_mode {
+        replace = "replace",
+        accumulate = "accumulate"
+    }
+}
+declare namespace lib_plankton.args {
+    /**
+     * @author fenris
+     */
+    class class_argument {
+        /**
+         * @author fenris
+         */
+        protected name: string;
+        /**
+         * @author fenris
+         */
+        protected kind: enum_kind;
+        /**
+         * @author fenris
+         */
+        protected type: enum_type;
+        /**
+         * @author fenris
+         */
+        protected mode: enum_mode;
+        /**
+         * @author fenris
+         */
+        protected default_: any;
+        /**
+         * @author fenris
+         */
+        protected info: string;
+        /**
+         * @author fenris
+         */
+        protected parameters: Object;
+        /**
+         * @author fenris
+         */
+        protected hidden: boolean;
+        /**
+         * @author fenris
+         */
+        constructor({ "name": name, "type": type, "kind": kind, "mode": mode, "default": default_, "info": info, "parameters": parameters, "hidden": hidden, }: {
+            name: string;
+            type?: enum_type;
+            kind?: enum_kind;
+            mode?: enum_mode;
+            default?: any;
+            info?: string;
+            parameters?: Object;
+            hidden?: boolean;
+        });
+        /**
+         * @author fenris
+         */
+        static positional({ "name": name, "type": type, "mode": mode, "default": default_, "info": info, "hidden": hidden, "index": index, }: {
+            name: string;
+            type?: enum_type;
+            mode?: enum_mode;
+            default?: any;
+            info?: string;
+            hidden?: boolean;
+            index: int;
+        }): class_argument;
+        /**
+         * @author fenris
+         */
+        static volatile({ "name": name, "type": type, "mode": mode, "default": default_, "info": info, "hidden": hidden, "indicators_short": indicators_short, "indicators_long": indicators_long, }: {
+            name: string;
+            type?: enum_type;
+            mode?: enum_mode;
+            default?: any;
+            info?: string;
+            hidden?: boolean;
+            indicators_short: Array<string>;
+            indicators_long: Array<string>;
+        }): class_argument;
+        /**
+         * @author fenris
+         */
+        check(): boolean;
+        /**
+         * @author fenris
+         */
+        name_get(): string;
+        /**
+         * @author fenris
+         */
+        kind_get(): enum_kind;
+        /**
+         * @author fenris
+         */
+        type_get(): enum_type;
+        /**
+         * @author fenris
+         */
+        mode_get(): enum_mode;
+        /**
+         * @author fenris
+         */
+        default_get(): any;
+        /**
+         * @author fenris
+         */
+        parameters_get(): Object;
+        /**
+         * @author fenris
+         */
+        hidden_get(): boolean;
+        /**
+         * @author fenris
+         */
+        toString(): string;
+        /**
+         * @author fenris
+         */
+        indicator_main(): string;
+        /**
+         * @author fenris
+         */
+        pattern_value(): string;
+        /**
+         * @author fenris
+         */
+        extract(raw: string): any;
+        /**
+         * @author fenris
+         */
+        assign(data: Object, target: string, raw: string): void;
+        /**
+         * @author fenris
+         */
+        make(data: Object, target: string): string;
+        /**
+         * @author fenris
+         */
+        generate_help(): string;
+    }
+}
+declare namespace lib_plankton.args {
+    /**
+     * @author fenris
+     */
+    var verbosity: int;
+    /**
+     * @author fenris
+     * @todo check validity
+     */
+    class class_handler {
+        /**
+         * @author fenris
+         */
+        protected arguments_: {
+            [name: string]: class_argument;
+        };
+        /**
+         * @author fenris
+         */
+        constructor(arguments_: {
+            [name: string]: class_argument;
+        });
+        /**
+         * @author fenris
+         */
+        filter(kind: enum_kind): {
+            [name: string]: class_argument;
+        };
+        /**
+         * @author fenris
+         */
+        read(environment: enum_environment, input: string, data?: {
+            [name: string]: any;
+        }): {
+            [name: string]: any;
+        };
+        /**
+         * @author fenris
+         * @todo handle if the data object doesn't have the required field or the type is wrong or sth.
+         */
+        write(environment: enum_environment, data: {
+            [name: string]: any;
+        }): string;
+        /**
+         * @desc manpage-like info-sheet
+         * @author fenris
+         */
+        generate_help({ "programname": programname, "author": author, "description": description, "executable": executable, }: {
+            programname?: string;
+            author?: string;
+            description?: string;
+            executable?: string;
+        }): string;
+    }
+}
diff --git a/lib/plankton/plankton.js b/lib/plankton/plankton.js
index c66955b..bdf56cf 100644
--- a/lib/plankton/plankton.js
+++ b/lib/plankton/plankton.js
@@ -1727,3 +1727,2052 @@ var lib_plankton;
         call.rate_limit_check = rate_limit_check;
     })(call = lib_plankton.call || (lib_plankton.call = {}));
 })(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function inverse_encode(decode, to) {
+            return decode(to);
+        }
+        code.inverse_encode = inverse_encode;
+        /**
+         * @author fenris
+         */
+        function inverse_decode(encode, from) {
+            return encode(from);
+        }
+        code.inverse_decode = inverse_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_inverse = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_inverse(subject) {
+                this.subject = subject;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_inverse.prototype.encode = function (to) {
+                var _this = this;
+                return code.inverse_encode(function (x) { return _this.subject.decode(x); }, to);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_inverse.prototype.decode = function (from) {
+                var _this = this;
+                return code.inverse_decode(function (x) { return _this.subject.encode(x); }, from);
+            };
+            return class_code_inverse;
+        }());
+        code.class_code_inverse = class_code_inverse;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function pair_encode(encode_first, encode_second, from) {
+            var between = encode_first(from);
+            var to = encode_second(between);
+            return to;
+        }
+        code.pair_encode = pair_encode;
+        /**
+         * @author fenris
+         */
+        function pair_decode(decode_first, decode_second, to) {
+            var between = decode_second(to);
+            var from = decode_first(between);
+            return from;
+        }
+        code.pair_decode = pair_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_pair = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_pair(first, second) {
+                this.first = first;
+                this.second = second;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_pair.prototype.encode = function (from) {
+                var _this = this;
+                return code.pair_encode(function (x) { return _this.first.encode(x); }, function (x) { return _this.second.encode(x); }, from);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_pair.prototype.decode = function (to) {
+                var _this = this;
+                return code.pair_decode(function (x) { return _this.first.decode(x); }, function (x) { return _this.second.decode(x); }, to);
+            };
+            return class_code_pair;
+        }());
+        code.class_code_pair = class_code_pair;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function chain_encode(encode_links, from) {
+            var value = from;
+            encode_links
+                .forEach(function (link) {
+                value = link(value);
+            });
+            return value;
+        }
+        code.chain_encode = chain_encode;
+        /**
+         * @author fenris
+         */
+        function chain_decode(decode_links, to) {
+            var value = to;
+            decode_links
+                .reverse()
+                .forEach(function (link) {
+                value = link(value);
+            });
+            return value;
+        }
+        code.chain_decode = chain_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_chain = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_chain(links) {
+                this.links = links;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_chain.prototype.encode = function (from) {
+                return code.chain_encode(this.links.map(function (link) { return (function (x) { return link.encode(x); }); }), from);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_chain.prototype.decode = function (to) {
+                return code.chain_decode(this.links.map(function (link) { return (function (x) { return link.decode(x); }); }), to);
+            };
+            return class_code_chain;
+        }());
+        code.class_code_chain = class_code_chain;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author Christian Fraß <frass@greenscale.de>
+         */
+        function flatten_encode(from, keys) {
+            if (keys === void 0) { keys = null; }
+            if (keys === null) {
+                if (from.length > 0) {
+                    keys = Object.keys(from[0]);
+                }
+                else {
+                    throw (new Error("encoding impossible"));
+                }
+            }
+            return {
+                "keys": keys,
+                "data": from.map(function (line) { return keys.map(function (name) { return line[name]; }); }),
+            };
+        }
+        code.flatten_encode = flatten_encode;
+        /**
+         * @author Christian Fraß <frass@greenscale.de>
+         */
+        function flatten_decode(to) {
+            return (to.data
+                .map(function (dataset) {
+                var dataset_ = {};
+                dataset
+                    .forEach(function (value, index) {
+                    var name = to.keys[index];
+                    dataset_[name] = value;
+                });
+                return dataset_;
+            }));
+        }
+        code.flatten_decode = flatten_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_flatten = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_flatten() {
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_flatten.prototype.encode = function (x) {
+                return code.flatten_encode(x);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_flatten.prototype.decode = function (x) {
+                return code.flatten_decode(x);
+            };
+            return class_code_flatten;
+        }());
+        code.class_code_flatten = class_code_flatten;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:json«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:json« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:json« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:json«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var json;
+    (function (json) {
+        /**
+         * @author fenris
+         */
+        function encode(x, formatted = false) {
+            return JSON.stringify(x, undefined, formatted ? "\t" : undefined);
+        }
+        json.encode = encode;
+        /**
+         * @author fenris
+         */
+        function decode(x) {
+            return JSON.parse(x);
+        }
+        json.decode = decode;
+    })(json = lib_plankton.json || (lib_plankton.json = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:json«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:json« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:json« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:json«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var json;
+    (function (json) {
+        /**
+         * @author fenris
+         */
+        class class_json {
+            /**
+             * @author fenris
+             */
+            constructor() {
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            encode(x) {
+                return json.encode(x);
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            decode(x) {
+                return json.decode(x);
+            }
+        }
+        json.class_json = class_json;
+    })(json = lib_plankton.json || (lib_plankton.json = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:file«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:file« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:file« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:file«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var file;
+    (function (file) {
+        /**
+         * @author fenris
+         */
+        function read(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.readFile(path, {
+                    "encoding": "utf8",
+                    "flag": "r",
+                }, function (error, content) {
+                    if (error == null) {
+                        resolve(content);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.read = read;
+        /**
+         * @author fenris
+         */
+        function read_buffer(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.readFile(path, {
+                    "flag": "r",
+                }, function (error, content) {
+                    if (error == null) {
+                        resolve(content);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.read_buffer = read_buffer;
+        /**
+         * @author fenris
+         */
+        function read_stdin() {
+            return (new Promise(function (resolve, reject) {
+                var input_raw = "";
+                process.stdin.setEncoding("utf8");
+                process.stdin.on("readable", function () {
+                    var chunk;
+                    while ((chunk = process.stdin.read()) !== null) {
+                        input_raw += chunk;
+                    }
+                });
+                process.stdin.on("end", function () {
+                    resolve(input_raw);
+                });
+            }));
+        }
+        file.read_stdin = read_stdin;
+        /**
+         * @author fenris
+         */
+        function write(path, content, options) {
+            if (options === void 0) { options = {}; }
+            options = Object.assign({
+                "encoding": "utf-8",
+            }, options);
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.writeFile(path, content, {
+                    "encoding": options.encoding,
+                    "flag": "w",
+                }, function (error) {
+                    if (error == null) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.write = write;
+        /**
+         * @author fenris
+         */
+        function write_buffer(path, content, options) {
+            if (options === void 0) { options = {}; }
+            options = Object.assign({}, options);
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.writeFile(path, content, {
+                    "flag": "w",
+                }, function (error) {
+                    if (error == null) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.write_buffer = write_buffer;
+        /**
+         */
+        function delete_(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.unlink(path, function () {
+                    resolve(undefined);
+                });
+            }));
+        }
+        file.delete_ = delete_;
+    })(file = lib_plankton.file || (lib_plankton.file = {}));
+})(lib_plankton || (lib_plankton = {}));
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        var enum_level;
+        (function (enum_level) {
+            enum_level[enum_level["debug"] = 0] = "debug";
+            enum_level[enum_level["info"] = 1] = "info";
+            enum_level[enum_level["notice"] = 2] = "notice";
+            enum_level[enum_level["warning"] = 3] = "warning";
+            enum_level[enum_level["error"] = 4] = "error";
+        })(enum_level = log.enum_level || (log.enum_level = {}));
+        ;
+        /**
+         */
+        function level_order(level1, level2) {
+            return (level1 <= level2);
+        }
+        log.level_order = level_order;
+        /**
+         */
+        function level_show(level) {
+            switch (level) {
+                case enum_level.debug: return "debug";
+                case enum_level.info: return "info";
+                case enum_level.notice: return "notice";
+                case enum_level.warning: return "warning";
+                case enum_level.error: return "error";
+                default: return "(unknown)";
+            }
+        }
+        log.level_show = level_show;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @deprecated
+ * @todo remove
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         * @author fenris
+         */
+        /*export*/ var level_stack = [0];
+        function level_push(level) { level_stack.push(level); }
+        log.level_push = level_push;
+        function level_pop() { if (level_stack.length > 1) {
+            level_stack.pop();
+        } }
+        log.level_pop = level_pop;
+        function level_get() { return level_stack.slice(-1)[0]; }
+        /*
+        export function level_inc() : void {level_push(level_get()+1);}
+        export function level_dec() : void {level_push(level_get()-1);}
+         */
+        /**
+         * @author fenris
+         */
+        var indent_stack = [0];
+        function indent_push(indent) { indent_stack.push(indent); }
+        log.indent_push = indent_push;
+        function indent_pop() { if (indent_stack.length > 1) {
+            indent_stack.pop();
+        } }
+        log.indent_pop = indent_pop;
+        function indent_get() { return level_stack.slice(-1)[0]; }
+        function indent_inc() { level_push(level_get() + 1); }
+        log.indent_inc = indent_inc;
+        function indent_dec() { level_push(level_get() - 1); }
+        log.indent_dec = indent_dec;
+        /**
+         * @author fenris
+         */
+        function write(_a) {
+            var message = _a["message"], _b = _a["type"], type = _b === void 0 ? null : _b, _c = _a["prefix"], prefix = _c === void 0 ? null : _c, _d = _a["level"], level = _d === void 0 ? 0 : _d, _e = _a["indent"], indent = _e === void 0 ? 0 : _e;
+            var entry = {
+                "level": ((type === null)
+                    ? lib_plankton.log.enum_level.info
+                    : {
+                        "debug": lib_plankton.log.enum_level.debug,
+                        "info": lib_plankton.log.enum_level.info,
+                        "notice": lib_plankton.log.enum_level.notice,
+                        "warning": lib_plankton.log.enum_level.warning,
+                        "error": lib_plankton.log.enum_level.error,
+                    }[type]),
+                "incident": message,
+                "details": {
+                    "prefix": prefix,
+                    "level": level,
+                    "indent": indent,
+                },
+            };
+            lib_plankton.log.add(entry);
+        }
+        log.write = write;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        var class_channel = /** @class */ (function () {
+            function class_channel() {
+            }
+            return class_channel;
+        }());
+        log.class_channel = class_channel;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         * output for writing log entries to stdout
+         */
+        var class_channel_stdout = /** @class */ (function (_super) {
+            __extends(class_channel_stdout, _super);
+            function class_channel_stdout() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            /**
+             */
+            class_channel_stdout.prototype.add = function (entry) {
+                process.stdout.write(("<" + (new Date(Date.now())).toISOString().slice(0, 19) + ">")
+                    +
+                        " "
+                    +
+                        ("[" + log.level_show(entry.level) + "]")
+                    +
+                        " "
+                    +
+                        ("" + entry.incident + "")
+                    +
+                        ": "
+                    +
+                        JSON.stringify(entry.details, undefined, "  ")
+                    +
+                        "\n");
+            };
+            return class_channel_stdout;
+        }(log.class_channel));
+        log.class_channel_stdout = class_channel_stdout;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        var class_channel_file = /** @class */ (function (_super) {
+            __extends(class_channel_file, _super);
+            /**
+             * [constructor]
+             */
+            function class_channel_file(path) {
+                var _this = _super.call(this) || this;
+                _this.path = path;
+                return _this;
+            }
+            /**
+             */
+            class_channel_file.prototype.add = function (entry) {
+                var _this = this;
+                var nm_fs = require("fs");
+                nm_fs.writeFile(this.path, {
+                    "flag": "a+",
+                }, (("<" + (new Date(Date.now())).toISOString().slice(0, 19) + ">")
+                    +
+                        " "
+                    +
+                        ("[" + log.level_show(entry.level) + "]")
+                    +
+                        " "
+                    +
+                        ("" + entry.incident + "")
+                    +
+                        ": "
+                    +
+                        JSON.stringify(entry.details, undefined, "  ")
+                    +
+                        "\n"), function (error) {
+                    process.stderr.write('-- [plankton] could not add log entry to file ' + _this.path + "\n");
+                });
+            };
+            return class_channel_file;
+        }(log.class_channel));
+        log.class_channel_file = class_channel_file;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         * output for desktop notifications via "libnotify"
+         */
+        var class_channel_notify = /** @class */ (function (_super) {
+            __extends(class_channel_notify, _super);
+            function class_channel_notify() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            /**
+             */
+            class_channel_notify.prototype.add = function (entry) {
+                var nm_child_process = require("child_process");
+                var command = ("notify-send"
+                    +
+                        " "
+                    +
+                        ("'"
+                            +
+                                ("[" + log.level_show(entry.level) + "]")
+                            +
+                                " "
+                            +
+                                entry.incident
+                            +
+                                "'")
+                    +
+                        " "
+                    +
+                        ("'"
+                            +
+                                (Object.keys(entry.details)
+                                    .map(function (key) { return (key + ": " + JSON.stringify(entry.details[key])); })
+                                    .join("\n"))
+                            +
+                                "'"));
+                nm_child_process.exec(command, function (error, stdout, stderr) {
+                    // do noting
+                });
+            };
+            return class_channel_notify;
+        }(log.class_channel));
+        log.class_channel_notify = class_channel_notify;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         * decorator for filtering out log entries below a certain level threshold
+         */
+        var class_channel_minlevel = /** @class */ (function (_super) {
+            __extends(class_channel_minlevel, _super);
+            /**
+             */
+            function class_channel_minlevel(core, threshold) {
+                var _this = _super.call(this) || this;
+                _this.core = core;
+                _this.threshold = threshold;
+                return _this;
+            }
+            /**
+             */
+            class_channel_minlevel.prototype.add = function (entry) {
+                if (!log.level_order(this.threshold, entry.level)) {
+                    // do nothing
+                }
+                else {
+                    this.core.add(entry);
+                }
+            };
+            return class_channel_minlevel;
+        }(log.class_channel));
+        log.class_channel_minlevel = class_channel_minlevel;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        function translate_level(level_string) {
+            return {
+                "debug": log.enum_level.debug,
+                "info": log.enum_level.info,
+                "notice": log.enum_level.notice,
+                "warning": log.enum_level.warning,
+                "error": log.enum_level.error,
+            }[level_string];
+        }
+        /**
+         */
+        function channel_make(description) {
+            var _a, _b, _c, _d;
+            switch (description.kind) {
+                default: {
+                    throw (new Error("unhandled log channel kind: " + description.kind));
+                    break;
+                }
+                case "stdout": {
+                    return (new log.class_channel_minlevel(new log.class_channel_stdout(), translate_level((_a = description.data["threshold"]) !== null && _a !== void 0 ? _a : "debug")));
+                    break;
+                }
+                case "file": {
+                    return (new log.class_channel_minlevel(new log.class_channel_file((_b = description.data["path"]) !== null && _b !== void 0 ? _b : "/tmp/plankton.log"), translate_level((_c = description.data["threshold"]) !== null && _c !== void 0 ? _c : "debug")));
+                    break;
+                }
+                case "notify": {
+                    return (new log.class_channel_minlevel(new log.class_channel_notify(), translate_level((_d = description.data["threshold"]) !== null && _d !== void 0 ? _d : "debug")));
+                    break;
+                }
+            }
+        }
+        log.channel_make = channel_make;
+        /**
+         */
+        function conf_default() {
+            return [
+                new log.class_channel_minlevel(new log.class_channel_stdout(), log.enum_level.notice),
+                new log.class_channel_minlevel(new log.class_channel_notify(), log.enum_level.error),
+            ];
+        }
+        log.conf_default = conf_default;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        var _channel_stack = null;
+        /**
+         * pushes a new configuration on the stack and activates it
+         */
+        function conf_push(channels) {
+            if (_channel_stack === null) {
+                _channel_stack = [];
+            }
+            _channel_stack.push(channels);
+        }
+        log.conf_push = conf_push;
+        /**
+         * pops the current active configuration from the stack
+         */
+        function conf_pop() {
+            if (_channel_stack.length > 0) {
+                _channel_stack.pop();
+            }
+            else {
+                // do nothing
+            }
+        }
+        log.conf_pop = conf_pop;
+        /**
+         * makes the logging system ready
+         */
+        function setup() {
+            if (_channel_stack === null) {
+                _channel_stack = [];
+                conf_push(log.conf_default());
+            }
+            else {
+                // do nothing
+            }
+        }
+        /**
+         * consumes a log entry, i.e. sends it to the currently active outputs
+         */
+        function add(entry) {
+            setup();
+            _channel_stack.slice(-1)[0].forEach(function (channel) { return channel.add(entry); });
+        }
+        log.add = add;
+        /**
+         */
+        function debug(incident, details) {
+            if (details === void 0) { details = {}; }
+            add({ "level": log.enum_level.debug, "incident": incident, "details": details });
+        }
+        log.debug = debug;
+        /**
+         */
+        function info(incident, details) {
+            if (details === void 0) { details = {}; }
+            add({ "level": log.enum_level.info, "incident": incident, "details": details });
+        }
+        log.info = info;
+        /**
+         */
+        function notice(incident, details) {
+            if (details === void 0) { details = {}; }
+            add({ "level": log.enum_level.notice, "incident": incident, "details": details });
+        }
+        log.notice = notice;
+        /**
+         */
+        function warning(incident, details) {
+            if (details === void 0) { details = {}; }
+            add({ "level": log.enum_level.warning, "incident": incident, "details": details });
+        }
+        log.warning = warning;
+        /**
+         */
+        function error(incident, details) {
+            if (details === void 0) { details = {}; }
+            add({ "level": log.enum_level.error, "incident": incident, "details": details });
+        }
+        log.error = error;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /**
+         */
+        var enum_environment;
+        (function (enum_environment) {
+            enum_environment["cli"] = "cli";
+            enum_environment["url"] = "url";
+        })(enum_environment = args.enum_environment || (args.enum_environment = {}));
+        ;
+        /**
+         */
+        var enum_kind;
+        (function (enum_kind) {
+            enum_kind["positional"] = "positional";
+            enum_kind["volatile"] = "volatile";
+        })(enum_kind = args.enum_kind || (args.enum_kind = {}));
+        ;
+        /**
+         */
+        var enum_type;
+        (function (enum_type) {
+            enum_type["boolean"] = "boolean";
+            enum_type["integer"] = "int";
+            enum_type["float"] = "float";
+            enum_type["string"] = "string";
+        })(enum_type = args.enum_type || (args.enum_type = {}));
+        ;
+        /**
+         */
+        var enum_mode;
+        (function (enum_mode) {
+            enum_mode["replace"] = "replace";
+            enum_mode["accumulate"] = "accumulate";
+        })(enum_mode = args.enum_mode || (args.enum_mode = {}));
+        ;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /*
+        export enum_mode {
+            replace = "replace",
+            accumulate = "accumulate",
+        };
+         */
+        /**
+         * @author fenris
+         */
+        var class_argument = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_argument(_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["kind"], kind = _c === void 0 ? args.enum_kind.positional : _c, _d = _a["mode"], mode = _d === void 0 ? args.enum_mode.replace : _d, _e = _a["default"], default_ = _e === void 0 ? null : _e, _f = _a["info"], info = _f === void 0 ? null : _f, _g = _a["parameters"], parameters = _g === void 0 ? {} : _g, _h = _a["hidden"], hidden = _h === void 0 ? false : _h;
+                this.name = name;
+                this.type = type;
+                this.kind = kind;
+                this.mode = mode;
+                this.default_ = default_;
+                this.info = info;
+                this.parameters = parameters;
+                this.hidden = hidden;
+                if (!this.check()) {
+                    throw (new Error("invalid argument-setup"));
+                }
+            }
+            /**
+             * @author fenris
+             */
+            class_argument.positional = function (_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, index = _a["index"];
+                return (new class_argument({
+                    "name": name,
+                    "kind": args.enum_kind.positional,
+                    "type": type,
+                    "mode": mode,
+                    "default": default_,
+                    "info": info,
+                    "hidden": hidden,
+                    "parameters": {
+                        "index": index,
+                    },
+                }));
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.volatile = function (_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, indicators_short = _a["indicators_short"], indicators_long = _a["indicators_long"];
+                return (new class_argument({
+                    "name": name,
+                    "kind": args.enum_kind.volatile,
+                    "type": type,
+                    "mode": mode,
+                    "default": default_,
+                    "info": info,
+                    "hidden": hidden,
+                    "parameters": {
+                        "indicators_short": indicators_short,
+                        "indicators_long": indicators_long,
+                    },
+                }));
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.check = function () {
+                var _this = this;
+                return [
+                    function () { return ((!(_this.kind == args.enum_kind.volatile))
+                        ||
+                            (("indicators_long" in _this.parameters)
+                                &&
+                                    (_this.parameters["indicators_long"]["length"] >= 0))); },
+                ].every(function (condition) { return condition(); });
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.name_get = function () {
+                return this.name;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.kind_get = function () {
+                return this.kind;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.type_get = function () {
+                return this.type;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.mode_get = function () {
+                return this.mode;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.default_get = function () {
+                return this.default_;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.parameters_get = function () {
+                return this.parameters;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.hidden_get = function () {
+                return this.hidden;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.toString = function () {
+                return "<".concat(this.name, ">");
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.indicator_main = function () {
+                if (this.kind === args.enum_kind.volatile) {
+                    return this.parameters["indicators_long"][0];
+                }
+                else {
+                    return null;
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.pattern_value = function () {
+                switch (this.type) {
+                    case args.enum_type.boolean: {
+                        return "false|true";
+                        break;
+                    }
+                    case args.enum_type.integer: {
+                        return "[0-9]+";
+                        break;
+                    }
+                    case args.enum_type.float: {
+                        return "\\d*(?:\\.\\d+)?";
+                        break;
+                    }
+                    case args.enum_type.string: {
+                        return "\\S+";
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled type ".concat(this.type)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.extract = function (raw) {
+                switch (this.type) {
+                    case args.enum_type.boolean: {
+                        return (raw != "false");
+                        break;
+                    }
+                    case args.enum_type.integer: {
+                        return parseInt(raw);
+                        break;
+                    }
+                    case args.enum_type.float: {
+                        return parseFloat(raw);
+                        break;
+                    }
+                    case args.enum_type.string: {
+                        return raw;
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled type ".concat(this.type)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.assign = function (data, target, raw) {
+                var value = this.extract(raw);
+                switch (this.mode) {
+                    case args.enum_mode.replace: {
+                        data[target] = value;
+                        break;
+                    }
+                    case args.enum_mode.accumulate: {
+                        /*
+                        if (! (this.name in data)) {
+                            data[this.name] = [];
+                        }
+                         */
+                        data[target].push(value);
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled mode ".concat(this.mode)));
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.make = function (data, target) {
+                var value = data[target];
+                return value.toString();
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.generate_help = function () {
+                var _this = this;
+                var _a, _b, _c, _d;
+                var output = "";
+                {
+                    switch (this.kind) {
+                        case args.enum_kind.positional: {
+                            var line = "";
+                            line += "\t";
+                            line += "<".concat(this.name, ">");
+                            line += "\n";
+                            output += line;
+                        }
+                        case args.enum_kind.volatile: {
+                            var line = "";
+                            line += "\t";
+                            if (this.type === args.enum_type.boolean) {
+                                line += ([]
+                                    .concat(((_a = this.parameters["indicators_short"]) !== null && _a !== void 0 ? _a : []).map(function (indicator) { return ("-" + indicator); }))
+                                    .concat(((_b = this.parameters["indicators_long"]) !== null && _b !== void 0 ? _b : []).map(function (indicator) { return ("--" + indicator); }))
+                                    .join(" | "));
+                            }
+                            else {
+                                line += ([]
+                                    .concat(((_c = this.parameters["indicators_short"]) !== null && _c !== void 0 ? _c : []).map(function (indicator) { return ("-" + indicator + " " + ("<" + _this.name + ">")); }))
+                                    .concat(((_d = this.parameters["indicators_long"]) !== null && _d !== void 0 ? _d : []).map(function (indicator) { return ("--" + indicator + "=" + ("<" + _this.name + ">")); }))
+                                    .join(" | "));
+                            }
+                            line += "\n";
+                            output += line;
+                        }
+                    }
+                }
+                {
+                    var line = "";
+                    line += "\t\t";
+                    var infotext = ((this.info == null) ? "(no info available)" : this.info);
+                    line += infotext;
+                    if ((this.type != "boolean") && (this.default_ != null)) {
+                        line += "; default: ".concat(this.default_.toString());
+                    }
+                    line += "\n";
+                    output += line;
+                }
+                return output;
+            };
+            return class_argument;
+        }());
+        args.class_argument = class_argument;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2023 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /**
+         * @author fenris
+         */
+        var settings = {
+            "environment": {
+                "cli": {
+                    "symbols": {
+                        "delimiter": " ",
+                        "prefix": "--",
+                        "assignment": "=",
+                    },
+                },
+                "url": {
+                    "symbols": {
+                        "delimiter": "&",
+                        "prefix": "",
+                        "assignment": "=",
+                    }
+                }
+            },
+        };
+        /**
+         * @author fenris
+         */
+        args.verbosity = 0;
+        /**
+         * @author fenris
+         * @todo check validity
+         */
+        var class_handler = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_handler(arguments_) {
+                this.arguments_ = arguments_;
+            }
+            /**
+             * @author fenris
+             */
+            class_handler.prototype.filter = function (kind) {
+                var arguments_ = {};
+                for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) {
+                    var _b = _a[_i], name = _b[0], argument = _b[1];
+                    if (argument.kind_get() == kind) {
+                        arguments_[name] = argument;
+                    }
+                }
+                return arguments_;
+            };
+            /**
+             * @author fenris
+             */
+            class_handler.prototype.read = function (environment, input, data) {
+                var _this = this;
+                if (data === void 0) { data = {}; }
+                switch (environment) {
+                    case args.enum_environment.cli:
+                    case args.enum_environment.url: {
+                        // default values
+                        {
+                            for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) {
+                                var _b = _a[_i], name = _b[0], argument = _b[1];
+                                data[name] = argument.default_get();
+                            }
+                        }
+                        // preprocessing
+                        {
+                            // short indicators (lil hacky ...)
+                            {
+                                if (environment == args.enum_environment.cli) {
+                                    for (var _c = 0, _d = Object.entries(this.filter(args.enum_kind.volatile)); _c < _d.length; _c++) {
+                                        var _e = _d[_c], name = _e[0], argument = _e[1];
+                                        // console.info(argument.parameters_get()["indicators_short"].join("|"));
+                                        var pattern_from = "";
+                                        {
+                                            pattern_from += "(?:^|".concat(settings["environment"][environment]["symbols"]["delimiter"], ")");
+                                            pattern_from += "-".concat(argument.parameters_get()["indicators_short"].join("|"));
+                                            pattern_from += "(?:$|".concat(settings["environment"][environment]["symbols"]["delimiter"], ")");
+                                        }
+                                        var pattern_to = "";
+                                        {
+                                            pattern_to += settings["environment"][environment]["symbols"]["delimiter"];
+                                            pattern_to += settings["environment"][environment]["symbols"]["prefix"];
+                                            pattern_to += argument.indicator_main();
+                                            if (argument.type_get() == args.enum_type.boolean) {
+                                                pattern_to += settings["environment"][environment]["symbols"]["delimiter"];
+                                            }
+                                            else {
+                                                pattern_to += settings["environment"][environment]["symbols"]["assignment"];
+                                            }
+                                        }
+                                        var result = input.replace(new RegExp(pattern_from, "g"), pattern_to);
+                                        lib_plankton.log.debug("lib_args:read:replacing", {
+                                            "pattern_from": pattern_from,
+                                            "pattern_to": pattern_to,
+                                            "input": input,
+                                            "result": result,
+                                        });
+                                        input = result;
+                                    }
+                                }
+                            }
+                            lib_plankton.log.debug("lib_args:read:current_input", {
+                                "input": input,
+                            });
+                        }
+                        // parsing
+                        {
+                            var parts = input
+                                .split(settings["environment"][environment]["symbols"]["delimiter"])
+                                .filter(function (x) { return (x != ""); });
+                            var index_expected_1 = 0;
+                            parts.forEach(function (part) {
+                                lib_plankton.log.debug("lib_args:read:analyzing", {
+                                    "part": part,
+                                });
+                                var found = [
+                                    function () {
+                                        lib_plankton.log.debug("lib_args:read:probing_as_volatile", {
+                                            "part": part,
+                                        });
+                                        for (var _i = 0, _a = Object.entries(_this.filter(args.enum_kind.volatile)); _i < _a.length; _i++) {
+                                            var _b = _a[_i], name = _b[0], argument = _b[1];
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:trying", {
+                                                "part": part,
+                                                "argument": argument.toString(),
+                                            });
+                                            var pattern = "";
+                                            {
+                                                var pattern_front = "";
+                                                pattern_front += "".concat(settings["environment"][environment]["symbols"]["prefix"]);
+                                                pattern_front += "(?:".concat(argument.parameters_get()["indicators_long"].join("|"), ")");
+                                                pattern += pattern_front;
+                                            }
+                                            {
+                                                var pattern_back = "";
+                                                pattern_back += "".concat(settings["environment"][environment]["symbols"]["assignment"]);
+                                                pattern_back += "(".concat(argument.pattern_value(), ")");
+                                                if (argument.type_get() == args.enum_type.boolean) {
+                                                    pattern_back = "(?:".concat(pattern_back, ")?");
+                                                }
+                                                pattern += pattern_back;
+                                            }
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:pattern", {
+                                                "pattern": pattern,
+                                            });
+                                            var regexp = new RegExp(pattern);
+                                            var matching = regexp.exec(part);
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:matching", {
+                                                "matching": matching,
+                                            });
+                                            if (matching == null) {
+                                                // do nothing
+                                            }
+                                            else {
+                                                argument.assign(data, name, matching[1]);
+                                                return true;
+                                            }
+                                        }
+                                        return false;
+                                    },
+                                    function () {
+                                        lib_plankton.log.debug("lib_args:read:probing_as_positional", {
+                                            "part": part,
+                                        });
+                                        var positional = _this.filter(args.enum_kind.positional);
+                                        for (var _i = 0, _a = Object.entries(positional); _i < _a.length; _i++) {
+                                            var _b = _a[_i], name = _b[0], argument = _b[1];
+                                            if (argument.parameters_get()['index'] !== index_expected_1) {
+                                                // do nothing
+                                            }
+                                            else {
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:trying", {
+                                                    "part": part,
+                                                    "argument": argument.toString(),
+                                                });
+                                                var pattern = "";
+                                                {
+                                                    var pattern_back = "";
+                                                    pattern_back += "(".concat(argument.pattern_value(), ")");
+                                                    pattern += pattern_back;
+                                                }
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:pattern", {
+                                                    "pattern": pattern,
+                                                });
+                                                var regexp = new RegExp(pattern);
+                                                var matching = regexp.exec(part);
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:matching", {
+                                                    "matching": matching,
+                                                });
+                                                if (matching == null) {
+                                                    return false;
+                                                }
+                                                else {
+                                                    argument.assign(data, name, matching[1]);
+                                                    index_expected_1 += 1;
+                                                    return true;
+                                                }
+                                            }
+                                        }
+                                        return false;
+                                    },
+                                ].some(function (x) { return x(); });
+                                if (!found) {
+                                    lib_plankton.log.warning("lib_args:read:could_not_parse", {
+                                        "part": part,
+                                    });
+                                }
+                            });
+                        }
+                        return data;
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled environment ".concat(environment)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             * @todo handle if the data object doesn't have the required field or the type is wrong or sth.
+             */
+            class_handler.prototype.write = function (environment, data) {
+                switch (environment) {
+                    case args.enum_environment.cli: {
+                        return (([]
+                            .concat(Object.entries(this.filter(args.enum_kind.volatile)).map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var values;
+                            switch (argument.mode_get()) {
+                                case args.enum_mode.replace: {
+                                    values = [data[argument.name_get()]];
+                                    break;
+                                }
+                                case args.enum_mode.accumulate: {
+                                    values = data[argument.name_get()];
+                                    break;
+                                }
+                            }
+                            return (values
+                                .map(function (value) { return ((settings["environment"][environment]["symbols"]["prefix"]
+                                +
+                                    argument.parameters_get()["indicators_long"][0])
+                                +
+                                    (settings["environment"][environment]["symbols"]["assignment"]
+                                        +
+                                            value.toString())); })
+                                .join(" "));
+                        }))
+                            .concat(Object.entries(this.filter(args.enum_kind.positional)).map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var raw = "";
+                            {
+                                var raw_back = "";
+                                raw_back += argument.make(data, name);
+                                raw += raw_back;
+                            }
+                            return raw;
+                        })))
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]));
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled environment ".concat(environment)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @desc manpage-like info-sheet
+             * @author fenris
+             */
+            class_handler.prototype.generate_help = function (_a) {
+                var _b = _a["programname"], programname = _b === void 0 ? null : _b, _c = _a["author"], author = _c === void 0 ? null : _c, _d = _a["description"], description = _d === void 0 ? null : _d, _e = _a["executable"], executable = _e === void 0 ? null : _e;
+                var environment = args.enum_environment.cli;
+                var output = "";
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "INFO";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        var line = "";
+                        line += "\t";
+                        line += "".concat(programname, " -- ").concat(description);
+                        line += "\n";
+                        section += line;
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                {
+                    if (author != null) {
+                        var section = "";
+                        {
+                            var line = "";
+                            line += "";
+                            line += "AUTHOR";
+                            line += "\n";
+                            section += line;
+                        }
+                        {
+                            var line = "";
+                            line += "\t";
+                            line += "".concat(author);
+                            line += "\n";
+                            section += line;
+                        }
+                        section += "\n";
+                        output += section;
+                    }
+                }
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "SYNOPSIS";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        var line = "";
+                        line += "\t";
+                        line += executable;
+                        line += settings["environment"][environment]["symbols"]["delimiter"];
+                        line += Object.entries(this.filter(args.enum_kind.positional))
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var part = "";
+                            part += "<".concat(argument.name_get(), ">");
+                            return part;
+                        })
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]);
+                        line += settings["environment"][environment]["symbols"]["delimiter"];
+                        line += Object.entries(this.filter(args.enum_kind.volatile))
+                            .filter(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return (!argument.hidden_get());
+                        })
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var part = "";
+                            // part += settings["environment"][environment]["symbols"]["prefix"];
+                            part += "-";
+                            part += argument.parameters_get()["indicators_short"][0];
+                            if (argument.type_get() != "boolean") {
+                                /*
+                                part += settings["environment"][environment]["symbols"]["assignment"];
+                                part += `<${argument.name_get()}>`;
+                                 */
+                                part += " ";
+                                part += "<".concat(argument.name_get(), ">");
+                            }
+                            part = "[".concat(part, "]");
+                            return part;
+                        })
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]);
+                        line += "\n";
+                        section += line;
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "OPTIONS";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        section += (Object.entries(this.arguments_)
+                            .filter(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return (!argument.hidden_get());
+                        })
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return argument.generate_help();
+                        })
+                            .join("\n"));
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                return output;
+            };
+            return class_handler;
+        }());
+        args.class_handler = class_handler;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
diff --git a/tools/update-plankton b/tools/update-plankton
index da129fd..2934da0 100755
--- a/tools/update-plankton
+++ b/tools/update-plankton
@@ -10,11 +10,14 @@ dir="lib/plankton"
 modules=""
 modules="${modules} base"
 modules="${modules} call"
+modules="${modules} json"
+modules="${modules} file"
+modules="${modules} args"
 
 
 ## exec
 
-mkdir -p ${dir}
+mkdir --parents ${dir}
 cd ${dir}
 ptk bundle node ${modules}
 cd - > /dev/null