diff --git a/.github/workflows/test-skripts.yml b/.github/workflows/test-skripts.yml
index 700330c..61be5e3 100644
--- a/.github/workflows/test-skripts.yml
+++ b/.github/workflows/test-skripts.yml
@@ -43,7 +43,7 @@ jobs:
         run: |
           mkdir -p build/libs
           curl -L -o build/libs/skript-reflect.jar \
-            https://github.com/SkriptLang/skript-reflect/releases/download/v2.6.1/skript-reflect-2.6.1.jar
+            https://github.com/SkriptLang/skript-reflect/releases/download/v2.6.3/skript-reflect-2.6.3.jar
             
       - name: Download Routines from JitPack
         run: |
@@ -54,26 +54,41 @@ jobs:
       
           curl -L --fail -o build/libs/skript-reflect/routines-paper.jar \
             https://jitpack.io/com/github/devdinc/routines/routines-paper/v2.2.1/routines-paper-v2.2.1.jar
-      # Disable pdc for now, i want to remove skbee req
-      # Disable config reload
+            
       - name: Prepare scripts
         run: |
           mkdir -p tests/scripts
           rsync -av scripts/ tests/scripts/
-          mv tests/scripts/libs/singlelinesection.sk tests/scripts/libs/0_singlelinesection.sk
-          rm -f tests/scripts/utils/testframework.sk
           rm -f tests/scripts/utils/configreloadv2.sk
+      
+      - name: Force-load Skript native test suite
+        run: |
+          cat > tests/zzzz_force_native_tests.sk <<'EOF'
+          import:
+              ch.njol.skript.test.runner.SkriptTestEvent
           
+          test "run devdinc tests":
+              event is instance of SkriptTestEvent
+              send "Running devdinc tests" to console
+
+              set {_list::string} to "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
+              set {_list::boolean} to false
+
+              call custom event "skriptTest" with {_list::*}
+
+              set {_tests::*} to all tests
+              autorun {_tests::*}
+          EOF
 
       - name: Run tests
         uses: devdinc/skript-test-action@v1.3
         with:
-          skript_repo_url: https://github.com/devdinc/Skript.git
+          skript_repo_url: https://github.com/SkriptLang/Skript.git
           # directory where your test scripts are located (relative to repo root)
           test_script_directory: tests
 
           # Skript version or ref (tag, branch, or commit)
-          skript_repo_ref: ef28bd5 # 2.13.2
+          skript_repo_ref: dev/feature
 
           # directory containing addon/plugin jars (relative to repo root)
           extra_plugins_directory: build/libs
diff --git a/.restructure b/.restructure
index 64b3cec..e518a3b 100644
--- a/.restructure
+++ b/.restructure
@@ -1,7 +1,7 @@
 using scripts
 
 prefix:
-  0 libs/singlelinesection.sk
+  0 libs/parser/singlelinesection.sk
   1 libs/functionsv2.sk
   2 libs/routines.sk
   3 .
diff --git a/README.md b/README.md
index 38d5b1d..1a025f2 100644
--- a/README.md
+++ b/README.md
@@ -35,10 +35,3 @@ If you encounter errors such as `Can't understand this expression`, the issue is
 
 Skript loads files alphabetically, with folders being prioritized. To control load order, prefix the Skript file with a folder or a character such as `0_` or `!`
 (e.g., `!testframework.sk`)
-
-## TODO
-
-Currents plans include:
-- multiline lambda expression
-- making the test framework support extending over the skriptlang native test suit
-- Auto casting for primitives, pdc.sk(new Byte,Integer etc)
diff --git a/docs/functions.md b/docs/functions.md
index 073b75f..d2991e0 100644
--- a/docs/functions.md
+++ b/docs/functions.md
@@ -31,16 +31,17 @@ All generated lambdas are real Java proxy instances.
 
 ---
 
-## Core Lambda Syntax
+## Core Lambda Syntax (Single-Line)
 
 ### 1. Returning Lambda
 
 ```skript
 lambda [<variables>]: <expression>
-```
+````
 
 * Returns a value
 * Automatically mapped to a Java functional interface
+* Return vs effect behavior is auto-detected
 
 ---
 
@@ -66,6 +67,67 @@ lambda [<variables>]:+ <expression>
 
 ---
 
+## Multiline Lambdas (Section-Based)
+
+Lambdas may also be written as **multiline sections**.
+These allow more complex logic while still compiling into Java functional interfaces.
+
+Multiline lambdas are created using **typed aliases** (`new runnable:`, `new function {_x}:`, etc.).
+
+---
+
+### Multiline Non-Returning Lambda
+
+Maps to:
+
+* `Runnable`
+* `Consumer<T>`
+* `BiConsumer<T, U>`
+
+depending on arity.
+
+```skript
+set {_task} to new runnable:
+    broadcast "working"
+    broadcast "still working"
+```
+
+Rules:
+
+* Produces **no return value**
+* All lines must be **effects**
+* `return` is not allowed
+
+---
+
+### Multiline Returning Lambda
+
+Multiline returning lambdas **must use the `return` effect**.
+The lambda does **not** infer a return value from the last line.
+
+```skript
+set {_double} to new function {_x}:
+    broadcast "doubling %{_x}%"
+    return {_x} * 2
+```
+
+Rules:
+
+* `return <expression>` is **mandatory**
+* The final line does **not** need to be an expression
+* Effects may appear anywhere before `return`
+* Multiple control-flow paths may use `return`
+
+Maps to:
+
+* `Supplier<T>`
+* `Function<T, R>`
+* `BiFunction<T, U, R>`
+
+based on arity.
+
+---
+
 ## Java Interface Mapping (Arity-Based)
 
 The target Java interface is selected based on **parameter count** and **return behavior**.
@@ -93,7 +155,9 @@ The target Java interface is selected based on **parameter count** and **return
 
 > Lambdas with more than **2 parameters are not supported**.
 
-### Workaround for Higher Arity
+---
+
+## Workaround for Higher Arity
 
 Pass a single composite object instead:
 
@@ -196,7 +260,8 @@ biaccepter {_a}, {_b}:
 
 ```skript
 set {_f} to function {_x}: {_x} * 2
-set {_r} to runnable: broadcast "hello"
+set {_r} to runnable:
+    broadcast "hello"
 ```
 
 ---
@@ -239,38 +304,38 @@ set {_adder} to lambda {_m}:- {_m}.values().stream().forEach({_inlineforeach})
 
 ## Limitations
 
-* Lambdas are **strictly single-line**
-* Returning lambdas (`:` / `:+`) **cannot contain effects**
-* Non-returning lambdas (`:-`) **cannot contain expressions**
-* Non-returning lambdas **cannot return values**
+* Lambdas may be **single-line or multiline**
+* Single-line lambdas infer return vs effect behavior
+* Multiline returning lambdas **require `return`**
+* Multiline non-returning lambdas **must not return**
+* Lambdas are limited to **0–2 parameters**
 * Variable lists as parameters are **not supported**
 * Arrays are unreliable inside lambdas:
 
   * Indexing (`[n]`) does not work
   * Use `spread(...)` before passing arrays
-* Imported classes or complex expressions **may fail inline**
-
-  * Mitigations:
+* Imported classes or complex expressions may fail inline
 
-    * Explicitly use `:+` or `:-`
-    * Wrap logic in a normal function and call it
+  * Prefer multiline lambdas
+  * Or wrap logic in a normal Skript function
 
 ---
 
 ## Notes
 
-* Return vs effect behavior is **auto-detected** unless overridden with `:-` or `:+`
+* Single-line lambdas auto-detect return vs effect
+* Multiline lambdas require explicit intent
 * Lambdas are real Java proxy objects and fully compatible with:
 
   * Java streams
   * Java APIs
   * skript-reflect usage
+* Experimentally, local values are passed into lambda sections. Use with care.
 
 ---
 
-* Experimentally local values are passed into the section. You can use local values, but be careful.
-
 ## Planned
 
 * Additional utility expressions (e.g., `for each` helpers)
 * These will be introduced in **separate files**
+
diff --git a/docs/pdc.md b/docs/pdc.md
index 2adee52..689d457 100644
--- a/docs/pdc.md
+++ b/docs/pdc.md
@@ -1,8 +1,5 @@
-
 # Persistent Data Container (PDC) Utility Expressions for Skript
 
-> **WARNING:** Read migration notes carefully before upgrading.
-
 ---
 
 ## Overview
@@ -11,94 +8,98 @@ This document describes a set of Skript expressions and helpers for interacting
 
 It supports:
 
-- Native `PersistentDataType` (PDT) values  
+- Native `PersistentDataType` (PDT) values
 - Arbitrary object storage via Java serialization into `BYTE_ARRAY`
 
 ---
 
-## Migration Notice (Base64 Removed)
+## Requirements
 
-Previous versions serialized arbitrary objects using Base64 encoding and stored them as `STRING` values.
+- Paper server
+- Skript
+- skript-reflect
 
-**This implementation no longer uses Base64.**
+---
 
-Arbitrary objects are now:
+## Key Features
 
-- Serialized directly using `BukkitObjectOutputStream`
-- Stored natively as `PersistentDataType.BYTE_ARRAY`
+### 1. Unified `key … in pdc` Expression
 
-This is a **storage-format change only**.  
-Arbitrary object support remains fully supported.
+- Read, write, and delete PDC entries using a single expression
+- Automatically resolves:
+  - `PersistentDataHolder` → `PersistentDataContainer`
 
-### Required User Action
+---
 
-- Existing Base64-encoded PDC values are **not compatible**
-- Stored data must be migrated or deleted
+### 2. Native and Arbitrary Object Storage
 
-Scripts do **not** require syntax changes, but values written by older versions will not deserialize correctly.
+- When a `PersistentDataType` is provided:
+  → Values are stored natively using that PDT
+- When omitted:
+  → Values are serialized and stored as `PersistentDataType.BYTE_ARRAY`
 
 ---
 
-## Requirements
+### 3. Built-in NamespacedKey Handling
 
-- Paper server  
-- Skript  
-- skript-reflect  
+There is **no standalone NamespacedKey expression**.
 
----
+Instead, namespaced keys are handled directly by the main expression using string input.
 
-## Key Features
+Key strings must be in the form:
 
-### 1. Unified `key in pdc` Expression
+```
 
-- Read, write, and delete PDC entries using a single expression
-- Automatically resolves:
-  - `PersistentDataHolder` → `PersistentDataContainer`
+namespace:key
 
-### 2. Native and Arbitrary Object Storage
+````
 
-- When a `PersistentDataType` is provided:  
-  → Values are stored natively
-- When omitted:  
-  → Values are serialized and stored as `BYTE_ARRAY`
+Example:
 
-### 3. NamespacedKey Convenience Expression
+```skript
+"minecraft:foo"
+"myplugin:data"
+````
 
-- Allows creation of `NamespacedKey` from strings such as:
-  - `plugin:key`
+---
 
 ### 4. Safety and Validation
 
-- Runtime validation ensures correct types for:
-  - Key
-  - Container
-  - PersistentDataType
-- Invalid expressions fail silently to avoid hard Skript errors
+* Runtime validation ensures correct types for:
+
+  * Key string
+  * Container / holder
+  * PersistentDataType (if provided)
+* Invalid expressions fail silently to avoid hard Skript errors
 
 ---
 
 ## Serialization Notes
 
-- Arbitrary objects are serialized using `BukkitObjectOutputStream`
-- Data is stored directly as `byte[]` via `PersistentDataType.BYTE_ARRAY`
-- Objects **must** implement `java.io.Serializable`
-
-### Compared to Base64
-
-- Lower overhead
-- No string encoding or decoding
-- Direct compatibility with Bukkit PDC APIs
+* Arbitrary objects are serialized using `BukkitObjectOutputStream`
+* Data is stored directly as `byte[]` via `PersistentDataType.BYTE_ARRAY`
+* Objects **must** implement `java.io.Serializable`
 
 ---
 
 ## Syntax Summary
 
+### Core Expression
+
+```skript
+expression [devdinc] [namespaced]( |-)key %string% [with]in %pdcholder/pdc% [for %-pdt%]
+```
+
+---
+
 ### Reading
 
 ```skript
 set {_value} to key "plugin:test" within player's pdc
 set {_value} to key "plugin:test" in player's pdc for pdt string
-````
+```
+
+---
 
 ### Writing
 
@@ -107,6 +108,8 @@ set key "plugin:test" within player's pdc to {_object}
 set key "plugin:test" in player's pdc for pdt integer to 5
 ```
 
+---
+
 ### Deleting
 
 ```skript
@@ -115,10 +118,11 @@ delete key "plugin:test" within player's pdc
 
 ---
 
-## Notes
+## Behavior Notes
 
 * If no `PersistentDataType` is specified, `BYTE_ARRAY` storage is used
-* Deleting a key or setting its value to `null` removes the entry
+* Setting a key to `null` removes the entry
+* Deleting a key removes it regardless of storage type
 
 ---
 
@@ -126,4 +130,7 @@ delete key "plugin:test" within player's pdc
 
 * Deserialization failures will propagate runtime errors
 * Class definition changes may break previously serialized data
