@misterscan/sesi 1.2.3 → 1.3.2

package/main/epochs.sesi

@@ -1,94 +0,0 @@
-print "------------------------------------------"
-print "🎛️ Hyperparameter Tuning Sesi Neural Network..."
-
-// 1. Inputs and Targets
-let inputs = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]]
-let targets = [0.0, 0.0, 0.0, 1.0]
-
-// 2. TUNED HYPERPARAMETERS
-let w1 = random() - 0.5
-let w2 = random() - 0.5
-let b = random() - 0.5
-
-let lr = 0.3       // Increased Learning Rate (from 0.15 to 0.3) to take bigger steps
-let epochs = 1500  // Increased Epochs (from 300 to 1500) to give the network 5x more practice!
-
-print "Initial Parameters:"
-print "w1: " + str(w1) + ", w2: " + str(w2) + ", bias: " + str(b)
-print "Training with Tuned Parameters (lr = 0.3, epochs = 1500)..."
-print "------------------------------------------"
-
-// Fast Sigmoid (Softsign) activation
-fn activate(x) {
-  let absX = x
-  if x < 0.0 {
-    absX = 0.0 - x
-  }
-  return 0.5 + (0.5 * (x / (1.0 + absX)))
-}
-
-fn activate_derivative(y) {
-  return y * (1.0 - y)
-}
-
-// 3. Training Loop
-let totalError = 0.0 // Declared outside the loop to be in-scope for final print diagnostics!
-let epoch = 0
-while epoch < epochs {
-  totalError = 0.0
-  let i = 0
-  
-  while i < 4 {
-    let x = inputs[i]
-    let target = targets[i]
-    
-    // Forward Propagation
-    let sum = (x[0] * w1) + (x[1] * w2) + b
-    let output = activate(sum)
-    
-    // Calculate Error
-    let error = target - output
-    totalError = totalError + (error * error)
-    
-    // Backpropagation
-    let gradient = error * activate_derivative(output)
-    
-    // Gradient Updates
-    w1 = w1 + (lr * gradient * x[0])
-    w2 = w2 + (lr * gradient * x[1])
-    b = b + (lr * gradient)
-    
-    i = i + 1
-  }
-  
-  // Log Loss progress to see convergence
-  if (epoch % 300) == 0 {
-    print "Epoch " + str(epoch) + " - Loss (MSE): " + str(totalError / 4.0)
-  }
-  
-  epoch = epoch + 1
-}
-
-print "------------------------------------------"
-print "🎉 Tuned Training Complete!"
-print "Final Loss (MSE): " + str(totalError / 4.0) // This will now parse successfully!
-print "------------------------------------------"
-
-// 4. Save the tuned model to disk
-let modelState = {"w1": w1, "w2": w2, "b": b}
-write_file("model_weights.json", to_json(modelState))
-print "💾 Saved tuned knobs to model_weights.json"
-print "------------------------------------------"
-
-// 5. Testing Tuned Predictions
-print "🔮 Testing Tuned Predictions:"
-let i = 0
-while i < 4 {
-  let x = inputs[i]
-  let sum = (x[0] * w1) + (x[1] * w2) + b
-  let pred = activate(sum)
-  
-  print "Input: [" + str(x[0]) + ", " + str(x[1]) + "] -> Expected: " + str(targets[i]) + " -> Predicted: " + str(pred)
-  i = i + 1
-}
-print "------------------------------------------"

package/main/gpu_orchestrator.sesi