-* Old Base64-encoded values must be migrated manually
+* Stored objects must remain compatible with Java serialization
+
+---
+
diff --git a/docs/scopedvariables.md b/docs/scopedvariables.md
new file mode 100644
index 0000000..d8022cc
--- /dev/null
+++ b/docs/scopedvariables.md
@@ -0,0 +1,249 @@
+# Scoped Variables Utility for Skript
+
+This module introduces **scoped variables**, allowing variables to be namespaced automatically by
+script, folder (package), or a custom scope string.
+
+It provides:
+
+- A configurable **default scope per script**
+- A `scoped variable` expression that transparently rewrites variable paths
+- Full support for **get / set / add / remove / delete / reset**
+- Correct handling of **local**, **ephemeral**, and **list** variables
+
+All scoping is implemented by rewriting variable names internally.
+
+---
+
+## Concepts
+
+### What Is a Scoped Variable?
+
+A scoped variable is a normal Skript variable whose **storage key is prefixed with a scope**.
+
+Instead of:
+
+```skript
+set {count} to 1
+````
+
+you get:
+
+```text
+scoped::<scope>::count
+```
+
+Scopes prevent collisions between scripts, folders, or logical modules while still using Skript’s variable system.
+
+---
+
+## Default Scope per Script
+
+Each script can define a **default scope** that is used whenever no explicit scope is provided.
+
+### Effect Syntax
+
+```skript
+set default scope for scoped variables in current script to
+    current folder
+    current package
+    current script
+    folder <string>
+    package <string>
+    <script>
+```
+
+### Meanings
+
+| Option                                 | Resulting Scope                               |
+| -------------------------------------- | --------------------------------------------- |
+| `current script`                       | Script file name                              |
+| `current folder` / `current package`   | Script’s parent folder relative to `/scripts` |
+| `folder <string>` / `package <string>` | Custom folder/package scope                   |
+| `<script>`                             | Explicit script scope                         |
+
+### Examples
+
+```skript
+set default scope for scoped variables in current script to current folder
+```
+
+```skript
+set default scope for scoped variables in current script to folder "economy"
+```
+
+```skript
+set default scope for scoped variables in current script to script "main.sk"
+```
+
+If no default scope is set, the script name is used.
+
+---
+
+## Scoped Variable Expression
+
+### Syntax
+
+```skript
+scoped [variable] %variable% [within|from|by
+    %-script%
+  | current folder
+  | current package
+]
+```
+
+This expression rewrites the backing variable name based on:
+
+* The variable being accessed
+* The resolved scope
+* Variable modifiers (local, ephemeral, list)
+
+---
+
+## Scope Resolution Rules
+
+If no explicit scope is provided:
+
+1. Use the script’s **default scope**, if set
+2. Otherwise, use the **current script name**
+
+If an explicit scope is provided:
+
+| Clause                               | Scope Used             |
+| ------------------------------------ | ---------------------- |
+| `within <script>`                    | That script            |
+| `current folder` / `current package` | Script’s parent folder |
+
+---
+
+## Variable Modifiers
+
+Scoped variables preserve all Skript variable semantics.
+
+### Local Variables
+
+```skript
+set {_x} to 1
+set scoped {_x} to 5
+```
+
+→ stored under:
+
+```text
+_scoped::<scope>::x
+```
+
+---
+
+### Ephemeral Variables
+
+```skript
+set {-temp} to 3
+set scoped {-temp} to 9
+```
+
+→ stored under:
+
+```text
+-scoped::<scope>::temp
+```
+
+---
+
+### List Variables
+
+```skript
+set {data::a} to 1
+set scoped {data::*} to 2
+```
+
+→ stored under:
+
+```text
+scoped::<scope>::data::*
+```
+
+---
+
+## Supported Operations
+
+The `scoped variable` expression supports **all standard variable operations**:
+
+* get
+* set
+* add
+* remove
+* remove all
+* delete
+* reset
+
+### Examples
+
+```skript
+set scoped {count} to 1
+add 5 to scoped {count}
+broadcast scoped {count}
+```
+
+```skript
+delete scoped {playerdata::*}
+```
+
+```skript
+set scoped {_local} to "hello"
+```
+
+---
+
+## Explicit Scope Usage
+
+```skript
+set scoped {coins} within current folder to 100
+```
+
+```skript
+set scoped {coins} within script "bank.sk" to 250
+```
+
+---
+
+## Internal Storage Format
+
+Internally, variables are rewritten as:
+
+```text
+[prefix]scoped::<scope>::<variable-name>[:: *]
+```
+
+Where:
+
+* `prefix` is:
+
+  * `_` for local variables
+  * `-` for ephemeral variables
+* `<scope>` is the resolved scope string
+* `::*` is appended for list variables
+
+This is an implementation detail and should not be relied upon directly.
+
+---
+
+## Notes & Caveats
+
+* Scoped variables are **not a new variable type** — they are rewritten normal variables
+* Scope resolution depends on the script’s file path
+* Moving scripts between folders may change scope values
+* Local and ephemeral behavior matches native Skript semantics
+* Variable names are resolved at runtime using the current event
+
+---
+
+## Intended Use Cases
+
+* Script modularization
+* Library-style Skript files
+* Avoiding global variable collisions
+* Folder-based namespaces
+* Shared state with controlled visibility
+
+---
+
diff --git a/docs/testframework.md b/docs/testframework.md
index 6c4cec1..acf8841 100644
--- a/docs/testframework.md
+++ b/docs/testframework.md
@@ -2,55 +2,107 @@
 
 ## Overview
 
-This document describes a **self-contained runtime testing framework for Skript**. The framework replicates much of Skript’s internal development test suite while extending it with runtime-safe execution, reflection-based inspection, and deterministic event-driven control.
+## Compatibility with Skript Native Tests
 
-Unlike Skript’s native internal tests, this framework:
+This framework **is compatible** with Skript’s native **quickTest** and **test-action** systems, but with important limitations.
 
-* Runs entirely at runtime
-* Is safe for production servers
-* Supports both **automatic (autorun)** and **manual** execution
-* Tracks failures centrally with optional console suppression
+### What Actually Happens
 
-All framework state is stored under the `-test.sk::*` namespace.
+When using Skript’s native test suite:
+
+* Skript’s own `test` event **overrides** the framework’s `skriptTest` event
+* Only features that exist in Skript’s native test environment are available
+* Framework-specific extensions become unavailable
+
+As a result:
+
+* Core assertions such as:
+
+```skript
+assert <condition>
+```
+
+remain usable
+
+* Framework-specific features such as:
+
+```skript
+stop auto test execution here
+```
+
+are **not usable** under quickTest or native `test-action`
+
+* Extended event-values (`event-test`, autorun flag, script scoping) may be missing or incomplete
+
+### Mitigation Strategy
+
+To regain full framework behavior, simply **prefix your existing test with `devdinc`**:
+
+```skript
+devdinc test "<name>"
+```
+
+This forces execution through the framework’s custom event pipeline and restores:
+
+* Full event-values
+* Autorun vs manual execution control
+* Reflection-backed features
+
+### Recommendation
+
+* **Prefer Skript’s native test suite when possible** for maximum compatibility
+* Use `devdinc test` only when you need:
+
+  * Script scoping
+    n  * Autorun control
+  * Parser / log inspection
+  * Extended lifecycle hooks
 
 ---
 
-## Design Goals
+This document describes a **runtime testing framework for Skript** implemented entirely in Skript using **custom events, reflection, and controlled parser interaction**.
 
-The framework is intentionally minimal and predictable, prioritizing correctness and isolation over flexibility.
+The framework is designed to mirror key aspects of Skript’s internal development test suite while remaining:
 
-It is designed to:
+* Safe to execute at runtime
+* Deterministic and event-driven
+* Compatible with production servers
+* Capable of testing **syntax, parsing, and runtime behavior**
 
-* Allow tests to be written directly in `.sk` files
-* Achieve functional parity with Skript’s internal test actions where feasible
-* Enable meta-testing of Skript syntax and parser behavior
-* Support fail-fast behavior with optional non-halting assertions
-* Prevent state leakage between tests
+All framework state is stored under the namespace:
+
+```
+-test.sk::*
+```
 
 ---
 
-## Feature Parity with Skript’s Native Test Suite
+## Design Goals
+
+The framework is intentionally strict and explicit.
 
-| Feature                   | Status       | Description                                           |
-| ------------------------- | ------------ | ----------------------------------------------------- |
-| **Test structure**        | Achieved     | `test %string%` mirrors native test declarations      |
-| **Conditional execution** | Achieved     | `when <condition>` skips tests dynamically            |
-| **Assertions**            | Achieved     | `assert <condition>` and `assert <condition> to fail` |
-| **Explicit failure**      | Achieved     | `fail test` effect                                    |
-| **Parser inspection**     | Experimental | Parse sections and log capture                        |
+It aims to:
+
+* Allow tests to be written directly in `.sk` files
+* Associate tests **with the script they originate from**
+* Support both **automatic (autorun)** and **manual** execution paths
+* Provide before/after hooks at both **per-test** and **per-script** levels
+* Prevent state leakage between tests
+* Enable parser-level testing via reflection
 
 ---
 
 ## High-Level Architecture
 
-The framework is built around four core principles:
+The framework is built around the following principles:
 
-1. **Tests are custom events**
-2. **Tests are registered implicitly at parse time**
-3. **Execution is event-driven, not inline**
-4. **Failures are tracked centrally per test**
+1. **Tests are custom events** (`skriptTest`)
+2. **Tests are registered at parse time**
+3. **Execution is scheduled, not inline** (scheduler + proxy Runnable)
+4. **Each test is scoped to its source script**
+5. **Failures are tracked per test, per script**
 
-Each test executes inside a dedicated `skriptTest` event context.
+Execution is fully event-driven and never relies on direct control flow from the script loader.
 
 ---
 
@@ -59,39 +111,73 @@ Each test executes inside a dedicated `skriptTest` event context.
 ### Syntax
 
 ```skript
-test "<test name>" [when <condition>]:
+devdinc test "<test name>" [when <condition>]:
     <test body>
 ```
 
-* Tests are registered automatically when the script is parsed
-* The optional `when` condition is evaluated immediately before execution
+* Tests are registered automatically during parsing
+* `when <condition>` is evaluated immediately before execution
+* Each test is associated with its **originating script**
 
-### Event Context
+---
 
-Inside a test, the framework provides:
+### Syntax
 
-* **`event-string` / `event-test`**
-  Fully-qualified test identifier:
+```skript
+devdinc test "<test name>" [when <condition>]:
+    <test body>
+```
+
+* Tests are registered automatically during parsing
+* `when <condition>` is evaluated immediately before execution
+* Each test is associated with its **originating script**
+
+---
 
-  ```
-  <test name>
-  ```
+## Test Identity & Scoping
 
-* **`event-boolean`**
-  Indicates whether the test is running in **autorun mode**
+Each test is uniquely identified by **both its name and its source script**.
+
+Internal representation:
+
+```
+[event-string, event-script]
+```
+
+This ensures:
+
+* No collisions between scripts
+* Deterministic execution order
+* Correct isolation and error attribution
 
 ---
 
-## Test Registration
+Internally, each test is stored as a **pair**:
 
-Tests are registered automatically at parse time. No explicit registration step is required.
+```
+[<test name>, <script>]
+```
 
-Internal storage format:
+This enables:
+
+* Multiple scripts defining tests with identical names
+* Script-scoped test execution
+* Accurate isolation and error tracking
+
+---
+
+## Test Registration (Parse-Time)
+
+Tests are registered during the **parse phase**, not execution.
+
+Registration format:
 
 ```
--test.sk::tests::<test name>
+-test.sk::tests::<script>::<test name> = [<test name>, <script>]
 ```
 
+A hidden sentinel test is used during load to guarantee full registration before autorun begins.
+
 ---
 
 ## Running Tests
@@ -100,31 +186,34 @@ Internal storage format:
 
 On script load:
 
-1. Previous global test state is cleared
-2. A hidden sentinel test establishes autorun context
-3. All registered tests are discovered
-4. Tests are executed in autorun mode
+1. Global test state is cleared
+2. A sentinel test establishes autorun context
+3. All tests across all scripts are discovered
+4. Tests are executed in load order
+
+Autorun tests receive:
 
-Autorun execution passes `true` as the event-boolean value.
+```
+event-boolean = true
+```
 
 ---
 
 ### Manual Execution
 
 ```skript
-run test(s) %strings%
+run test(s) %objects%
 ```
 
-* Accepts one or more **fully-qualified test identifiers**
-* Clears prior error state for each test
-* Executes tests outside autorun mode
-
-Identifier format:
+* Accepts one or more `[test name, script]` objects
+* Runs tests with:
 
 ```
-<test name>
+event-boolean = false
 ```
 
+* Autorun-only tests may opt out (see below)
+
 ---
 
 ## Test Discovery
@@ -132,154 +221,187 @@ Identifier format:
 ### Expression
 
 ```skript
-all tests [with test name %-string%]
+all tests [with test name %-string%] [[in] %-script%]
 ```
 
 ### Behavior
 
 * No arguments → all tests from all scripts
-* `with test name <string>` → exact match only
+* `with test name` → exact match
+* `in <script>` → restricts to a single script
 
-Returned values are fully-qualified test identifiers.
+Return type:
+
+```
+[test name, script]
+```
 
 ---
 
 ## Assertions
 
-Assertions validate test behavior and record failures.
+Assertions validate runtime conditions and record failures.
 
-### Syntax Variants
+### Syntax
 
 ```skript
 assert true: <condition>
 assert false: <condition>
-assert <condition> [to fail]
+assert <condition> to fail
 ```
 
-### Optional Modifiers
+### Modifiers
 
-* **`without halting`**
-  Records failure but continues execution
+* `without halting` – records failure but continues
+* `with error message "<msg>"` – prints formatted output
+* `with no error message` – suppresses console output
 
-* **`with error message "<message>"`**
-  Prints formatted failure output
+Assertions are only valid inside `skriptTest`.
 
-* **`with no error message`**
-  Suppresses console output entirely
+---
+
+## Explicit Failure
 
-Assertions are only valid inside a test context.
+```skript
+fail test
+fail test with error message "<msg>"
+```
+
+* Records a failure immediately
+* Halts execution unless `without halting` is used
 
 ---
 
 ## Error Tracking
 
+Errors are tracked per **test + script**:
+
+```
+-test.sk::errors::<script>::<test name>::*
+```
+
 ### Expression
 
 ```skript