@@ -1,36 +0,0 @@
-// Sesi Script: gpu_orchestrator.sesi
-// Master bootstrap and execution controller for the GPU Live Telemetry & Baby Neural Network pipeline.
-
-print "=========================================="
-print "🖥️  Sesi Deep Learning Pipeline Bootstrap..."
-print "=========================================="
-
-// 1. Seed the initial progress.json file to prevent browser fetch race conditions
-let initialState = "{\n  \"epoch\": 0,\n  \"max_epochs\": 1500,\n  \"loss\": 0.25,\n  \"accuracy\": 0.5,\n  \"loss_history\": [0.25],\n  \"accuracy_history\": [0.5],\n  \"gpu\": {\n    \"temp\": 38,\n    \"util\": 0,\n    \"vram_used\": 450,\n    \"vram_total\": 4096\n  },\n  \"status\": \"Pipeline initialized... waiting for GPU start.\",\n  \"predictions\": [0.5, 0.5, 0.5, 0.5]\n}"
-
-write_file("progress.json", initialState)
-print "📝 Seeded initial telemetry file: progress.json"
-
-// 2. Spawning background PyTorch/CUDA-simulated Neural Network script asynchronously
-print "🚀 Spawning background GPU model trainer and telemetry stream..."
-
-let spawnSuccess = false
-try {
-  exec("powershell -Command \"Start-Process python -ArgumentList 'gpu_trainer.py'\"")
-  spawnSuccess = true
-} catch (e) {
-  try {
-    exec("powershell -Command \"Start-Process py -ArgumentList 'gpu_trainer.py'\"")
-    spawnSuccess = true
-  } catch (e2) {
-    print "❌ Failed to spawn background Python process!"
-  }
-}
-
-if spawnSuccess {
-  print "⚡ Background GPU pipeline successfully launched!"
-  print "🌐 Opening visual telemetry control panel in your browser..."
-  print "=========================================="
-  print "🎉 DONE! Sit back, look at your browser, and enjoy watching your actual GTX 1660 Ti load up as the baby network converges!"
-  print "=========================================="
-}

package/main/hardware_diagnostics.sesi

@@ -1,118 +0,0 @@
-// Sesi Script: hardware_diagnostics.sesi
-// Natively orchestrates Python and PowerShell to query physical CPU & GPU hardware specifications.
-
-print "------------------------------------------"
-print "🔍 Initializing Hardware Specifications Scan..."
-print "🔌 Spawning PowerShell-to-Python pipeline..."
-
-// 1. Write the Python diagnostics script to retrieve advanced hardware specs
-let pythonCode = "import subprocess
-import json
-import platform
-
-def get_cpu():
-    try:
-        cmd = 'powershell -Command \"Get-CimInstance Win32_Processor | Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed | ConvertTo-Json\"'
-        output = subprocess.check_output(cmd, shell=True).decode().strip()
-        data = json.loads(output)
-        if isinstance(data, list):
-            data = data[0]
-        return {
-            'name': data.get('Name', 'Unknown CPU').strip(),
-            'cores': data.get('NumberOfCores', 4),
-            'threads': data.get('NumberOfLogicalProcessors', 8),
-            'speed_ghz': round(int(data.get('MaxClockSpeed', 3000)) / 1000, 1)
-        }
-    except Exception as e:
-        return {'name': 'Unknown CPU', 'cores': 0, 'threads': 0, 'speed_ghz': 0.0}
-
-def get_gpus():
-    try:
-        cmd = 'powershell -Command \"Get-CimInstance Win32_VideoController | Select-Object Name, DriverVersion, AdapterRAM | ConvertTo-Json\"'
-        output = subprocess.check_output(cmd, shell=True).decode().strip()
-        if not output:
-            return []
-        data = json.loads(output)
-        if not isinstance(data, list):
-            data = [data]
-        gpus = []
-        for g in data:
-            ram_bytes = g.get('AdapterRAM', 0)
-            ram_gb = 0.0
-            if ram_bytes:
-                try:
-                    ram_val = int(ram_bytes)
-                    if ram_val < 0:
-                        ram_val = ram_val + 2**32
-                    ram_gb = round(ram_val / (1024**3), 1)
-                except:
-                    pass
-            gpus.append({
-                'name': g.get('Name', 'Unknown GPU'),
-                'driver': g.get('DriverVersion', 'Unknown'),
-                'vram_gb': ram_gb
-            })
-        return gpus
-    except Exception as e:
-        return []
-
-data = {
-    'platform': platform.system() + ' ' + platform.release() + ' (' + platform.machine() + ')',
-    'cpu': get_cpu(),
-    'gpus': get_gpus()
-}
-print(json.dumps(data))
-"
-
-write_file("hardware_info.py", pythonCode)
-print "📝 Hardware script programmatically written to: hardware_info.py"
-
-// 2. Execute the python subprocess
-print "⚙️ Spawning system metrics gathering process..."
-let sysOutput = ""
-try {
-  sysOutput = exec("python hardware_info.py")
-} catch (e) {
-  try {
-    sysOutput = exec("py hardware_info.py")
-  } catch (e2) {
-    print "❌ Failed to run Python. Make sure Python is in your PATH!"
-  }
-}
-
-// 3. Parse and read the returned results natively in Sesi!
-if sysOutput != "" {
-  let specs = from_json(sysOutput)
-  
-  print "------------------------------------------"
-  print "🖥️  SYSTEM HARDWARE DIAGNOSTICS REPORT  🖥️"
-  print "------------------------------------------"
-  print "🌐 Platform:     " + specs["platform"]
-  print "------------------------------------------"
-  print "⚡ PROCESSOR (CPU):"
-  print "   Model Name:   " + specs["cpu"]["name"]
-  print "   Physical Cores: " + str(specs["cpu"]["cores"])
-  print "   Logical Threads: " + str(specs["cpu"]["threads"])
-  print "   Max Clock Speed: " + str(specs["cpu"]["speed_ghz"]) + " GHz"
-  print "------------------------------------------"
-  
-  let gpuList = specs["gpus"]
-  let gpuCount = len(gpuList)
-  print "🎮 GRAPHICS CONTROLLER (GPU) - Detected (" + str(gpuCount) + "):"
-  
-  let i = 0
-  while i < gpuCount {
-    let gpu = gpuList[i]
-    let gpuNum = i + 1
-    print "   GPU #" + str(gpuNum) + ":"
-    print "   Model Name:     " + gpu["name"]
-    print "   Driver Version: " + gpu["driver"]
-    if gpu["vram_gb"] > 0.0 {
-      print "   Dedicated VRAM: " + str(gpu["vram_gb"]) + " GB"
-    } else {
-      print "   Dedicated VRAM: Shared/Integrated System Memory"
-    }
-    i = i + 1
-  }
-  print "------------------------------------------"
-}

package/main/inference.sesi

@@ -1,54 +0,0 @@
-// Sesi Script: inference.sesi
-// Pure-Sesi high-precision 2-layer Neural Network inference engine.
-// Instantly loads and propagates saved weights from model_weights.json using our upgraded native exp() compiler builtin!
-
-print "------------------------------------------"
-print "🔮 Running Sesi Multi-Layer Neural Network Inference..."
-print "📝 Reading saved parameters from model_weights.json..."
-
-// 1. Read and parse saved weights natively
-let rawState = read_file("model_weights.json")
-let weightsData = from_json(rawState)
-
-let w_hidden = weightsData["w_hidden"]
-let b_hidden = weightsData["b_hidden"]
-let w_output = weightsData["w_output"]
-let b_output = weightsData["b_output"]
-
-print "------------------------------------------"
-print "🚀 Neural weights successfully loaded!"
-print "🚀 Performing feedforward propagation completely natively in Sesi..."
-print "------------------------------------------"
-
-// Upgraded native Sigmoid using our compiled exp() builtin!
-fn activate(x) {
-  let denom = 1.0 + exp(0.0 - x)
-  return 1.0 / denom
-}
-
-// 2. Perform feedforward predictions on the 4 XOR inputs
-let inputs = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]]
-let targets = [0.0, 1.0, 1.0, 0.0]
-
-let i = 0
-while i < 4 {
-  let x = inputs[i]
-  let target = targets[i]
-  
-  // Forward propagation: Hidden Layer
-  // Neuron 0
-  let h_sum0 = (x[0] * w_hidden[0][0]) + (x[1] * w_hidden[0][1]) + b_hidden[0]
-  let h_out0 = activate(h_sum0)
-  
-  // Neuron 1
-  let h_sum1 = (x[0] * w_hidden[1][0]) + (x[1] * w_hidden[1][1]) + b_hidden[1]
-  let h_out1 = activate(h_sum1)
-  
-  // Forward propagation: Output Layer
-  let o_sum = (h_out0 * w_output[0]) + (h_out1 * w_output[1]) + b_output
-  let output = activate(o_sum)
-  
-  print "Input: [" + str(x[0]) + ", " + str(x[1]) + "] -> Expected: " + str(target) + " -> Natively Predicted: " + str(output)
-  i = i + 1
-}
-print "------------------------------------------"

package/main/native_chatbot.sesi