-test errors [for %-strings%]
+test errors [for %-objects%]
 ```
 
-* Returns all recorded failures for the current test
-* Includes:
+* Without arguments → current test
+* With objects → aggregated errors
 
-  * Assertion failures
-  * Explicit `fail test` invocations
-  * Internally tracked errors
-
-Errors are reset between tests and never leak across executions.
+Errors are cleared before each test and never leak.
 
 ---
 
-## Explicit Test Failure
+## Event Values (Complete Reference)
 
-### Syntax
+Every test and lifecycle hook executed by this framework exposes the following **event-values**:
 
-```skript
-fail test
-fail test with error message "<message>"
-```
+| Event Value     | Type    | Meaning                        |
+| --------------- | ------- | ------------------------------ |
+| `event-string`  | string  | Test name                      |
+| `event-script`  | script  | Script that defines the test   |
+| `event-boolean` | boolean | Autorun flag                   |
+| `event-test`    | object  | `[event-string, event-script]` |
 
-Behavior:
+### Availability
 
-* Records a failure immediately
-* Optionally prints formatted output
-* Halts execution unless `without halting` is specified
+* All values are guaranteed when using `devdinc test`
+* Under Skript native tests, availability depends on Skript’s test runner
 
-## Autorun Execution Semantics
+---
+
+---------------|----------|--------|
+| `event-string`   | string   | Test name |
+| `event-script`   | script   | Originating script |
+| `event-boolean`  | boolean  | Autorun flag |
+| `event-test`     | object   | `[event-string, event-script]` |
+
+These values are **guaranteed** only when using `devdinc test`.
 
-### Autorun Flag (Test Context)
+They are **undefined** when running via quickTest or native test-action.
+
+---
 
-**Expression:**
+## Autorun Semantics
+
+### Autorun Flag
 
 ```skript
 event-test is autorun
 event-test is not autorun
 ```
 
-**Type:** Boolean condition
+* `true` during load-time execution
+* `false` during manual execution
 
-**Meaning:**
+The flag is immutable and scoped to the test event.
 
-* Evaluates to `true` when the current test is executing as part of automatic test execution
-* Evaluates to `false` when the test is executed manually via `run test(s)`
+---
 
-**Scope:**
+### Stopping Autorun Execution
 
-* Valid only inside a `test` block
-* Bound to the `skriptTest` event context
+```skript
+stop auto test execution here
+```
+
+* Halts the current test **only if** autorun is active
+* No effect during manual execution
 
-**Notes:**
+Typical usage:
 
-* This flag is set by the framework before test execution begins
-* It remains constant for the duration of the test
-* It is commonly used to guard unsafe, destructive, or environment-dependent logic
+```skript
+if event-test is autorun:
+    stop auto test execution here
+```
 
 ---
 
-### Autorun Control Effect
+## Test Lifecycle Hooks
 
-**Syntax:**
+The framework provides structured lifecycle hooks that integrate with both framework and native execution.
+
+### Hooks
 
 ```skript
-stop auto test execution here
+before each test
+after each test
+before all tests
+after all tests
 ```
 
-**Behavior:**
+### `event-script` Usage
 
-* If `event-test is autorun`:
+Inside **all** lifecycle hooks, `event-script` refers to:
 
-  * Immediately halts execution of the current test
-    
-* If `event-test is not autorun`:
+> **The script whose tests are currently executing**
 
-  * Has no effect
+Examples:
 
-**Use Case:**
-Allows tests to opt out of autorun safely while still being available for manual execution.
+```skript
+before all tests:
+    broadcast "Running tests for %event-script%"
 
----
+after each test:
+    delete {-tmp::%event-script%::*}
+```
 
-### Typical Usage Pattern
+This allows:
 
-```skript
-test "destructive test":
-    if event-test is autorun:
-        stop auto test execution here
-    # manual-only logic below
-```
+* Per-script setup and teardown
+* Shared resources scoped to a script
+* Accurate cleanup even when multiple scripts define tests
 
----
+### Execution Semantics
 
-### Guarantees
+* `before all tests` / `after all tests` run **once per script**
+* `before each test` / `after each test` run **per test**, with `event-string` set
 
-* Autorun mode is always enabled during load-time execution
-* Manual execution always runs with autorun disabled
-* The autorun flag is not mutable by user code
-* Autorun state never leaks between tests
+---
 
-## Experimental: Parsing & Log Inspection
+## Parser & Syntax Testing (Reflection)
 
-The framework supports testing Skript syntax itself.
+The framework supports **parser-level testing** using reflection.
 
 ### Parse Section
 
@@ -288,96 +410,137 @@ parse:
     <skript code>
 ```
 
-* Attempts to parse the nested code using `ParserInstance`
-* Does not execute the code
+* Uses `ParserInstance` to parse nodes
+* Does not execute code
+* Fully restores parser state afterward
 
-### Log Inspection
+### Log Capture
 
 ```skript
 last parse logs
 ```
 
-* Returns all `SkriptLogger` messages captured during the most recent parse
-* Enables validation of expected parser errors
+* Captures `SkriptLogger` output
+* Enables assertions against expected parser errors
+
+---
+
+## Native TestTracker Integration (Experimental)
+
+Failures are forwarded to Skript’s internal `TestTracker`.
+
+### Implications
+
+* Native reporting tools can observe results
+* CI-style environments can consume output
+
+### Limitations
+
+* Experimental and version-dependent
+* No compatibility guarantees
+
+You **must** use:
+
+```skript
+devdinc test "<name>"
+```
+
+Native `test` syntax is not supported.
 
 ---
 
 ## Test Environment Utilities
 
-To ensure isolation and repeatability, the framework provides controlled test fixtures:
+The framework provides controlled fixtures:
 
-* **`test-world`** – dedicated test world
-* **`test-location`** – fixed location (`spawn + 10, 1, 0`)
-* **`test-block`** – self-resetting block restored after tests
-* **`test-offline-player`** – generated offline player instance
+* `test-world` – `skripttest` or fallback world
+* `test-location` – fixed offset location
+* `test-block` – temporary block (auto-restored)
+* `test-offline-player` – generated offline player
+
+These utilities guarantee cleanup after each test.
 
 ---
 
-## Failure Reporting
+## World Isolation Policy
 
-Each test maintains its own failure count:
+### Default
 
-```
--test.sk::errors::<test id>
-```
+* World state is **shared** across tests
+* This is intentional for performance and safety
 
-After execution completes:
+### Opt-In Isolation
 
-* A summary line is printed:
+Users may implement isolation manually via hooks:
 
-```
-<X>/<Y> tests passed
-```
+```skript
+before each test:
+    # snapshot world
 
-Where:
+after each test:
+    # restore world
+```
 
-* `Y` = executed tests
-* `X` = tests without recorded failures
+No built-in snapshotting is provided.
 
 ---
 
-## Console Output Format
+## Console Output
 
-When enabled, failures are printed as:
+Failures are printed as:
 
 ```
 [Skript] [TEST FAILURE] <test name> <optional message>
 ```
 
-Output is suppressed entirely when `with no error message` is specified.
+Output is suppressed when `with no error message` is used.
 
 ---
 
-## Internal Guarantees
+## Guarantees
 
-The framework guarantees that:
+The framework guarantees:
 
-* Tests are isolated by themselves
-* Registration is implicit and deterministic
-* Autorun and manual execution are distinguishable
-* Failures are recorded even in non-halting mode
-* State never leaks between tests
+* Deterministic registration and execution
+* Script-scoped test isolation
+* No state leakage between tests
+* Reliable autorun vs manual distinction
+* Parser state is always restored
 
 ---
 
-## Internal & Non-Public Details
+## Non-Public Implementation Details
 
-The following are implementation details and must not be relied upon:
+The following must not be relied upon:
 
-* Sentinel test usage
+* Sentinel test mechanics
 * Internal variable layout
-* Reflection-based hooks
+* Scheduler timing assumptions
+* Reflection internals
 
 These may change without notice.
 
 ---
 
-## Intended Use Cases
+## Reflection Disclaimer
+
+Reflection is used for:
+
+* `ParserInstance` manipulation
+* Condition parsing
+* Log capture
+* Native `TestTracker` forwarding
+
+### Guarantees
+
+* All reflected state is backed up and restored
+* No permanent mutation of Skript internals
+
+### Non-Guarantees
+
+* Binary compatibility across versions
+* Stability under obfuscation
+* Support on modified Skript forks
 
-* Regression testing for Skript libraries
-* Validation of complex event-driven logic
-* Syntax and parser validation
-* Automated sanity checks on server startup
-* Lightweight CI-style verification
+Reflection-backed features are **best-effort** and may degrade gracefully.
 