@@ -1,180 +0,0 @@
-// Sesi Script: native_chatbot.sesi
-// 100% NATIVE DATA-TRAINED DEVELOEPR CO-PILOT CHATBOT!
-// Trained entirely inside Sesi on 14 keywords across 6 distinct functional categories!
-
-// ==================================================
-// 💬 1. CHOOSE YOUR ADVANCED TECHNICAL QUERY HERE!
-// (Test it with custom phrases containing our keywords!)
-let queryText = "create an svg"
-// ==================================================
-
-print "=================================================="
-print "🧠 WELCOME TO THE NATIVE-TRAINED SESI DEVELOEPR CO-PILOT!"
-print "=================================================="
-print "⚙️  Vectorizing training vocabulary..."
-
-// Sigmoid math
-fn activate(x) {
-  return 1.0 / (1.0 + exp(0.0 - x))
-}
-
-fn derivative(y) {
-  return y * (1.0 - y)
-}
-
-// 2. Advanced Bag-of-Words Vectorizer (14 keywords)
-fn vectorize(text) {
-  let words = split(text, " ")
-  let vec = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-  
-  let w = 0
-  while w < len(words) {
-    let word = words[w]
-    if word == "print" { vec[0] = 1.0 }
-    if word == "str" { vec[1] = 1.0 }
-    if word == "type" { vec[2] = 1.0 }
-    if word == "num" { vec[3] = 1.0 }
-    if word == "bool" { vec[4] = 1.0 }
-    if word == "json" { vec[5] = 1.0 }
-    if word == "convert" { vec[6] = 1.0 }
-    if word == "array" { vec[7] = 1.0 }
-    if word == "len" { vec[8] = 1.0 }
-    if word == "file" { vec[9] = 1.0 }
-    if word == "write" { vec[10] = 1.0 }
-    if word == "dir" { vec[11] = 1.0 }
-    if word == "exp" { vec[12] = 1.0 }
-    if word == "random" { vec[13] = 1.0 }
-    w = w + 1
-  }
-  return vec
-}
-
-// Helper to calculate neuron forward dot product
-fn compute_output(x, w, b) {
-  let sum = 0.0
-  let i = 0
-  while i < 14 {
-    sum = sum + (x[i] * w[i])
-    i = i + 1
-  }
-  return activate(sum + b)
-}
-
-// 3. Setup Comprehensive Labeled Dataset (6 classes, declared strictly on single continuous lines)
-let inputs = [vectorize("how to print str logging output"), vectorize("type check and num bool conversion"), vectorize("convert objects to json format"), vectorize("array length len split push pop keys"), vectorize("file write list dir read image"), vectorize("math exp random synaptic calculations")]
-
-let targets = [[1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 1.0]]
-
-// 4. Initialize synaptic weights and biases for the 6 output units
-let w0 = [0.1, 0.2, -0.1, 0.3, -0.2, 0.1, -0.1, 0.2, -0.1, 0.1, -0.2, 0.1, -0.3, 0.2]
-let w1 = [-0.1, 0.1, 0.3, 0.2, 0.1, -0.2, 0.1, -0.3, 0.2, -0.1, 0.1, -0.2, 0.1, -0.1]
-let w2 = [0.2, -0.2, 0.1, -0.1, 0.2, 0.3, 0.3, 0.1, -0.2, 0.2, -0.1, 0.1, -0.2, 0.1]
-let w3 = [-0.1, 0.1, -0.2, 0.1, -0.1, 0.2, -0.1, 0.3, 0.3, -0.2, 0.1, -0.1, 0.2, -0.2]
-let w4 = [0.1, -0.1, 0.2, -0.2, 0.1, -0.1, 0.2, -0.1, 0.2, 0.4, 0.4, 0.3, -0.1, 0.1]
-let w5 = [-0.2, 0.2, -0.1, 0.1, -0.2, 0.1, -0.2, 0.1, -0.2, 0.1, -0.2, 0.1, 0.4, 0.4]
-
-let b0 = -0.1
-let b1 = 0.1
-let b2 = -0.2
-let b3 = 0.2
-let b4 = -0.1
-let b5 = 0.0
-
-print "🧠 Training 14x6 multi-class Sesi neural synapses..."
-
-// 5. Run native single-layer gradient descent training loop (2,000 epochs)
-let lr = 0.4
-let epoch = 1
-while epoch <= 2000 {
-  let c = 0
-  while c < 6 {
-    let x = inputs[c]
-    let t = targets[c]
-    
-    // Forward Propagation
-    let o0 = compute_output(x, w0, b0)
-    let o1 = compute_output(x, w1, b1)
-    let o2 = compute_output(x, w2, b2)
-    let o3 = compute_output(x, w3, b3)
-    let o4 = compute_output(x, w4, b4)
-    let o5 = compute_output(x, w5, b5)
-    
-    // Backpropagation deltas
-    let delta0 = (t[0] - o0) * derivative(o0)
-    let delta1 = (t[1] - o1) * derivative(o1)
-    let delta2 = (t[2] - o2) * derivative(o2)
-    let delta3 = (t[3] - o3) * derivative(o3)
-    let delta4 = (t[4] - o4) * derivative(o4)
-    let delta5 = (t[5] - o5) * derivative(o5)
-    
-    // Synaptic Weight Updates
-    let k = 0
-    while k < 14 {
-      w0[k] = w0[k] + (lr * delta0 * x[k])
-      w1[k] = w1[k] + (lr * delta1 * x[k])
-      w2[k] = w2[k] + (lr * delta2 * x[k])
-      w3[k] = w3[k] + (lr * delta3 * x[k])
-      w4[k] = w4[k] + (lr * delta4 * x[k])
-      w5[k] = w5[k] + (lr * delta5 * x[k])
-      k = k + 1
-    }
-    
-    b0 = b0 + (lr * delta0)
-    b1 = b1 + (lr * delta1)
-    b2 = b2 + (lr * delta2)
-    b3 = b3 + (lr * delta3)
-    b4 = b4 + (lr * delta4)
-    b5 = b5 + (lr * delta5)
-    
-    c = c + 1
-  }
-  epoch = epoch + 1
-}
-
-print "🎯 Synaptic parameters optimized! Brain ready."
-print "--------------------------------------------------"
-
-// 6. Comprehensive Technical Reference Database (Declared strictly on single continuous lines to satisfy Sesi parser!)
-let responses = ["📖 SESI MANUAL: I/O & CONSOLE LOGGING\n   🎯 Function: print(...args) -> null\n      - Prints multiple values to stdout separated by spaces.\n      - Example: print \"Value:\", 42\n   🎯 Function: str(value) -> string\n      - Convers any primitive, array, or object into a clean string representation.\n      - Example: let s = str([1, 2])", "📖 SESI MANUAL: TYPE CHECKING & CASTING\n   🎯 Function: type(value) -> string\n      - Returns native Sesi types: 'number', 'string', 'bool', 'null', 'array', 'object'.\n   🎯 Function: num(value) -> number / bool(value) -> bool\n      - Converts values to numbers or booleans using strict truthiness rules.\n      - Example: num(\"3.14\") -> 3.14 / bool(0) -> false", "📖 SESI MANUAL: JSON UTILITIES\n   🎯 Function: to_json(value) -> string\n      - Serializes an array or object into a formatted JSON string.\n   🎯 Function: from_json(string) -> any\n      - Parses valid JSON strings back into native Sesi arrays and objects.\n      - Example: let obj = from_json(\"{\\\"a\\\": 1}\")\n      - Note: Critical for offline parameters loading!", "📖 SESI MANUAL: ARRAYS & COLLECTIONS\n   🎯 Function: len(col) -> number / range(n) -> array\n      - len() returns collection size. range(n) creates a sequence from 0 to n-1.\n   🎯 Function: push(arr, v) -> pop(arr) -> any\n      - Adds/removes elements in-place.\n   🎯 Function: join(arr, sep) / split(str, sep)\n      - Joins array elements or splits strings into array components.", "📖 SESI MANUAL: FILE SYSTEM OPERATIONS\n   🎯 Function: read_file(path) / write_file(path, text)\n      - Reads or writes text files relative to the workspace directory.\n   🎯 Function: write_image(path, base64_content) -> bool\n      - Writes base64 strings directly as binary image files (e.g. logos).\n   🎯 Function: list_dir(path) / make_dir(path)\n      - Lists directory items or recursively creates new directories.", "📖 SESI MANUAL: MATH & DEEP LEARNING\n   🎯 Function: exp(x) -> number\n      - Computes high-speed exponential function Math.exp(x).\n      - Fundamental for native neural networks: Sigmoid = 1.0 / (1.0 + exp(-x))\n   🎯 Function: random() -> number\n      - Returns a pseudo-random decimal float between 0.0 and 1.0.\n      - Essential for seed randomization and breaking saddle points!"]
-
-// 7. Query User String!
-print "📥 User Query Input: \"" + queryText + "\""
-let query_vec = vectorize(queryText)
-print "📊 Vectorized Input: " + str(query_vec)
-print "--------------------------------------------------"
-
-// Forward propagation on user query
-let q_o0 = compute_output(query_vec, w0, b0)
-let q_o1 = compute_output(query_vec, w1, b1)
-let q_o2 = compute_output(query_vec, w2, b2)
-let q_o3 = compute_output(query_vec, w3, b3)
-let q_o4 = compute_output(query_vec, w4, b4)
-let q_o5 = compute_output(query_vec, w5, b5)
-
-let outputs = [q_o0, q_o1, q_o2, q_o3, q_o4, q_o5]
-print "🧠 Neural Activation Scores: " + str(outputs)
-
-// Determine class index with highest score
-let best_class = 0
-let max_score = -1.0
-let j = 0
-while j < 6 {
-  if outputs[j] > max_score {
-    max_score = outputs[j]
-    best_class = j
-  }
-  j = j + 1
-}
-
-print "--------------------------------------------------"
-print "🤖 SESI CO-PILOT RESPONDING:"
-print "--------------------------------------------------"
-if max_score < 0.40 {
-  print "🤔 Sesi's native synapses evaluated this query with low confidence: " + str(max_score)
-  print "   It seems your question does not contain any Sesi keywords in our vocabulary!"
-  print "   Please try asking about: 'print', 'str', 'files', 'json', 'exp', or 'random'!"
-} else {
-  print responses[best_class]
-  print "📐 Neural Classification Confidence: " + str(max_score)
-}
-print "=================================================="

package/main/native_synthesizer.sesi

@@ -1,83 +0,0 @@
-// Sesi Script: native_synthesizer.sesi
-// 100% NATIVE OFFLINE MARKOV TEXT SYNTHESIZER!
-// Generatively types Sesi code syntax word-by-word completely offline with zero API calls!
-
-// ==================================================
-// 💬 1. DEFINE YOUR INSPIRATIONAL TRAINING CORPUS!
-// ==================================================
-let corpus = "let value = 42 print value let raw = to_json(value) let obj = from_json(raw) print obj if value > 10 print value while value < 100 let value = value + 1 print value read_file(path) write_file(path, text) write_image(path, data) list_dir(path) make_dir(path) exp(x) random()"
-
-print "=================================================="
-print "📻 BLUE NOTE SYNTHESIZER: NATIVE TEXT GENERATION"
-print "=================================================="
-print "⚙️  Analyzing corpus structure..."
-
-// Native Floor function (Genius string-splitting floor logic!)
-fn floor(x) {
-  let s = str(x)
-  let parts = split(s, ".")
-  return num(parts[0])
-}
-
-// 2. Tokenize corpus
-let words = split(corpus, " ")
-let num_words = len(words)
-print "📊 Compiled " + str(num_words) + " corpus tokens!"
-
-// 3. Compile Markov Transition Table (Word-to-Word transition dictionary)
-let transitions = {}
-
-let i = 0
-while i < (num_words - 1) {
-  let w1 = words[i]
-  let w2 = words[i + 1]
-  
-  let key_exists = type(transitions[w1]) == "array"
-  if key_exists == false {
-    // Declared strictly on one line to satisfy Sesi parser
-    transitions[w1] = []
-  }
-  
-  let list = transitions[w1]
-  push(list, w2)
-  
-  i = i + 1
-}
-
-print "🎯 State transition probabilities calculated!"
-print "--------------------------------------------------"
-
-// 4. Generate synthetic Sesi code sentences!
-let current_word = "let" // Start word
-let generated = current_word
-let gen_steps = 1
-let max_steps = 25 // Length of synthesized text
-
-while gen_steps < max_steps {
-  let choices = transitions[current_word]
-  let has_choices = type(choices) == "array"
-  
-  if has_choices == false {
-    // If we hit a dead end, wrap back to starting word
-    current_word = "let"
-  } else {
-    let num_choices = len(choices)
-    if num_choices == 0 {
-      current_word = "let"
-    } else {
-      // Pick a mathematically safe random index
-      let rand_idx = floor(random() * num_choices)
-      let next_word = choices[rand_idx]
-      
-      generated = generated + " " + next_word
-      current_word = next_word
-    }
-  }
-  
-  gen_steps = gen_steps + 1
-}
-
-print "🤖 GENERATED NATIVE SESI SYNTHESIS:"
-print "--------------------------------------------------"
-print generated
-print "=================================================="