-This framework is deliberately constrained to ensure reliability and transparency.
diff --git a/scripts/lang/eventspecifiedvariables.sk b/scripts/lang/eventspecifiedvariables.sk
new file mode 100644
index 0000000..f2a9f9d
--- /dev/null
+++ b/scripts/lang/eventspecifiedvariables.sk
@@ -0,0 +1,202 @@
+import:
+    java.util.Map
+    ch.njol.skript.variables.Variables
+    ch.njol.skript.lang.Variable
+    ch.njol.skript.lang.VariableString
+    ch.njol.skript.Skript
+    org.bukkit.event.Event
+    ch.njol.skript.util.StringMode
+
+expression (1:variable %-string%|2:%$-objects%) with custom-event [%-object%]:
+    parse:
+        #if expr-2 is not an instance of Variable:
+        #    Skript.error("Expression 1 must be a variable")
+        #    stop
+
+        #if expr-3 is set:
+        #    expr-3 is not an instance of Event
+        #    Skript.error("Expression 2 must be an event")
+        #    stop
+            
+        # change values does not exist here and we cant specify "set scope"
+        #if size of change values is greater than 1:
+        #    {_isList} is false
+        #    Skript.error("You can't set a single variable to multiple values")
+        #    stop
+        continue
+
+    set:
+        if parse mark is 2:
+            set {_var} to (raw expression of expr-2).getName()
+            set {_isLocal} to (raw expression of expr-2).isLocal()
+            set {_isList} to (raw expression of expr-2).isList()
+        else:
+            set {_isLocal} to true if expr-1 starts with "_" else false
+            set {_name} to expr-1
+            if {_isLocal} is true:
+                set {_name} to {_name}.substring(1) # substring to remove "_"
+            set {_var} to VariableString.newInstance({_name}, StringMode.VARIABLE_NAME)
+            set {_isList} to true if expr-1 ends with "::*" else false
+            
+        set {_event} to event if expr-3 is not set else expr-3
+        set {_name} to {_var}.toUnformattedString({_event})
+        
+        if any:
+            {_isList} is true
+            {_name} ends with "::*" # inner resolution, not how skript behaves but I want it this way
+        then:
+            set {_base} to {_name}.substring(0, {_name}.length() - 3)
+            Variables.setVariable("%{_base}%::*", null, {_event}, {_isLocal})
+            set {_i} to 1
+            loop change values:
+                Variables.setVariable("%{_base}%::%{_i}%", loop-value, {_event}, {_isLocal})
+                add 1 to {_i}
+            stop
+
+        Variables.setVariable({_name}, change value, {_event}, {_isLocal})
+
+    get:
+        if parse mark is 2:
+            set {_var} to (raw expression of expr-2).getName()
+            set {_isLocal} to (raw expression of expr-2).isLocal()
+            set {_isList} to (raw expression of expr-2).isList()
+        else:
+            set {_isLocal} to true if expr-1 starts with "_" else false
+            set {_name} to expr-1
+            if {_isLocal} is true:
+                set {_name} to {_name}.substring(1) # substring to remove "_"
+            set {_var} to VariableString.newInstance({_name}, StringMode.VARIABLE_NAME)
+            set {_isList} to true if expr-1 ends with "::*" else false
+    
+        set {_event} to event if expr-3 is not set else expr-3
+        set {_name} to {_var}.toUnformattedString({_event})
+        set {_value} to Variables.getVariable({_name}, {_event}, {_isLocal})
+
+        if {_value} is instance of Map:
+            set {_base} to {_name}.substring(0, {_name}.length() - 3)
+            loop ...{_value}.entrySet():
+                set {_entry} to loop-value
+                set {_list::%{_entry}.getKey()%} to {_entry}.getValue()
+            return {_list::*}
+
+        # scalar fallback
+        return {_value}
+
+    add:
+        if parse mark is 2:
+            set {_var} to (raw expression of expr-2).getName()
+            set {_isLocal} to (raw expression of expr-2).isLocal()
+            set {_isList} to (raw expression of expr-2).isList()
+        else:
+            set {_isLocal} to true if expr-1 starts with "_" else false
+            set {_name} to expr-1
+            if {_isLocal} is true:
+                set {_name} to {_name}.substring(1) # substring to remove "_"
+            set {_var} to VariableString.newInstance({_name}, StringMode.VARIABLE_NAME)
+            set {_isList} to true if expr-1 ends with "::*" else false
+    
+        set {_event} to event if expr-3 is not set else expr-3
+        set {_name} to {_var}.toUnformattedString({_event})
+        set {_value} to Variables.getVariable({_name}, {_event}, {_isLocal})
+
+        if {_value} is instance of Map:
+            set {_base} to {_name}.substring(0, {_name}.length() - 3)
+            set {_i} to {_value}.size() + 1
+            loop change values:
+                Variables.setVariable("%{_base}%::%{_i}%", loop-value, {_event}, {_isLocal})
+                add 1 to {_i}
+            stop
+
+        # scalar add
+        if {_value} is not set:
+            Variables.setVariable({_name}, change value, {_event}, {_isLocal})
+        else:
+            Variables.setVariable({_name}, {_value} + change value, {_event}, {_isLocal})
+            
+    remove:
+        if parse mark is 2:
+            set {_var} to (raw expression of expr-2).getName()
+            set {_isLocal} to (raw expression of expr-2).isLocal()
+            set {_isList} to (raw expression of expr-2).isList()
+        else:
+            set {_isLocal} to true if expr-1 starts with "_" else false
+            set {_name} to expr-1
+            if {_isLocal} is true:
+                set {_name} to {_name}.substring(1) # substring to remove "_"
+            set {_var} to VariableString.newInstance({_name}, StringMode.VARIABLE_NAME)
+            set {_isList} to true if expr-1 ends with "::*" else false
+    
+        set {_event} to event if expr-3 is not set else expr-3
+        set {_name} to {_var}.toUnformattedString({_event})
+        set {_value} to Variables.getVariable({_name}, {_event}, {_isLocal})
+
+        if {_value} is instance of Map:
+            set {_base} to {_name}.substring(0, {_name}.length() - 3)
+            loop ...{_value}.entrySet():
+                set {_entry} to loop-value
+                if change values contains {_entry}.getValue():
+                    Variables.setVariable("%{_base}%::%{_entry}.getKey()%", null, {_event}, {_isLocal})
+                    stop
+            stop
+
+        # scalar remove = subtract
+        Variables.setVariable({_name}, {_value} - change value, {_event}, {_isLocal})
+
+    remove all:
+        if parse mark is 2:
+            set {_var} to (raw expression of expr-2).getName()
+            set {_isLocal} to (raw expression of expr-2).isLocal()
+            set {_isList} to (raw expression of expr-2).isList()
+        else:
+            set {_isLocal} to true if expr-1 starts with "_" else false
+            set {_name} to expr-1
+            if {_isLocal} is true:
+                set {_name} to {_name}.substring(1) # substring to remove "_"
+            set {_var} to VariableString.newInstance({_name}, StringMode.VARIABLE_NAME)
+            set {_isList} to true if expr-1 ends with "::*" else false
+    
+        set {_event} to event if expr-3 is not set else expr-3
+        set {_name} to {_var}.toUnformattedString({_event})
+        set {_value} to Variables.getVariable({_name}, {_event}, {_isLocal})
+
+        if {_value} is instance of Map:
+            set {_base} to {_name}.substring(0, {_name}.length() - 3)
+            loop ...{_value}.entrySet():
+                set {_entry} to loop-value
+                if change values contains {_entry}.getValue():
+                    Variables.setVariable("%{_base}%::%{_entry}.getKey()%", null, {_event}, {_isLocal})
+            stop
+
+    delete:
+        if parse mark is 2:
+            set {_var} to (raw expression of expr-2).getName()
+            set {_isLocal} to (raw expression of expr-2).isLocal()
+            set {_isList} to (raw expression of expr-2).isList()
+        else:
+            set {_isLocal} to true if expr-1 starts with "_" else false
+            set {_name} to expr-1
+            if {_isLocal} is true:
+                set {_name} to {_name}.substring(1) # substring to remove "_"
+            set {_var} to VariableString.newInstance({_name}, StringMode.VARIABLE_NAME)
+            set {_isList} to true if expr-1 ends with "::*" else false
+    
+        set {_event} to event if expr-3 is not set else expr-3
+        set {_name} to {_var}.toUnformattedString({_event})
+        Variables.setVariable({_name}, null, {_event}, {_isLocal})
+
+    reset:
+        if parse mark is 2:
+            set {_var} to (raw expression of expr-2).getName()
+            set {_isLocal} to (raw expression of expr-2).isLocal()
+            set {_isList} to (raw expression of expr-2).isList()
+        else:
+            set {_isLocal} to true if expr-1 starts with "_" else false
+            set {_name} to expr-1
+            if {_isLocal} is true:
+                set {_name} to {_name}.substring(1) # substring to remove "_"
+            set {_var} to VariableString.newInstance({_name}, StringMode.VARIABLE_NAME)
+            set {_isList} to true if expr-1 ends with "::*" else false
+    
+        set {_event} to event if expr-3 is not set else expr-3
+        set {_name} to {_var}.toUnformattedString({_event})
+        Variables.setVariable({_name}, null, {_event}, {_isLocal})
diff --git a/scripts/lang/repeateffect.sk b/scripts/lang/repeateffect.sk
new file mode 100644
index 0000000..def4dbb
--- /dev/null
+++ b/scripts/lang/repeateffect.sk
@@ -0,0 +1,14 @@
+import:
+    ch.njol.skript.lang.Effect
+
+effect [repeat] <(.+)> (1:once|2:twice|3:thrice|4:%-number% times):
+    parse:
+        set {_a} to first element of regex-1
+        set {_repeat.sk::effect} to Effect.parse({_a}, "Can't understand effect: ")
+        continue
+    trigger:
+        set {_times} to expr-1
+        if parse mark is not 4:
+            set {_times} to parse mark
+        loop {_times} times:
+            {_repeat.sk::effect}.run(event)
diff --git a/scripts/lang/scopedvariable.sk b/scripts/lang/scopedvariable.sk
new file mode 100644
index 0000000..9193bf6
--- /dev/null
+++ b/scripts/lang/scopedvariable.sk
@@ -0,0 +1,141 @@
+import:
+    ch.njol.skript.log.SkriptLogger
+    ch.njol.skript.lang.Variable
+    ch.njol.skript.Skript
+
+effect set default scope for scoped variables in current script to (a:current (x:folder|x:package|y:script)|b:(folder|package) %-string%|c: %-script%):
+    parse:
+        set {_origin} to SkriptLogger.getNode()
+        set {_realscript} to script ({_origin}.getConfig().getFileName())
+        continue
+    trigger:
+        if parse tags contains "a":
+            if parse tags contains "x":
+                set {_scriptsFolder} to Skript.getInstance().getScriptsFolder().toPath().toAbsolutePath()
+                set {_scriptParent} to {_origin}.getConfig().getPath().getParent().toAbsolutePath()
+                set {_relative} to {_scriptsFolder}.relativize({_scriptParent})
+                set {_currentscript} to {_relative}.toString().replace("\\", "/")
+                set {-scoped.sk::default_scope::%{_realscript}%} to {_currentscript}
+            else if parse tags contains "y":
+                set {-scoped.sk::default_scope::%{_realscript}%} to {_realscript}
+        else if parse tags contains "b":
+            set {-scoped.sk::default_scope::%{_realscript}%} to expr-1
+        else if parse tags contains "c":
+            set {-scoped.sk::default_scope::%{_realscript}%} to expr-2
+            
+local function scoped_ctx(origin: object, event: object, var: object, script: object, mark: number) :: strings:
+    # origin + script
+    set {_realscript} to script ({_origin}.getConfig().getFileName())
+
+    # --- scope ---
+    if {_mark} is 0:
+        set {_scope} to {_realscript} if {-scoped.sk::default_scope::%{_realscript}%} is not set else {-scoped.sk::default_scope::%{_realscript}%}
+    else if {_mark} is 1:
+        set {_scope} to {_script}
+    else if {_mark} is 2:
+        set {_scriptsFolder} to Skript.getInstance().getScriptsFolder().toPath().toAbsolutePath()
+        set {_scriptParent} to {_origin}.getConfig().getPath().getParent().toAbsolutePath()
+        set {_relative} to {_scriptsFolder}.relativize({_scriptParent})
+        set {_scope} to {_relative}.toString().replace("\\", "/")
+
+    set {_prefix} to ""
+    set {_suffix} to ""
+    if {_var}.isLocal() is true:
+        set {_prefix} to "_"
+        
+    if {_var}.isEphemeral() is true:
+        set {_prefix} to "-"
+        
+    if {_var}.isList() is true:
+        set {_suffix} to "::*"
+
+    # --- name ---
+    set {_name} to {_var}.getName().toUnformattedString({_event})
+    replace "::*" with "" in {_name}
+    
+    set {_ctx::1prefix} to {_prefix}
+    set {_ctx::2var} to "%{_scope}%::%{_name}%%{_suffix}%"
+    return {_ctx::*}
+
+
+expression scoped [variable] %$objects% [([with]in|from|by) (1:%-script%|2:current (folder|package))]:
+    parse:
+        expr-1 is an instance of Variable
+        set {_var} to expr-1
+        
+        # we use this to capture backing expression's script, could be made cleaner.
+        # we use origin.toString 
+        set {_origin} to SkriptLogger.getNode()
+        continue
+
+    get:
+        set {_ctx::*} to scoped_ctx({_origin}, event, {_var}, expr-2, parse mark)
+
+        # we do this to remove the warning message
+        if {_ctx::1} is "_":
+            return variable "_scoped::%{_ctx::2}%" with custom-event event
+        else if {_ctx::1} is "-":
+            return variable "-scoped::%{_ctx::2}%" with custom-event event
+        else:
+            return variable "scoped::%{_ctx::2}%" with custom-event event
+
+    set:
+        set {_ctx::*} to scoped_ctx({_origin}, event, {_var}, expr-2, parse mark)
+        
+        if {_ctx::1} is "_":
+            set variable "_scoped::%{_ctx::2}%" with custom-event event to change values
+        else if {_ctx::1} is "-":
+            set variable "-scoped::%{_ctx::2}%" with custom-event event to change values
+        else:
+            set variable "scoped::%{_ctx::2}%" with custom-event event to change values
+
+    add:
+        set {_ctx::*} to scoped_ctx({_origin}, event, {_var}, expr-2, parse mark)
+
+        if {_ctx::1} is "_":
+            add change values to variable "_scoped::%{_ctx::2}%" with custom-event event
+        else if {_ctx::1} is "-":
+            add change values to variable "-scoped::%{_ctx::2}%" with custom-event event
+        else:
+            add change values to variable "scoped::%{_ctx::2}%" with custom-event event
+
+    remove:
+        set {_ctx::*} to scoped_ctx({_origin}, event, {_var}, expr-2, parse mark)
+
+        if {_ctx::1} is "_":
+            remove change values from variable "_scoped::%{_ctx::2}%" with custom-event event
+        else if {_ctx::1} is "-":
+            remove change values from variable "-scoped::%{_ctx::2}%" with custom-event event
+        else:
+            remove change values from variable "scoped::%{_ctx::2}%" with custom-event event
+
+    remove all:
+        set {_ctx::*} to scoped_ctx({_origin}, event, {_var}, expr-2, parse mark)
+
+        if {_ctx::1} is "_":
+            remove all change values from variable "_scoped::%{_ctx::2}%" with custom-event event
+        else if {_ctx::1} is "-":
+            remove all change values from variable "-scoped::%{_ctx::2}%" with custom-event event
+        else:
+            remove all change values from variable "scoped::%{_ctx::2}%" with custom-event event
+
+    delete:
+        set {_ctx::*} to scoped_ctx({_origin}, event, {_var}, expr-2, parse mark)
+
+        if {_ctx::1} is "_":
+            delete variable "_scoped::%{_ctx::2}%" with custom-event event
+        else if {_ctx::1} is "-":
+            delete variable "-scoped::%{_ctx::2}%" with custom-event event
+        else:
+            delete variable "scoped::%{_ctx::2}%" with custom-event event
+
+    reset:
+        set {_ctx::*} to scoped_ctx({_origin}, event, {_var}, expr-2, parse mark)
+
+        if {_ctx::1} is "_":
+            delete variable "_scoped::%{_ctx::2}%" with custom-event event
+        else if {_ctx::1} is "-":
+            delete variable "-scoped::%{_ctx::2}%" with custom-event event
+        else:
+            delete variable "scoped::%{_ctx::2}%" with custom-event event
+
diff --git a/scripts/lang/singlelinemulticonditional.sk b/scripts/lang/singlelinemulticonditional.sk
new file mode 100644
index 0000000..0318460
--- /dev/null
+++ b/scripts/lang/singlelinemulticonditional.sk
@@ -0,0 +1,28 @@
+import:
+    ch.njol.skript.lang.Condition
+
+condition <(.+)> (1:&&|2:\|\|) <(.+)>:
+    check:
+        set {_a} to first element of regex-1
+        set {_b} to first element of regex-2
+        set {_message} to "Can't understand this condition: "
+        set {_bool1} to Condition.parse({_a}, "%{_message}%%{_a}%").check(event)
+        set {_bool2} to Condition.parse({_b}, "%{_message}%%{_b}%").check(event)
+        if parse mark is 1:
+            if all:
+                {_bool1} is true
+                {_bool2} is true
+            then:
+                continue
+        else:
+            if any:
+                {_bool1} is true
+                {_bool2} is true
+            then:
+                continue
+                
+expression boolean value of condition <(.+)>:
+    get:
+        set {_b} to first element of regex-1
+        set {_message} to "Can't understand this condition: "
+        return Condition.parse({_b}, "%{_message}%%{_b}%").check(event)
diff --git a/scripts/libs/functionsv2.sk b/scripts/libs/functionsv2.sk
index 3135cdd..5551d1e 100644
--- a/scripts/libs/functionsv2.sk
+++ b/scripts/libs/functionsv2.sk
@@ -8,12 +8,11 @@ import:
     ch.njol.skript.lang.ExpressionList
     ch.njol.skript.lang.Variable
     ch.njol.skript.Skript
-    ch.njol.skript.lang.EffectSection
-    ch.njol.skript.lang.function.EffFunctionCall
-    ch.njol.skript.lang.SkriptParser
+    ch.njol.skript.lang.Effect
     ch.njol.skript.log.SkriptLogger
-    ch.njol.skript.lang.EffectSectionEffect
-    org.skriptlang.skript.registration.SyntaxRegistry
+    ch.njol.skript.config.SectionNode
+    ch.njol.skript.config.Node
+    java.util.ArrayList
 
 local function FextractArgs(vars: object) :: objects:
     if {_vars} is instance of ExpressionList:
@@ -29,71 +28,51 @@ local function isEffect(input:string) :: boolean:
         return false
     return true
 
-local function getFunctionReference(call: object) :: object:
-    set {_class} to {_call}.getClass()
-    set {_field} to {_class}.getDeclaredField("function")
-    {_field}.setAccessible(true)
-    return {_field}.get({_call})
-
 # equals effect.parse 
 local function parseEffectSilent(input: string) :: object:
-    set {_log} to SkriptLogger.startParseLogHandler()
-    set {_func} to EffFunctionCall.parse({_input})
-    if {_func} is set:
-        set {_ref} to getFunctionReference({_func})
-        if {_ref}.getReturnType() is set:
-            {_log}.close()
-            return {_none}
-        {_log}.close()
-        return {_func}
-    set {_section} to EffectSection.parse({_input}, null, null, null)
-    if {_section} is set:
-        {_log}.close()
-        return new EffectSectionEffect({_section})
-    set {_registry} to Skript.instance().syntaxRegistry()
-    set {_iterator} to {_registry}.syntaxes(SyntaxRegistry.EFFECT).iterator()
-    set {_effect} to SkriptParser.parse({_input}, {_iterator}, null)
+    set {_log} to SkriptLogger.startRetainingLog()
+    set {_effect} to Effect.parse({_input}, null)
     {_log}.clear()
     {_log}.close()
     return {_effect}
-    
-expression build lambda args %objects% body %string% noreturn %boolean% script %script%:
+
+expression build lambda args %objects% body %strings% noreturn %boolean% script %script%:
     get:
         set {_functionsv2.sk::ctx::args::*} to expr-1
-        set {_functionsv2.sk::ctx::body} to expr-2
+        set {_functionsv2.sk::ctx::body::*} to expr-2
         set {_functionsv2.sk::ctx::noreturn} to expr-3
         set {_functionsv2.sk::ctx::script} to expr-4
         set {_functionsv2.sk::ctx::arity} to size of {_functionsv2.sk::ctx::args::*}
         if {_functionsv2.sk::ctx::noreturn} is true:
             if {_functionsv2.sk::ctx::arity} is 0:
-                set {_functionsv2.sk::ctx::functions::run} to line section {_functionsv2.sk::ctx::body} with args {_this}
+                set {_functionsv2.sk::ctx::functions::run} to line section {_functionsv2.sk::ctx::body::*} with args {_this}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of Runnable using {_functionsv2.sk::ctx::functions::*}
             else if {_functionsv2.sk::ctx::arity} is 1:
                 set {_functionsv2.sk::ctx::proxy} to raw expression of {_this}
-                set {_functionsv2.sk::ctx::functions::accept} to line section {_functionsv2.sk::ctx::body} with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%" in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::accept} to line section {_functionsv2.sk::ctx::body::*} with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%" in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of Consumer using {_functionsv2.sk::ctx::functions::*}
             else:
                 set {_functionsv2.sk::ctx::proxy} to raw expression of {_this}
-                set {_functionsv2.sk::ctx::functions::accept} to line section {_functionsv2.sk::ctx::body} with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%", "%{_functionsv2.sk::ctx::args::2}%" in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::accept} to line section {_functionsv2.sk::ctx::body::*} with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%", "%{_functionsv2.sk::ctx::args::2}%" in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of BiConsumer using {_functionsv2.sk::ctx::functions::*}
         else:
-
+            set {_functionsv2.sk::ctx::realbody::*} to "return %{_functionsv2.sk::ctx::body::*}%" if size of {_functionsv2.sk::ctx::body::*} is 1 else {_functionsv2.sk::ctx::body::*}
             if {_functionsv2.sk::ctx::arity} is 0:
-                set {_functionsv2.sk::ctx::functions::get} to line section "return %{_functionsv2.sk::ctx::body}%" with args {_this} in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::get} to line section {_functionsv2.sk::ctx::realbody::*} with args {_this} in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of Supplier using {_functionsv2.sk::ctx::functions::*}
             else if {_functionsv2.sk::ctx::arity} is 1:
                 set {_functionsv2.sk::ctx::proxy} to raw expression of {_this}
-                set {_functionsv2.sk::ctx::functions::apply} to line section "return %{_functionsv2.sk::ctx::body}%" with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%" in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::apply} to line section {_functionsv2.sk::ctx::realbody::*} with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%" in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of Function using {_functionsv2.sk::ctx::functions::*}
             else:
                 set {_functionsv2.sk::ctx::proxy} to raw expression of {_this}
-                set {_functionsv2.sk::ctx::functions::apply} to line section "return %{_functionsv2.sk::ctx::body}%" with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%", "%{_functionsv2.sk::ctx::args::2}%" in {_functionsv2.sk::ctx::script}
+                set {_functionsv2.sk::ctx::functions::apply} to line section {_functionsv2.sk::ctx::realbody::*} with args "%{_functionsv2.sk::ctx::proxy}%", "%{_functionsv2.sk::ctx::args::1}%", "%{_functionsv2.sk::ctx::args::2}%" in {_functionsv2.sk::ctx::script}
                 set {_functionsv2.sk::ctx::proxy} to new proxy instance of BiFunction using {_functionsv2.sk::ctx::functions::*}
         return {_functionsv2.sk::ctx::proxy}
 
 expression:
     patterns:
-        lambda[ %-objects%]\:(1: |2:- |3:+ )<(.+)>
+        [new] lambda[ %-objects%]\:(1: |2:- |3:+ )<(.+)>
     parse:
         set {_functionsv2.sk::ctx::vars} to expr-1
         set {_functionsv2.sk::ctx::expr} to first element of regex-1
@@ -111,8 +90,8 @@ expression:
         
 expression:
     patterns:
-        (1:supplier|1:getter|2:runnable|2:runner)[ %-objects%]\: <(.+)>
-        (3:consumer|3:accepter|4:function|4:applier|5:biconsumer|5:biaccepter|6:bifunction|6:biapplier) %-objects%\: <(.+)>
+        [new] (1:supplier|1:getter|2:runnable|2:runner)[ %-objects%]\: <(.+)>
+        [new] (3:consumer|3:accepter|4:function|4:applier|5:biconsumer|5:biaccepter|6:bifunction|6:biapplier) %-objects%\: <(.+)>
     parse:
         set {_functionsv2.sk::ctx::vars} to expr-1
         set {_functionsv2.sk::ctx::expr} to first element of regex-1
@@ -150,18 +129,131 @@ expression:
     get:
         return build lambda args {_functionsv2.sk::ctx::args::*} body {_functionsv2.sk::ctx::expr} noreturn {_functionsv2.sk::ctx::noreturn} script {_functionsv2.sk::ctx::script}
 
+local function walk(n: object, list: object) :: objects:
+    if {_list} is not set:
+        set {_list} to new ArrayList()
+    loop ...{_n}:
+        {_list}.add(loop-value)
+        if loop-value is instance of SectionNode:
+            walk(loop-value, {_list})
+    return ...{_list}
+
+condition set %object% to [new] lambda[ %-objects%](1:|2:-|3:+):
+    parse:
+        set {_functionsv2.sk::ctx::origin} to SkriptLogger.getNode()
+        set {_functionsv2.sk::ctx::script} to script ({_functionsv2.sk::ctx::origin}.getConfig().getFileName())
+        if {_functionsv2.sk::ctx::script} is not set: # likely inner lambda
+            set {_functionsv2.sk::ctx::script} to current script
+        set {_functionsv2.sk::ctx::vars} to expr-2
+        set {_functionsv2.sk::ctx::originindent} to {_functionsv2.sk::ctx::origin}.[Node]getIndentation()
+        set {_functionsv2.sk::ctx::nodes::*} to walk({_functionsv2.sk::ctx::origin}, {_none})
+        loop {_functionsv2.sk::ctx::nodes::*}:
+            set {_functionsv2.sk::ctx::indent} to loop-value.[Node]getIndentation().substring(length of {_functionsv2.sk::ctx::originindent} + 4) if {_functionsv2.sk::ctx::originindent} starts with " " else loop-value.[Node]getIndentation().substring(length of {_functionsv2.sk::ctx::originindent} + 1) 
+            set {_functionsv2.sk::ctx::key} to "%{_functionsv2.sk::ctx::indent}%%loop-value.getKey()%"
+            set {_functionsv2.sk::ctx::key} to "%{_functionsv2.sk::ctx::key}%:" if loop-value is instance of SectionNode
+            add {_functionsv2.sk::ctx::key} to {_functionsv2.sk::ctx::expr::*} 
+            {_functionsv2.sk::ctx::key}.trim() starts with "return"
+            set {_functionsv2.sk::ctx::noreturn} to false if parse mark is 1
+                
+        set {_functionsv2.sk::ctx::noreturn} to true if parse mark is 2
+        set {_functionsv2.sk::ctx::noreturn} to false if parse mark is 3
+        set {_functionsv2.sk::ctx::args::*} to FextractArgs({_functionsv2.sk::ctx::vars})
+        continue
+    check:
+        set raw expression of expr-1 to build lambda args {_functionsv2.sk::ctx::args::*} body {_functionsv2.sk::ctx::expr::*} noreturn {_functionsv2.sk::ctx::noreturn} script {_functionsv2.sk::ctx::script}
+
+condition set %object% to [new] (1:supplier|1:getter|2:runnable|2:runner|3:consumer|3:accepter|4:function|4:applier|5:biconsumer|5:biaccepter|6:bifunction|6:biapplier)[ %-objects%]:
+    parse:
+        set {_functionsv2.sk::ctx::origin} to SkriptLogger.getNode()
+        set {_functionsv2.sk::ctx::script} to script ({_functionsv2.sk::ctx::origin}.getConfig().getFileName())
+        if {_functionsv2.sk::ctx::script} is not set:
+            set {_functionsv2.sk::ctx::script} to current script
+
+        set {_functionsv2.sk::ctx::vars} to expr-2
+        set {_functionsv2.sk::ctx::originindent} to {_functionsv2.sk::ctx::origin}.[Node]getIndentation()
+        set {_functionsv2.sk::ctx::nodes::*} to walk({_functionsv2.sk::ctx::origin}, {_none})
+
+        loop {_functionsv2.sk::ctx::nodes::*}:
+            set {_functionsv2.sk::ctx::indent} to loop-value.[Node]getIndentation().substring(length of {_functionsv2.sk::ctx::originindent} + 4) if {_functionsv2.sk::ctx::originindent} starts with " " else loop-value.[Node]getIndentation().substring(length of {_functionsv2.sk::ctx::originindent} + 1) 
+            set {_functionsv2.sk::ctx::key} to "%{_functionsv2.sk::ctx::indent}%%loop-value.getKey()%"
+            set {_functionsv2.sk::ctx::key} to "%{_functionsv2.sk::ctx::key}%:" if loop-value is instance of SectionNode
+            add {_functionsv2.sk::ctx::key} to {_functionsv2.sk::ctx::expr::*} 
+
+        set {_functionsv2.sk::ctx::args::*} to FextractArgs({_functionsv2.sk::ctx::vars})
+
+        set {_functionsv2.sk::ctx::noreturn} to true
+        if any:
+            parse mark is 1
+            parse mark is 4
+            parse mark is 6
+        then:
+            set {_functionsv2.sk::ctx::noreturn} to false
+        set {_functionsv2.sk::ctx::args::*} to FextractArgs({_functionsv2.sk::ctx::vars})
+        if any:
+            parse mark is 1
+            parse mark is 2
+        then:
+            if size of {_functionsv2.sk::ctx::args::*} > 0:
+                stop
+        if any:
+            parse mark is 3
+            parse mark is 4
+        then:
+            if size of {_functionsv2.sk::ctx::args::*} is 0:
+                stop
+        if any:
+            parse mark is 5
+            parse mark is 6
+        then:
+            if size of {_functionsv2.sk::ctx::args::*} is not 2:
+                stop
+
+        continue
+
+    check:
+        set raw expression of expr-1 to build lambda args {_functionsv2.sk::ctx::args::*} body {_functionsv2.sk::ctx::expr::*} noreturn {_functionsv2.sk::ctx::noreturn} script {_functionsv2.sk::ctx::script}
+
 expression run[ lambda] %object%[ with %-objects%]:
     get:
         set {_functionsv2.sk::ctx::args::*} to expr-2
         expr-1 is instance of Runnable:
             expr-1.run()
+            return {_none}
         else if expr-1 is instance of Consumer:
             expr-1.accept(expr-2)
+            return {_none}
         else if expr-1 is instance of BiConsumer:
             expr-1.accept({_functionsv2.sk::ctx::args::1}, {_functionsv2.sk::ctx::args::2})
+            return {_none}
         else if expr-1 is instance of Function:
             return expr-1.apply(expr-2)
         else if expr-1 is instance of BiFunction:
             return expr-1.apply({_functionsv2.sk::ctx::args::1}, {_functionsv2.sk::ctx::args::2})
         else if expr-1 is instance of Supplier:
             return expr-1.get()
+            
+effect run[ lambda] %object%[ with %-objects%]:
+    trigger:
+        set {_args::*} to expr-2
+        if expr-1 is instance of Runnable:
+            expr-1.run()
+        else if expr-1 is instance of Consumer:
+            expr-1.accept({_args::*})
+        else if expr-1 is instance of BiConsumer:
+            expr-1.accept({_args::1}, {_args::2})
+        else if expr-1 is instance of Function:
+            expr-1.apply({_args::*})
+        else if expr-1 is instance of BiFunction:
+            expr-1.apply({_args::1}, {_args::2})
+        else if expr-1 is instance of Supplier:
+            expr-1.get()
+
+effect return %object%:
+    parse:
+        set {_functionsv2.sk::ctx::node} to SkriptLogger.getNode()
+        if "%{_functionsv2.sk::ctx::node}%" contains "lambda." or "supplier." or "applier." or "getter." or "function" or "bifunction" or "biapplier":
+            continue
+    trigger:
+        broadcast "shouldn't ever run"
+
+
diff --git a/scripts/libs/singlelinesection.sk b/scripts/libs/parser/singlelinesection.sk
similarity index 100%
rename from scripts/libs/singlelinesection.sk
rename to scripts/libs/parser/singlelinesection.sk
diff --git a/scripts/libs/pdc.sk b/scripts/libs/pdc.sk
index 64939f2..b101372 100644
--- a/scripts/libs/pdc.sk
+++ b/scripts/libs/pdc.sk
@@ -8,6 +8,18 @@ import:
     org.bukkit.util.io.BukkitObjectInputStream
     org.bukkit.util.io.BukkitObjectOutputStream
     ch.njol.skript.lang.Variable
+    java.lang.Byte
+    java.lang.Short
+    java.lang.Integer
+    java.lang.Long
+    java.lang.Float
+    java.lang.Double
+    java.lang.Boolean
+    
+on load:
+    set scoped {-primitives::pdt::*} to PersistentDataType.BOOLEAN, PersistentDataType.BYTE, PersistentDataType.SHORT, PersistentDataType.INTEGER, PersistentDataType.LONG, PersistentDataType.FLOAT, PersistentDataType.DOUBLE, PersistentDataType.STRING, PersistentDataType.TAG_CONTAINER
+    set scoped {-primitives::str::*} to "bool", "byte", "short", "int", "long", "float", "double", "str", "pdc"
+    set scoped {-primitives::int::*} to 8, 6, 7, 2, 3, 4, 5, 1, 9
 
 local function validate_pdcexpr(key: object, pdc: object, pdt: object) :: boolean:
     if all:
@@ -22,53 +34,97 @@ local function validate_pdcexpr(key: object, pdc: object, pdt: object) :: boolea
         return false
     return true
 
-# e.g. key "plugin:test" in player's pdc for type byte 
-expression [devdinc] %object% [with]in %object%[ for %-object%]: 
+
+local function coerce_pdt_value(pdt: object, value: object) :: object:
+    if {_value} is not set:
+        return {_none}
+
+    if {_pdt} is PersistentDataType.INTEGER:
+        return try new Integer({_value}) if {_value} is an integer
+
+    else if {_pdt} is PersistentDataType.BYTE:
+        return try new Byte({_value}) if {_value} is an integer
+
+    else if {_pdt} is PersistentDataType.SHORT:
+        return try new Short({_value}) if {_value} is an integer
+
+    else if {_pdt} is PersistentDataType.LONG:
+        return try new Long({_value}) if {_value} is an integer
+
+    else if {_pdt} is PersistentDataType.FLOAT:
+        return try new Float({_value})
+
+    else if {_pdt} is PersistentDataType.DOUBLE:
+        return try new Double({_value})
+
+    else if {_pdt} is PersistentDataType.STRING:
+        return {_value} if {_value} is a text
+
+    else if {_pdt} is PersistentDataType.BOOLEAN:
+        return {_value} if {_value} is a boolean
+        
+    else if {_pdt} is PersistentDataType.TAG_CONTAINER:
+        return {_value} if {_value} is an instance of PersistentDataContainer
+
+    else if {_pdt} is PersistentDataType.BYTE_ARRAY:
+        return {_value}
+
+    return {_none}
+
+
+expression [devdinc] [namespaced]( |-)key %string% [with]in %object%[ for %-object%]:
     parse:
-        set {_key} to expr-1
         set {_pdt} to expr-3
-            
+        
         if any:
-            "%{_key}%" is "[devdinc] [namespaced]( |-)key %%string%%"
-            {_key} is instance of Variable
+            "%{_pdt}%" contains "[devdinc] (pdt|[persistent data ]type)"
+            "%{_pdt}%" contains "PersistentDataType"
+            {_pdt} is instance of Variable
+            {_pdt} is not set
         then:
-            if any:
-                "%{_pdt}%" contains "[devdinc] (pdt|[persistent data ]type)"
-                "%{_pdt}%" contains "PersistentDataType"
-                {_pdt} is instance of Variable
-                {_pdt} is not set
-            then:
-                continue
-        stop
+            continue
 
     get:
-        set {_key} to expr-1
+        set {_key} to NamespacedKey.fromString(expr-1, null) 
         set {_pdc} to expr-2.getPersistentDataContainer() if expr-2 is instance of PersistentDataHolder else expr-2
         set {_pdt} to expr-3
-        
+
         stop if validate_pdcexpr({_key}, {_pdc}, {_pdt}) is false
-            
+
         if {_pdt} is not set:
-            if {_pdc}.has({_key}, PersistentDataType.BYTE_ARRAY) is false:
-                return {_none}
-
-            set {_bytes} to {_pdc}.get({_key}, PersistentDataType.BYTE_ARRAY)
-            set {_in} to new BukkitObjectInputStream(new ByteArrayInputStream({_bytes}))
-            set {_obj} to {_in}.readObject()
-            {_in}.close()
-            return {_obj}
+            set {_typeKey} to NamespacedKey.fromString("%{_key}%..type", null) 
+
+            if {_pdc}.has({_typeKey}, PersistentDataType.STRING):
+                set {_typeId} to {_pdc}.get({_typeKey}, PersistentDataType.STRING)
+                
+                set {_i} to 1
+                loop scoped {-primitives::str::*}:
+                    if {_typeId} is loop-value:
+                        set {_pdt} to {_i}th element of scoped {-primitives::pdt::*}
+                        return try {_pdc}.get({_key}, {_pdt}) # try is used for if the key does not exist
+                    add 1 to {_i}
+
+            else:
+                if {_pdc}.has({_key}, PersistentDataType.BYTE_ARRAY) is false:
+                    return {_none}
+
+                set {_bytes} to {_pdc}.get({_key}, PersistentDataType.BYTE_ARRAY)
+                set {_in} to new BukkitObjectInputStream(new ByteArrayInputStream({_bytes}))
+                set {_obj} to {_in}.readObject()
+                {_in}.close()
+                return {_obj}
         else:
             return {_pdc}.get({_key}, {_pdt})
 
     set:
-        set {_key} to expr-1
+        set {_key} to NamespacedKey.fromString(expr-1, null) 
         set {_pdc} to expr-2.getPersistentDataContainer() if expr-2 is instance of PersistentDataHolder else expr-2
         set {_pdt} to expr-3
-        
+
         stop if validate_pdcexpr({_key}, {_pdc}, {_pdt}) is false
-        
+
         set {_value} to change value
-        
+
         if any:
             {_value} is null
             {_value} is not set
@@ -77,62 +133,78 @@ expression [devdinc] %object% [with]in %object%[ for %-object%]:
             stop
 
         if {_pdt} is not set:
+            set {_typeKey} to NamespacedKey.fromString("%{_key}%..type", null) 
+            
+            set {_i} to 1
+            loop scoped {-primitives::pdt::*}:
+                set {_try} to coerce_pdt_value(loop-value, {_value})
+
+                if {_try} is set:
+                    {_pdc}.set({_key}, loop-value, {_try})
+                    {_pdc}.set({_typeKey}, PersistentDataType.STRING, {_i}th element of scoped {-primitives::str::*})
+
+                    stop
+                
+                add 1 to {_i}
+
             set {_baos} to new ByteArrayOutputStream()
             set {_out} to new BukkitObjectOutputStream({_baos})
             {_out}.writeObject({_value})
             {_out}.close()
-            
+
             set {_boxedBytes::*} to ...{_baos}.toByteArray()
             set {_bytes} to new byte[size of {_boxedBytes::*}]
             loop {_boxedBytes::*}:
                 set {_bytes}[loop-index parsed as number - 1] to loop-value
-                
+
             {_pdc}.set({_key}, PersistentDataType.BYTE_ARRAY, {_bytes})
 
         else:
-            {_pdc}.set({_key}, {_pdt}, {_value})
+            set {_coerced} to coerce_pdt_value({_pdt}, {_value})
+            {_pdc}.set({_key}, {_pdt}, {_coerced})
+
 
     delete:
-        set {_key} to expr-1
+        set {_key} to NamespacedKey.fromString(expr-1, null) 
         set {_pdc} to expr-2.getPersistentDataContainer() if expr-2 is instance of PersistentDataHolder else expr-2
         set {_pdt} to expr-3
-        
+
         stop if validate_pdcexpr({_key}, {_pdc}, {_pdt}) is false
-        
+
+        set {_typeKey} to NamespacedKey.fromString("%{_key}%..type", null) 
+        {_pdc}.remove({_typeKey})
         {_pdc}.remove({_key})
 
-expression [devdinc] [namespaced]( |-)key %string%:
+
+object property p[ersistent ]d[ata ]c[ontainer]:
     parse:
         continue
     get:
-        return NamespacedKey.fromString(expr-1, null)
-        
-object property p[ersistent ]d[ata ]c[ontainer]:
+        return expr-1.getPersistentDataContainer()
+
+
+expression [devdinc] new p[ersistent ]d[ata ]c[ontainer] from %object%:
     parse:
         continue
     get:
-        return expr-1.getPersistentDataContainer()
+        set {_src} to expr-1
+
+        if {_src} is instance of PersistentDataHolder:
+            set {_ctx} to {_src}.getPersistentDataContainer().getAdapterContext()
+            return {_ctx}.newPersistentDataContainer()
+
+        if {_src} is instance of PersistentDataContainer:
+            set {_ctx} to {_src}.getAdapterContext()
+            return {_ctx}.newPersistentDataContainer()
 
-expression [devdinc] (pdt|[persistent data ]type) (1:str[ing]|2:int[eger]|3:long|4:float|5:double|6:byte|7:short|8:bool[ean]):
+        return {_none}
+
+
+expression [devdinc] (pdt|[persistent data ]type) [of] (1:str[ing]|2:int[eger]|3:long|4:float|5:double|6:byte|7:short|8:bool[ean]|9:container):
     parse:
         continue
     get:
-        if parse mark is 1:
-            return PersistentDataType.STRING
-        else if parse mark is 2:
-            return PersistentDataType.INTEGER
-        else if parse mark is 3:
-            return PersistentDataType.LONG
-        else if parse mark is 4:
-            return PersistentDataType.FLOAT
-        else if parse mark is 5:
-            return PersistentDataType.DOUBLE
-        else if parse mark is 6:
-            return PersistentDataType.BYTE
-        else if parse mark is 7:
-            return PersistentDataType.SHORT
-        else if parse mark is 8:
-            return PersistentDataType.BOOLEAN
-        else:
-            return {_none}
+        set {_l::*} to scoped {-primitives::int::*}
+        set {_i} to {_l::%parse mark%}
+        return {_i}th element of scoped {-primitives::pdt::*}
 
diff --git a/scripts/utils/testframework.sk b/scripts/utils/testframework.sk
index 4e80bcc..14d121a 100644
--- a/scripts/utils/testframework.sk
+++ b/scripts/utils/testframework.sk
@@ -5,8 +5,11 @@ import:
     org.bukkit.Bukkit
     ch.njol.skript.test.utils.TestOfflinePlayer
     ch.njol.skript.lang.Condition
+    ch.njol.skript.test.runner.TestTracker
+    ch.njol.skript.log.SkriptLogger
+    java.lang.Runnable
 
-local effect testFail %string%[, %-string%]:
+local effect sendTestFailMessage %string%[, %-string%]:
     trigger:
         set {_msg} to " %expr-2%" if expr-2 is set else ""
         send "[<gold>Skript<reset>] [&cTEST FAILURE<reset>] %expr-1%%{_msg}%" to console
@@ -14,9 +17,23 @@ local effect testFail %string%[, %-string%]:
 event "skriptTest":
     pattern: [devdinc] test %string% [when <(.+)>]
     event-values: string, boolean
+    parse:
+        set {_origin} to SkriptLogger.getNode()
+        set {_realscript} to script ({_origin}.getConfig().getFileName())
+        # we don't have access to event-string or expr-1, so we can't do it in parse time.
+        # one thing we can do is cause a call to event to register tho.
+        set {_list::string} to "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
+        set {_list::boolean} to false
+        create section with {_proxy} stored in {_functions::run}:
+            wait 2 ticks
+            call custom event "skriptTest" with {_list::*}
+        set {_proxy} to new proxy instance of Runnable using {_functions::*}
+        Bukkit.getGlobalRegionScheduler().execute(instance of plugin "Skript", {_proxy})
+        continue
     check:
+        set {_realscript} to current script if {_realscript} is not set # before skript-reflect 2.6.4, parse section in events within same script doesn't run
         set {_ok} to true
-        set {-test.sk::tests::%expr-1%} to "%expr-1%"
+        set {-test.sk::tests::%{_realscript}%.%expr-1%} to ["%expr-1%", {_realscript}] # registering
         if "%expr-1%" is event-string:
             set {_raw} to first element of regex-1
             if {_raw} is set:
@@ -25,51 +42,126 @@ event "skriptTest":
             if {_cond} is set:
                 set {_ok} to {_cond}.check(event)
             continue if {_ok} is true
+            
+event "beforeSkriptTest":
+    pattern: [devdinc] before each test
+    event-values: string, boolean, script
+    check:
+        continue
+        
+event "afterSkriptTest":
+    pattern: [devdinc] after each test
+    event-values: string, boolean, script
+    check:
+        continue
+        
+event "beforeSkriptTestAll":
+    pattern: [devdinc] before all tests
+    event-values: script
+    check:
+        continue
+        
+event "afterSkriptTestAll":
+    pattern: [devdinc] after all tests
+    event-values: script
+    check:
+        continue
+
+plural expression [all] tests [[with] [test] [name] %-string%] [[with][in] %-script%]:
+    parse:
+        set {_scoped} to false if expr-2 is not set
+        continue
 
-plural expression all tests [with test name %-string%]:
-    return type: strings
     get:
-        loop {-test.sk::tests::*}:
-            if any:
-                expr-1 is not set
-                loop-value is expr-1
-            then:
-                add "%loop-value%" to {_r::*}
+        if {_scoped} is false:
+            loop {-test.sk::tests::*}:
+                if any:
+                    expr-1 is not set
+                    loop-value[0] is expr-1
+                then:
+                    add loop-value to {_r::*}
+        else:
+            loop {-test.sk::tests::*}:
+                loop-value[1] is expr-2
+                if any:
+                    expr-1 is not set
+                    loop-value[0] is expr-1
+                then:
+                    add loop-value to {_r::*}
 
         return {_r::*}
         
-effect (1:|2:auto)run [test][s] %strings%:
+effect (1:|2:auto)run %objects%:
     trigger:
         set {_tests::*} to expr-1
         set {_alltests::*} to all tests
         loop {_tests::*}:
-            delete {-test.sk::errors::%loop-value%::*} 
-            set {_list::string} to loop-value
+            set {_list::script} to loop-value[1]
+            {_scripts::*} does not contain {_list::script}
+            add {_list::script} to {_scripts::*}
+            call custom event "beforeSkriptTestAll" with {_list::*}
+        loop {_tests::*}:
+            set {_list::string} to loop-value[0]
+            set {_list::script} to loop-value[1]
             set {_list::boolean} to true if parse mark is 2 else false
+            call custom event "beforeSkriptTest" with {_list::*}
             call custom event "skriptTest" with {_list::*}
+            call custom event "afterSkriptTest" with {_list::*}
             if any:
-                loop-value contains "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
-                {_alltests::*} does not contain loop-value
+                {_list::string} contains "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
+                size of ({_alltests::*} where ["%input%" is "%loop-value%"]) is 0
             then:
                 add 1 to {_forgottenTestResults}
                 continue loop
-            add 1 to {_testFails} if size of {-test.sk::errors::%loop-value%::*} is greater than 0
+            add 1 to {_testFails} if size of {-test.sk::errors::%{_list::script}%.%{_list::string}%::*} is greater than 0
+        loop {_scripts::*}:
+            set {_list::script} to loop-value
+            call custom event "afterSkriptTestAll" with {_list::*}
         set {_validTestAmount} to size of {_tests::*} - {_forgottenTestResults}
         if {_validTestAmount} is not 0:
             send "[<gold>Skript<reset>] <yellow>%{_validTestAmount} - {_testFails}%/%{_validTestAmount}% tests passed." to console
         else if size of {_alltests::*} is greater than 0: # skipping if there is no initial hidden test 
             send "[<gold>Skript<reset>] <yellow>No tests found." to console
 
+condition last test result [of %-object%] is a (1:pass|2:fail):
+    usable in:
+        custom event "skriptTest"
+    check:
+        if expr-1 is not set:
+            set {_test} to event.getEventValue("string")
+            set {_script} to event.getEventValue("script")
+        else:
+            set {_test} to expr-1[0]
+            set {_script} to expr-1[1]
+            stop if size of (all tests where ["%input%" is "%expr-1%"]) is 0
+        if all:
+            parse mark is 1
+            size of {-test.sk::errors::%{_script}%.%{_test}%::*} <= 0
+        then:
+            continue
+        else:
+            if all:
+                parse mark is 2
+                size of {-test.sk::errors::%{_script}%.%{_test}%::*} > 0
+            then:
+                continue
+
+before each test:
+    delete {-test.sk::errors::%event-script%.%event-string%::*} 
+    set {-test.sk::testblock} to test-block's type
+    
+after each test:
+    set test-block to {-test.sk::testblock}
+
 on load:
     delete {-test.sk::*}
-    set {_block} to test-block's type
     wait 1 tick
-    run test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
+    set {_list::string} to "f39f0f4a-31ee-4b71-87e9-38ddba3a2313"
+    set {_list::boolean} to false
+    call custom event "skriptTest" with {_list::*}
     wait 1 tick
     set {_tests::*} to all tests
     autorun {_tests::*}
-    set test-block to {_block}
-    broadcast "<red>Test block is permanent!" if test-block is not {_block}
 
 effect:
     patterns:
@@ -79,12 +171,14 @@ effect:
         custom event "skriptTest"
     parse:
         set {_raw} to first element of regex-1
+        set {_origin} to SkriptLogger.getNode()
+        set {_currentscript} to script ({_origin}.getConfig().getFileName())
         
         set {_parser} to ParserInstance.get()
         set {_parser}.[ParserInstance]isActive to true
         set {_backup} to {_parser}.backup()  
         
-        {_parser}.setCurrentScript(current script)
+        {_parser}.setCurrentScript({_currentscript})
         {_parser}.setCurrentEvent("assert condition", (custom event "skriptTest").getClass())
         
         set {_cond} to Condition.parse({_raw}, "Can't understand condition: " + {_raw})
@@ -97,6 +191,7 @@ effect:
         
         set {_label} to "assert true" if parse tags contains "1" else "assert false"
         set {_test} to event.getEventValue("string")
+        set {_script} to event.getEventValue("script")
         if all:
             parse tags contains "1"
             {_ok} is false
@@ -114,8 +209,9 @@ effect:
             {_bool2} is true
         then:
             if parse tags does not contain "5":
-                testFail "Test ""%{_test}%"" with condition '%{_label}%: %{_raw}%' failed", expr-1
-            add "%expr-1%" to {-test.sk::errors::%{_test}%::*}
+                sendTestFailMessage "Test ""%{_test}%"" with condition '%{_label}%: %{_raw}%' failed", expr-1
+            TestTracker.testFailed(expr-1)
+            add "%expr-1%" to {-test.sk::errors::%{_script}%.%{_test}%::*}
             if parse tags contains "3":
                 delay effect
 
@@ -124,9 +220,11 @@ effect (3:|4:(no|without) (halt[ing]|fail[(-| )](safe|fast)|abort[ing])) fail te
         custom event "skriptTest"
     trigger:
         set {_test} to event.getEventValue("string")
+        set {_script} to event.getEventValue("script")
         if parse tags does not contain "5":
-            testFail "Test ""%{_test}%"" failed", expr-1
-        add "%expr-1%" to {-test.sk::errors::%{_test}%::*}
+            sendTestFailMessage "Test ""%{_test}%"" failed", expr-1
+        TestTracker.testFailed(expr-1)
+        add "%expr-1%" to {-test.sk::errors::%{_script}%.%{_test}%::*}
         if parse tags contains "3":
             delay effect
         
@@ -138,14 +236,13 @@ effect stop auto [test] execution [here]:
         if {_bool} is true:
             delay effect
             
-expression [event(-| )]test:
-    return type: string
+expression event(-| )test:
 #    usable in:
 #        custom event "skriptTest"
     get:
-        return event.getEventValue("string")
+        return [event.getEventValue("string"), event.getEventValue("script")]
         
-condition %string% (1:is|2:is not|2:isn't) autorun:
+condition event(-| )test (1:is|2:is not|2:isn't) autorun:
     # usable in:
     #    custom event "skriptTest"
     check:
@@ -157,11 +254,8 @@ condition %string% (1:is|2:is not|2:isn't) autorun:
             parse mark is 2
             continue
             
-### this section is experimental.
-
 import:
     ch.njol.skript.ScriptLoader
-    ch.njol.skript.log.SkriptLogger
             
 condition parse:
     parse:
@@ -193,24 +287,31 @@ plural expression last parse logs:
     get:
         return {-test.sk::latestLogs::*}
 
-# ----
-
-plural expression test errors[ for [test[s]] %-strings%]:
+plural expression test errors[ for %-objects%]:
     return type: strings
     get:
         if expr-1 is not set:
             set {_test} to event.getEventValue("string")
-            return {-test.sk::errors::%{_test}%::*}
+            set {_script} to event.getEventValue("script")
+            return {-test.sk::errors::%{_script}%.%{_test}%::*}
         else:
             loop ...expr-1:
-                set {_test} to loop-value
-                add {-test.sk::errors::%{_test}%::*} to {_r::*}
+                set {_test} to loop-value[0]
+                set {_script} to loop-value[1]
+                add {-test.sk::errors::%{_script}%.%{_test}%::*} to {_r::*}
             return {_r::*}
 
 expression [the] test(-| )world:
     return type: world
     get:
-        return Bukkit.getWorlds().get(0)
+        set {_world} to Bukkit.getWorld("skripttest")
+        if any:
+            {_world} is not set
+            {_world} is null
+        then:
+            return Bukkit.getWorlds().get(0)
+        else:
+            return {_world}
 
 expression [the] test(-| )location:
     return type: location
@@ -272,21 +373,25 @@ devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 fail test halts by default":
     broadcast "<red>ERROR: fail test did not halt"
 
 devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 autorun flag is true":
+    if event-test is not autorun:
+        stop
     assert true: event-test is autorun
 
 devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 manual run flag is false" when {_none} is set:
     fail test
     
 devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 manual run flag" when event-test is not autorun:
-    fail test
+    fail test if event-test is autorun
 
 devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 stop auto execution works":
+    if event-test is not autorun:
+        stop
     stop auto test execution here
     broadcast "<red>ERROR: auto execution not stopped"
 
 devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests returns this test":
-    set {_all::*} to all tests
-    assert true: {_all::*} contains "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests returns this test"
+    set {_all::*} to all tests with test name "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests returns this test"
+    assert true: size of {_all::*} > 0
 
 devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 all tests":
     set {_all::*} to all tests
@@ -300,19 +405,30 @@ devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 errors do not leak between te
     assert true: size of test errors is 0
 
 devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 event-test returns correct name":
-    assert true: event-test is event-string
+    assert true: event-test[0] is event-string
     
-devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 test-block is temporary":
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 test-block is temporary A":
+    set {-test.sk::temptestblocka} to test-block's type
     test block is chest:
         set test-block to trapped chest
     else if test block is trapped chest:
         set test-block to chest
     else:
         set test-block to ender chest
-        
-    # test is continued at on load end
+    set {-test.sk::temptestblockb} to test-block's type
+    
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 test-block is temporary B":
+    assert true: {-test.sk::temptestblocka} is test-block's type
+    assert true: {-test.sk::temptestblocka} is not {-test.sk::temptestblockb}
     
 devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 parse section":
     parse:
         no errors: abc # just an internal stuff to make sure test.sk loads without errors
     assert last parse logs contains "Can't understand this condition/effect: no errors: abc"
+
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 last test result A":
+    fail test with no error message
+    
+devdinc test "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 last test result B":
+    set {_test::*} to all tests with test name "f39f0f4a-31ee-4b71-87e9-38ddba3a2313 last test result A"
+    assert true: last test result of {_test::1} is a fail
diff --git a/tests/pdc.sk b/tests/pdc.sk
deleted file mode 100644
index bbbf0be..0000000
--- a/tests/pdc.sk
+++ /dev/null
@@ -1,80 +0,0 @@
-import:
-    java.util.HashMap
-    java.lang.Integer
-    java.lang.Byte
-
-test "pdc basic set/get with typed pdt":
-
-    set {_key} to namespaced-key "plugin:test_int"
-
-    set {_key} within test-world for pdt integer to new Integer(42)
-    assert {_key} within test-world for pdt integer is 42 with "typed pdt get failed"
-
-
-test "pdc overwrite typed value":
-
-    set {_key} to namespaced-key "plugin:test_overwrite"
-
-    set {_key} within test-world for pdt string to "a"
-    set {_key} within test-world for pdt string to "b"
-
-    assert {_key} within test-world for pdt string is "b" with "overwrite failed"
-
-
-test "pdc delete typed value":
-
-    set {_key} to namespaced-key "plugin:test_delete"
-
-    set {_key} within test-world for pdt long to 100
-    delete {_key} within test-world for pdt long
-
-    assert {_key} within test-world for pdt long is not set with "delete failed"
-
-
-test "pdc object serialization (byte_array implicit)":
-
-    set {_key} to namespaced-key "plugin:test_object"
-
-    set {_obj} to new HashMap()
-    {_obj}.put("a", 1)
-    {_obj}.put("b", 2)
-
-    set {_key} within test-world to {_obj}
-
-    set {_out} to {_key} within test-world
-    assert {_out}.get("a") is 1 with "object deserialize failed (a)"
-    assert {_out}.get("b") is 2 with "object deserialize failed (b)"
-
-
-test "pdc remove object via null":
-
-    set {_key} to namespaced-key "plugin:test_object_remove"
-
-    set {_key} within test-world to "temp"
-    set {_key} within test-world to null
-
-    assert {_key} within test-world is not set with "object remove via null failed"
-
-
-test "pdc holder vs direct pdc equivalence":
-
-    set {_key} to namespaced-key "plugin:test_holder"
-    set {_pdc} to test-world's pdc
-
-    set {_key} within test-world for pdt byte to new Byte(7)
-    assert {_key} within {_pdc} for pdt byte is 7 with "direct pdc access failed"
-
-
-test "pdc boolean pdt":
-
-    set {_key} to namespaced-key "plugin:test_bool"
-
-    set {_key} within test-world for pdt boolean to true
-    assert {_key} within test-world for pdt boolean is true with "boolean pdt failed"
-
-
-test "pdc default object missing returns none":
-
-    set {_key} to namespaced-key "plugin:test_missing"
-
-    assert {_key} within test-world is not set with "missing object did not return none"
diff --git a/tests/working/lang/eventspecifiedvariables.test.sk b/tests/working/lang/eventspecifiedvariables.test.sk
new file mode 100644
index 0000000..f91f7c7
--- /dev/null
+++ b/tests/working/lang/eventspecifiedvariables.test.sk
@@ -0,0 +1,104 @@
+import:
+    ch.njol.skript.log.SkriptLogger
+
+test "variable scalar set/get":
+    set {_x} with custom-event to 5
+    set {_res} to {_x} with custom-event
+    assert {_res} is 5 with "scalar get"
+
+test "variable scalar set overwrite":
+    set {_x} with custom-event to 1
+    set {_x} with custom-event to 10
+    assert {_x} is 10 with "scalar set overwrite"
+
+test "variable scalar add unset":
+    delete {_x} with custom-event
+    add 3 to {_x} with custom-event
+    assert {_x} is 3 with "scalar add when unset"
+
+test "variable scalar add existing":
+    set {_x} with custom-event to 4
+    add 6 to {_x} with custom-event
+    assert {_x} is 10 with "scalar add existing"
+
+test "variable scalar remove":
+    set {_x} with custom-event to 10
+    remove 3 from {_x} with custom-event
+    assert {_x} is 7 with "scalar remove subtract"
+
+test "variable scalar delete":
+    set {_x} with custom-event to 5
+    delete {_x} with custom-event
+    assert {_x} is not set with "scalar delete"
+
+test "variable scalar reset":
+    set {_x} to 5
+    reset {_x} with custom-event
+    assert {_x} is not set with "scalar reset"
+
+test "variable list set/get":
+    set {_list::*} with custom-event to "a", "b", "c"
+    set {_res::*} to {_list::*} with custom-event
+    assert {_res::1} is "a" with "list get index 1"
+    assert {_res::2} is "b" with "list get index 2"
+    assert {_res::3} is "c" with "list get index 3"
+
+test "variable list set clears previous":
+    set {_list::*} to "x", "y"
+    set {_list::*} with custom-event to "a", "b"
+    assert {_list::1} is "a" with "list overwrite clears old"
+    assert {_list::2} is "b" with "list overwrite new value"
+    assert {_list::3} is not set with "list cleared extra entries"
+
+test "variable list add":
+    set {_list::*} with custom-event to "a", "b"
+    add "c", "d" to {_list::*} with custom-event
+    assert {_list::1} is "a" with "list add preserves index 1"
+    assert {_list::2} is "b" with "list add preserves index 2"
+    assert {_list::3} is "c" with "list add index 3"
+    assert {_list::4} is "d" with "list add index 4"
+
+test "variable list remove first match":
+    set {_list::*} to "a", "b", "c"
+    remove "b" from {_list::*} with custom-event
+    assert {_list::2} is not set with "list remove deletes matching entry"
+    assert {_list::1} is "a" with "list remove keeps others"
+
+test "variable list remove all":
+    set {_list::*} to "a", "b", "a", "c"
+    remove all "a" from {_list::*} with custom-event
+    assert {_list::1} is not "a" with "list remove all removes first"
+    assert {_list::3} is not "a" with "list remove all removes duplicates"
+
+test "variable list delete":
+    set {_list::*} to "x", "y"
+    delete {_list::*} with custom-event
+    assert {_list::*} is not set with "list delete clears list"
+
+test "variable list reset":
+    set {_list::*} to "x", "y"
+    reset {_list::*} with custom-event
+    assert {_list::*} is not set with "list reset clears list"
+    
+test "inner resolution":
+    # ephemeral prefix works but for skript warning "Starting a variable with a variable... warning we do this"
+    set {_inner} to "event.scopified.test::*" 
+    set {-a%{_inner}%} with custom-event to 15
+    assert {-aevent.scopified.test::*} contains 15
+
+test "string locals":
+    set variable "_abc" with custom-event to "abc"
+    assert variable "_abc" with custom-event is "abc"
+    assert {_abc} is "abc"
+
+#test "variable parse rejects non-variable":
+#    parse:
+#        set {_x} to variable 5 with custom-event
+#    assert last parse logs contains "Expression 1 must be a variable"
+
+#test "variable parse rejects multiple change values":
+#    parse:
+#        set {_x} with custom-event to 1, 2
+#    assert last parse logs contains "You can't set a single variable to multiple values"
+
+
diff --git a/tests/working/lang/scopedvariable.test.sk b/tests/working/lang/scopedvariable.test.sk
new file mode 100644
index 0000000..46b2b75
--- /dev/null
+++ b/tests/working/lang/scopedvariable.test.sk
@@ -0,0 +1,109 @@
+test "scoped variable - set & get":
+    set scoped {-test} to 12
+    assert scoped {-test} is 12
+
+test "scoped variable - add":
+    set scoped {-addtest} to 5
+    add 3 to scoped {-addtest}
+    assert scoped {-addtest} is 8
+
+test "scoped variable - lists":
+    set scoped {-lists::*} to "a", "b", "c"
+    assert scoped {-lists::*} contains "a"
+    assert scoped {-lists::*} contains "b"
+    assert scoped {-lists::*} contains "c"
+
+test "scoped variable - remove":
+    set scoped {-removetest::*} to "a", "b", "c"
+    remove "b" from scoped {-removetest::*}
+    assert scoped {-removetest::*} contains "a"
+    assert scoped {-removetest::*} contains "c"
+    assert scoped {-removetest::*} does not contain "b"
+
+test "scoped variable - remove all":
+    set scoped {-removeall::*} to "a", "b", "b", "c"
+    remove all "b" from scoped {-removeall::*}
+    assert scoped {-removeall::*} is "a", "c"
+
+test "scoped variable - delete":
+    set scoped {-deletetest} to 42
+    delete scoped {-deletetest}
+    assert scoped {-deletetest} is not set
+
+test "scoped variable - reset single value":
+    set scoped {-resettest} to 9
+    reset scoped {-resettest}
+    assert scoped {-resettest} is not set
+
+test "scoped variable - reset list":
+    set scoped {-resetlist::*} to 1, 2, 3
+    reset scoped {-resetlist::*}
+    assert scoped {-resetlist::*} is not set
+
+test "scoped variable - non-ephemeral (named)":
+    set scoped {namedtest} to "hello"
+    assert scoped {namedtest} is "hello"
+    delete scoped {namedtest}
+
+test "scoped variable - script scoping":
+    set scoped {-scoped} within current script to 100
+    assert scoped {-scoped} is 100
+    set scoped {-scoped2} to 100
+    assert scoped {-scoped2} within current script is 100
+
+test "scoped variable - inner expression resolution":
+    set {_i} to 1
+    set scoped {-list::*} to 20
+    assert scoped {-list::%{_i}%} is 20
+    set {_list::*} to scoped {-list::*}
+    assert {_list::%{_i}%} is 20
+    assert scoped {-list::1} is 20
+    
+test "scoped variable - folder vs current script isolation":
+    set scoped {-x} within current script to 1
+    set scoped {-x} within current folder to 2
+
+    assert scoped {-x} within current script is 1
+    assert scoped {-x} within current folder is 2
+
+devdinc test "scoped variable - default scope switch to folder":
+    set default scope for scoped variables in current script to current folder
+
+    set scoped {-d} to 42
+
+    without halting assert scoped {-d} within current folder is 42
+    without halting assert scoped {-d} within current script is not set
+    set default scope for scoped variables in current script to current script
+
+test "scoped variable - default scope is script-local":
+    set scoped {-a} to 5
+
+    set default scope for scoped variables in current script to current folder
+    set scoped {-b} to 6
+
+    assert scoped {-a} within current script is 5
+    assert scoped {-b} within current folder is 6
+    set default scope for scoped variables in current script to current script
+
+#test "scoped variable - list folder isolation":
+#    set scoped {-l::*} within folder "one" to "a", "b"
+#    set scoped {-l::*} within folder "two" to "c"
+#
+#    assert scoped {-l::*} within folder "one" is "a", "b"
+#    assert scoped {-l::*} within folder "two" is "c"
+
+test "scoped variable - reset does not affect other scopes":
+    set scoped {-r} within current folder to 1
+    set scoped {-r} within current script to 2
+
+    reset scoped {-r} within current script
+
+    assert scoped {-r} within current script is not set
+    assert scoped {-r} within current folder is 1
+
+test "scoped variable - locals a":
+    set scoped {_locals::a} to 15
+    assert scoped {_locals::a} is 15
+    
+test "scoped variable - locals b":
+    assert scoped {_locals::a} is not 15
diff --git a/tests/functionsv2.sk b/tests/working/libs/functionsv2.test.sk
similarity index 82%
rename from tests/functionsv2.sk
rename to tests/working/libs/functionsv2.test.sk
index d65f537..bfd4467 100644
--- a/tests/functionsv2.sk
+++ b/tests/working/libs/functionsv2.test.sk
@@ -108,3 +108,32 @@ test "java call":
     set {_lam} to lambda:+ new URL("https://www.dummy2.com")
     set {_val} to {_lam}.get()
     assert {_val}.getClass().getSimpleName().equalsIgnoreCase("URL") is true 
+
+test "run multiline lambda with return":
+    set {_sup} to lambda:
+        set {_x} to "yes"
+        return {_x}
+    assert (run lambda {_sup}) is "yes" with "multiline lambda return failed"
+
+test "multiline lambda multiple runs":
+    clear {-functions::test::*}
+    set {-functions::test::varl} to 0
+    set {_sup} to lambda:
+        add 1 to {-functions::test::varl}
+        return {-functions::test::varl}
+    assert (run lambda {_sup}) is 1
+    assert (run lambda {_sup}) is 2
+
+test "multiline lambda with if":
+    set {_sup} to lambda:
+        if {_none} is not set:
+            return "yes"
+        return "no"
+    assert (run lambda {_sup}) is "yes" with "if control flow failed"
+
+test "multiline supplier":
+    set {_sup} to new supplier:
+        set {_a} to 1
+        return {_a}
+    assert (run lambda {_sup}) is 1
+
diff --git a/tests/singlinesection.sk b/tests/working/libs/parser/singlelinesection.test.sk
similarity index 86%
rename from tests/singlinesection.sk
rename to tests/working/libs/parser/singlelinesection.test.sk
index 045d6f7..b9201a9 100644
--- a/tests/singlinesection.sk
+++ b/tests/working/libs/parser/singlelinesection.test.sk
@@ -31,3 +31,7 @@ test "new single line section expression":
     set {_section} to single line section "set {_a} to 2", "set {_c} to 3", "return {_a} + {_b} + {_c}"
     run section {_section} and store result in {_n}
     assert {_n} is 5 with error "single line section bug 7"
+    
+    set {_section} to single line section "if {_none} is not set:", "    return {_x} + {_z}" with args "{_x}", "{_z}"
+    run section {_section} with 15, 10 and store result in {_n}
+    assert {_n} is 25 with "single line section bug 8"
diff --git a/tests/working/libs/pdc.test.sk b/tests/working/libs/pdc.test.sk
new file mode 100644
index 0000000..aad6eb4
--- /dev/null
+++ b/tests/working/libs/pdc.test.sk
@@ -0,0 +1,115 @@
+import:
+    java.util.HashMap
+    
+on load:
+    set scoped {-key} to "plugin:test_pdt"
+    
+after each test:
+    event-script is current script
+    delete namespaced-key scoped {-key} within test-world if scoped {-key} is set
+    
+# since we use after each test we have to use devdinc test pattern here
+
+devdinc test "pdc basic set/get with typed pdt":
+
+    set namespaced-key scoped {-key} within test-world for pdt integer to 42
+    assert namespaced-key scoped {-key} within test-world for pdt integer is 42 with "typed pdt get failed"
+
+devdinc test "pdc overwrite typed value":
+
+    set namespaced-key scoped {-key} within test-world for pdt string to "a"
+    set namespaced-key scoped {-key} within test-world for pdt string to "b"
+
+    assert namespaced-key scoped {-key} within test-world for pdt string is "b" with "overwrite failed"
+
+devdinc test "pdc delete typed value":
+    set namespaced-key scoped {-key} within test-world for pdt long to 100
+    delete namespaced-key scoped {-key} within test-world for pdt long
+
+    assert namespaced-key scoped {-key} within test-world for pdt long is not set with "delete failed"
+
+devdinc test "pdc object serialization (byte_array implicit)":
+
+    set {_obj} to new HashMap()
+    {_obj}.put("a", 1)
+    {_obj}.put("b", 2)
+
+    set namespaced-key scoped {-key} within test-world to {_obj}
+
+    set {_out} to namespaced-key scoped {-key} within test-world
+    assert {_out}.get("a") is 1 with "object deserialize failed (a)"
+    assert {_out}.get("b") is 2 with "object deserialize failed (b)"
+
+devdinc test "pdc remove object via null":
+
+    set namespaced-key scoped {-key} within test-world to "temp"
+    set namespaced-key scoped {-key} within test-world to null
+
+    assert namespaced-key scoped {-key} within test-world is not set with "object remove via null failed"
+
+devdinc test "pdc holder vs direct pdc equivalence":
+    set {_pdc} to test-world's pdc
+
+    set namespaced-key scoped {-key} within test-world for pdt byte to 7
+    assert namespaced-key scoped {-key} within {_pdc} for pdt byte is 7 with "direct pdc access failed"
+
+devdinc test "pdc boolean pdt":
+
+    set namespaced-key scoped {-key} within test-world for pdt boolean to true
+    assert namespaced-key scoped {-key} within test-world for pdt boolean is true with "boolean pdt failed"
+
+devdinc test "pdc default object missing returns none":
+
+    assert namespaced-key scoped {-key} within test-world is not set with "missing object did not return none"
+
+devdinc test "pdc unspecified pdt boolean":
+
+    set namespaced-key scoped {-key} within test-world to true
+    assert namespaced-key scoped {-key} within test-world is true with "unspecified boolean failed"
+
+devdinc test "pdc unspecified pdt byte":
+
+    set namespaced-key scoped {-key} within test-world to 5
+    assert namespaced-key scoped {-key} within test-world is 5 with "unspecified byte failed"
+
+devdinc test "pdc unspecified pdt short":
+
+    set namespaced-key scoped {-key} within test-world to 12
+    assert namespaced-key scoped {-key} within test-world is 12 with "unspecified short failed"
+
+devdinc test "pdc unspecified pdt integer":
+
+    set namespaced-key scoped {-key} within test-world to 123
+    assert namespaced-key scoped {-key} within test-world is 123 with "unspecified integer failed"
+
+devdinc test "pdc unspecified pdt long":
+
+    set namespaced-key scoped {-key} within test-world to 123
+    assert namespaced-key scoped {-key} within test-world is 123 with "unspecified long failed"
+
+devdinc test "pdc unspecified pdt float":
+
+    set namespaced-key scoped {-key} within test-world to 1.5
+    assert namespaced-key scoped {-key} within test-world is 1.5 with "unspecified float failed"
+
+devdinc test "pdc unspecified pdt double":
+    
+    set namespaced-key scoped {-key} within test-world to 2.75
+    assert namespaced-key scoped {-key} within test-world is 2.75 with "unspecified double failed"
+
+
+devdinc test "pdc unspecified pdt string":
+
+    set namespaced-key scoped {-key} within test-world to "hello"
+    assert namespaced-key scoped {-key} within test-world is "hello" with "unspecified string failed"
+
+devdinc test "pdc unspecified pdt tag_container":
+
+    set {_inner-pdc} to new pdc from test-world
+    set {_inner-key} to "plugin:inner_key"
+    set namespaced-key {_inner-key} within {_inner-pdc} for pdt integer to 9
+
+    set namespaced-key scoped {-key} within test-world to {_inner-pdc}
+
+    set {_out-pdc} to namespaced-key scoped {-key} within test-world
+    assert namespaced-key {_inner-key} within {_out-pdc} for pdt integer is 9 with "unspecified tag_container failed"
diff --git a/tests/routines.sk b/tests/working/libs/routines.test.sk
similarity index 85%
rename from tests/routines.sk
rename to tests/working/libs/routines.test.sk
index 7daff81..b76a3dc 100644
--- a/tests/routines.sk
+++ b/tests/working/libs/routines.test.sk
@@ -5,7 +5,7 @@ test "routines basic":
     set {_res} to routine.fluent(instant now).context(async context).supply(lambda:+ new URL("https://www.dummy2.com")).join()
     assert "%{_res}%" is "https://www.dummy2.com" with "java call"
 
-    set {_res} to wait for fluent routine lambda: routine_local_get_url()
+    set {_res} to wait for fluent routine lambda:+ routine_local_get_url()
     assert "%{_res}%" is "https://www.dummy1.com" with "function call"