smc-lang 0.1.0__tar.gz

smc_lang-0.1.0/LICENSE

@@ -0,0 +1,42 @@
+SMC Fair-Source License (Version 1.0)
+Copyright (c) 2026 Jason Rezek. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software subject to the following conditions:
+
+1. INDIVIDUAL, ACADEMIC & NON-COMMERCIAL USE
+Use, copying, modification, merging, publishing, and distribution of the Software
+for personal, educational, academic, non-commercial, or hobbyist purposes is
+completely free of charge and permitted in perpetuity.
+
+2. SMALL BUSINESS SAFE HARBOR
+Use of the Software by any business entity whose gross annual revenues (or total
+funding raised) do not exceed $1,000,000 USD (one million United States dollars)
+and employs fewer than 10 full-time equivalent employees is completely free of charge.
+
+3. ENTERPRISE COMMERCIAL USE
+Any use of the Software by or on behalf of any commercial entity that exceeds the
+Small Business Safe Harbor threshold, or any use of the Software to provide a paid
+hosted cloud service, SaaS runtime, or managed execution platform, requires a paid
+Commercial License Agreement executed with the Copyright Holder.
+
+4. INTELLECTUAL PROPERTY & ATTRIBUTION
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+DISCLAIMER OF WARRANTY:
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+================================================================================
+For Enterprise Licensing, Commercial Inquiries, and Custom Integrations:
+Contact: Jason Rezek
+Email: zekvftb@gmail.com
+GitHub: https://github.com/zekvftb/smc-lang
+================================================================================

smc_lang-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: smc-lang
+Version: 0.1.0
+Summary: Saturday Morning Cartoons (SMC): A biologically inspired, fault-tolerant programming language and VM
+Author-email: Jason Rezek <zekvftb@gmail.com>
+License: Fair-Source-1.0 (Free for Individuals, Commercial for Enterprise)
+Keywords: programming-language,virtual-machine,biology-inspired,fault-tolerant,cartoons
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 📺 SMC (Saturday Morning Cartoons) Programming Language
+
+**SMC (Saturday Morning Cartoons)** is a biologically inspired, fault-tolerant programming language and standalone virtual machine. 
+
+It translates the fundamental computational principles of **DNA and RNA** into modern, license-free software architecture, paired with subtle 90s cartoon and anime nostalgia!
+
+---
+
+## 📖 Complete Documentation & Tutorial
+👉 **Read the comprehensive guide and manual in [docs/GUIDE.md](docs/GUIDE.md)**!
+
+---
+
+## 🧬 Biological Principles to SMC Software Architecture
+
+| Real Biological Mechanism (DNA/RNA) | Computer Science Problem | SMC Language Solution |
+| :--- | :--- | :--- |
+| **Codon Degeneracy** (64 codons map to 20 amino acids; 3rd base wobble absorbs mutations) | Rigid syntax: a single missing letter or typo halts the compiler with a fatal error. | **Wobble Typo-Tolerance**: Synonyms map to identical opcodes. Minor spelling mistakes are smoothly repaired via Levenshtein edit-distance without halting. |
+| **Overlapping Genes** (PhiX174 reading two different proteins from the same sequence) | 1D sequential execution: every routine requires its own separate memory footprint. | **CatDog Multi-Framing**: Interleave two complete programs on the exact same line of code; read at offset 0 (Cat) or offset 1 (Dog) for 2x memory density. |
+| **mRNA Half-Life Decay** (Poly-A tail shortens on each translation until transcript dissolves) | Memory leaks in C/C++; periodic CPU freezes from Garbage Collectors in Java/Python. | **Acme Anvil TTL**: Ephemeral variables carry an auto-decrementing `acme(ttl=N)` timer. Once expired, it vaporizes from RAM with zero memory leaks and 0% GC pauses. |
+| **Lock-and-Key Receptors** (Proteins find targets by 3D physical pocket shape, not pointers) | Fragile numeric memory pointers (`0x7FFF`) and hard-coded network IP endpoints. | **Planetary Shape Dispatch**: Functions bind to elemental and planetary rings (`MERCURY`, `MARS`, `JUPITER`, `VENUS`, `MOON`). Callers emit ring keys to trigger matching handlers. |
+| **p53 DNA Repair Checkpoint** ("Guardian of the genome" catching unrouted sequences) | Unhandled exceptions and crash cascades. | **Tuxedo Mask Watchdog**: Catches unrouted dispatches with a graceful fallback block ("My work here is done!"). |
+| **Cellular Differentiation** (Stem cells differentiating into specialized tissue states) | State evolution and polymorphic typing. | **Sailor Moon Transformation**: `transform` / `MOON_PRISM_POWER` blocks explicitly evolve state objects. |
+
+---
+
+## ⚡ Quickstart
+
+### 1. Installation (100% Free & MIT/Public Domain)
+```powershell
+pip install -e D:\smc_lang\
+```
+
+### 2. Launching the Live Interactive REPL
+```powershell
+smc
+# or: python -m smc.cli repl
+```
+
+### 3. Running an SMC Script
+```powershell
+python -m smc.cli run D:\smc_lang\examples\advanced_functions.smc
+```
+
+### 4. Running CatDog Dual-Frame Overlapping Code
+```powershell
+python -m smc.cli catdog D:\smc_lang\examples\catdog_dual_frame.smc
+```
+
+### 5. Inspecting Repaired Mutations & Tokens
+```powershell
+python -m smc.cli tokens D:\smc_lang\examples\sailor_moon_battle.smc
+```
+
+---
+
+## 🎨 Modern Professional Syntax (with Degenerate Aliases)
+
+SMC prioritizes clean, modern, professional keywords, while preserving nostalgic aliases under the hood:
+
+```smc
+experiment "Planetary_Defense"
+
+# 1. Full arithmetic expressions with order of operations (* and / before + and -)
+let enemy_hp = 100
+let attack_power = (15 * 2) - 5   # Evaluates to 25
+
+# 2. Tuxedo Mask watchdog fallback
+fallback {
+    print "Tuxedo Mask throws a red rose! (Graceful fallback executed)"
+}
+
+# 3. Planetary Senshi ring binding
+bind(ring="MARS") {
+    print "Sailor Mars: Flame blast triggered!"
+}
+
+# 4. Turn-based combat loop (while loop & conditionals)
+while (enemy_hp > 0) {
+    # Acme Anvil ephemeral shield (auto-vaporizes after 2 cycles without GC pauses)
+    acme(ttl=2) defense_shield = "Active_Barrier"
+
+    dispatch "MARS"
+    let enemy_hp = enemy_hp - attack_power
+}
+
+# 5. Sailor Moon State Transformation (Cellular Differentiation)
+let guardian = "Usagi_Tsukino"
+transform guardian = "Princess_Serenity" {
+    print "State transformed to royal tier!"
+}
+
+halt
+```
+
+---
+
+## 🧪 Automated Testing
+Run the comprehensive test suite:
+```powershell
+python -m pytest D:\smc_lang\tests/
+```
+**All 15 tests pass in 0.12 seconds!**
+
+---
+
+## 📜 License & Enterprise Commercial Terms
+
+SMC is distributed under the **SMC Fair-Source License 1.0**:
+
+* 🎓 **100% Free for Individuals, Students, & Non-Commercial Use:** You can learn, play, modify, and build personal or academic projects completely free forever.
+* 🚀 **Small Business Safe Harbor:** 100% free for startups and companies with **gross annual revenues under $1,000,000 USD** and fewer than 10 employees.
+* 🏢 **Enterprise Commercial License:** Commercial use by large entities exceeding the threshold, or use as a paid hosted cloud service, requires an Enterprise Commercial License.
+
+For commercial licensing agreements and enterprise integration inquiries, contact:  
+**Jason Rezek** — [`zekvftb@gmail.com`](mailto:zekvftb@gmail.com)

smc_lang-0.1.0/README.md

@@ -0,0 +1,116 @@
+# 📺 SMC (Saturday Morning Cartoons) Programming Language
+
+**SMC (Saturday Morning Cartoons)** is a biologically inspired, fault-tolerant programming language and standalone virtual machine. 
+
+It translates the fundamental computational principles of **DNA and RNA** into modern, license-free software architecture, paired with subtle 90s cartoon and anime nostalgia!
+
+---
+
+## 📖 Complete Documentation & Tutorial
+👉 **Read the comprehensive guide and manual in [docs/GUIDE.md](docs/GUIDE.md)**!
+
+---
+
+## 🧬 Biological Principles to SMC Software Architecture
+
+| Real Biological Mechanism (DNA/RNA) | Computer Science Problem | SMC Language Solution |
+| :--- | :--- | :--- |
+| **Codon Degeneracy** (64 codons map to 20 amino acids; 3rd base wobble absorbs mutations) | Rigid syntax: a single missing letter or typo halts the compiler with a fatal error. | **Wobble Typo-Tolerance**: Synonyms map to identical opcodes. Minor spelling mistakes are smoothly repaired via Levenshtein edit-distance without halting. |
+| **Overlapping Genes** (PhiX174 reading two different proteins from the same sequence) | 1D sequential execution: every routine requires its own separate memory footprint. | **CatDog Multi-Framing**: Interleave two complete programs on the exact same line of code; read at offset 0 (Cat) or offset 1 (Dog) for 2x memory density. |
+| **mRNA Half-Life Decay** (Poly-A tail shortens on each translation until transcript dissolves) | Memory leaks in C/C++; periodic CPU freezes from Garbage Collectors in Java/Python. | **Acme Anvil TTL**: Ephemeral variables carry an auto-decrementing `acme(ttl=N)` timer. Once expired, it vaporizes from RAM with zero memory leaks and 0% GC pauses. |
+| **Lock-and-Key Receptors** (Proteins find targets by 3D physical pocket shape, not pointers) | Fragile numeric memory pointers (`0x7FFF`) and hard-coded network IP endpoints. | **Planetary Shape Dispatch**: Functions bind to elemental and planetary rings (`MERCURY`, `MARS`, `JUPITER`, `VENUS`, `MOON`). Callers emit ring keys to trigger matching handlers. |
+| **p53 DNA Repair Checkpoint** ("Guardian of the genome" catching unrouted sequences) | Unhandled exceptions and crash cascades. | **Tuxedo Mask Watchdog**: Catches unrouted dispatches with a graceful fallback block ("My work here is done!"). |
+| **Cellular Differentiation** (Stem cells differentiating into specialized tissue states) | State evolution and polymorphic typing. | **Sailor Moon Transformation**: `transform` / `MOON_PRISM_POWER` blocks explicitly evolve state objects. |
+
+---
+
+## ⚡ Quickstart
+
+### 1. Installation (100% Free & MIT/Public Domain)
+```powershell
+pip install -e D:\smc_lang\
+```
+
+### 2. Launching the Live Interactive REPL
+```powershell
+smc
+# or: python -m smc.cli repl
+```
+
+### 3. Running an SMC Script
+```powershell
+python -m smc.cli run D:\smc_lang\examples\advanced_functions.smc
+```
+
+### 4. Running CatDog Dual-Frame Overlapping Code
+```powershell
+python -m smc.cli catdog D:\smc_lang\examples\catdog_dual_frame.smc
+```
+
+### 5. Inspecting Repaired Mutations & Tokens
+```powershell
+python -m smc.cli tokens D:\smc_lang\examples\sailor_moon_battle.smc
+```
+
+---
+
+## 🎨 Modern Professional Syntax (with Degenerate Aliases)
+
+SMC prioritizes clean, modern, professional keywords, while preserving nostalgic aliases under the hood:
+
+```smc
+experiment "Planetary_Defense"
+
+# 1. Full arithmetic expressions with order of operations (* and / before + and -)
+let enemy_hp = 100
+let attack_power = (15 * 2) - 5   # Evaluates to 25
+
+# 2. Tuxedo Mask watchdog fallback
+fallback {
+    print "Tuxedo Mask throws a red rose! (Graceful fallback executed)"
+}
+
+# 3. Planetary Senshi ring binding
+bind(ring="MARS") {
+    print "Sailor Mars: Flame blast triggered!"
+}
+
+# 4. Turn-based combat loop (while loop & conditionals)
+while (enemy_hp > 0) {
+    # Acme Anvil ephemeral shield (auto-vaporizes after 2 cycles without GC pauses)
+    acme(ttl=2) defense_shield = "Active_Barrier"
+
+    dispatch "MARS"
+    let enemy_hp = enemy_hp - attack_power
+}
+
+# 5. Sailor Moon State Transformation (Cellular Differentiation)
+let guardian = "Usagi_Tsukino"
+transform guardian = "Princess_Serenity" {
+    print "State transformed to royal tier!"
+}
+
+halt
+```
+
+---
+
+## 🧪 Automated Testing
+Run the comprehensive test suite:
+```powershell
+python -m pytest D:\smc_lang\tests/
+```
+**All 15 tests pass in 0.12 seconds!**
+
+---
+
+## 📜 License & Enterprise Commercial Terms
+
+SMC is distributed under the **SMC Fair-Source License 1.0**:
+
+* 🎓 **100% Free for Individuals, Students, & Non-Commercial Use:** You can learn, play, modify, and build personal or academic projects completely free forever.
+* 🚀 **Small Business Safe Harbor:** 100% free for startups and companies with **gross annual revenues under $1,000,000 USD** and fewer than 10 employees.
+* 🏢 **Enterprise Commercial License:** Commercial use by large entities exceeding the threshold, or use as a paid hosted cloud service, requires an Enterprise Commercial License.
+
+For commercial licensing agreements and enterprise integration inquiries, contact:  
+**Jason Rezek** — [`zekvftb@gmail.com`](mailto:zekvftb@gmail.com)

smc_lang-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smc-lang"
+version = "0.1.0"
+description = "Saturday Morning Cartoons (SMC): A biologically inspired, fault-tolerant programming language and VM"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    { name = "Jason Rezek", email = "zekvftb@gmail.com" }
+]
+license = { text = "Fair-Source-1.0 (Free for Individuals, Commercial for Enterprise)" }
+keywords = ["programming-language", "virtual-machine", "biology-inspired", "fault-tolerant", "cartoons"]
+dependencies = []
+
+[project.scripts]
+smc = "smc.cli:main"
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "-v --tb=short"

smc_lang-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

smc_lang-0.1.0/src/smc/__init__.py

@@ -0,0 +1,22 @@
+"""Saturday Morning Cartoons (SMC) Language.
+
+A biologically inspired, fault-tolerant programming language and virtual machine
+featuring degenerate opcodes, CatDog multi-framing, Acme-TTL ephemeral memory,
+and Captain Planet content-addressable dispatch.
+"""
+
+__version__ = "0.1.0"
+
+from smc.tokens import Opcode, CanonicalToken, TokenType
+from smc.lexer import SmcLexer
+from smc.parser import SmcParser
+from smc.vm import DexterVM
+
+__all__ = [
+    "Opcode",
+    "CanonicalToken",
+    "TokenType",
+    "SmcLexer",
+    "SmcParser",
+    "DexterVM",
+]

smc_lang-0.1.0/src/smc/cli.py

@@ -0,0 +1,132 @@
+"""Command-Line Interface for SMC (Saturday Morning Cartoons) Language.
+
+Usage:
+  smc                      # Launch the interactive live REPL shell
+  smc repl                 # Launch the interactive live REPL shell
+  smc run <file.smc>       # Execute script in DexterVM
+  smc catdog <file.smc>    # Execute CatDog dual-frame interleaved routines
+  smc tokens <file.smc>    # Inspect token stream and degenerate opcode mappings
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+
+from smc.lexer import SmcLexer
+from smc.parser import CatDogSlicer, SmcParser
+from smc.repl import start_repl
+from smc.vm import DexterVM
+
+
+def run_file(file_path: Path | str) -> None:
+    path = Path(file_path)
+    if not path.is_file():
+        print(f"Error: File not found at '{path}'")
+        sys.exit(1)
+
+    source = path.read_text(encoding="utf-8")
+    lexer = SmcLexer(source)
+    tokens = lexer.tokenize()
+
+    parser = SmcParser(tokens)
+    ast = parser.parse()
+
+    vm = DexterVM()
+    res = vm.run(ast)
+
+    print("\n--- DEXTER_VM EXECUTION OUTPUT ---")
+    for line in res["stdout"]:
+        print(line)
+    print("----------------------------------\n")
+    print(f"Steps: {res['execution_steps']} | Anvils Dropped: {res['anvils_dropped']} | Mutations Survived: {res['mutations_survived']}")
+
+
+def run_catdog(file_path: Path | str) -> None:
+    path = Path(file_path)
+    if not path.is_file():
+        print(f"Error: File not found at '{path}'")
+        sys.exit(1)
+
+    source = path.read_text(encoding="utf-8")
+    lexer = SmcLexer(source)
+    tokens = lexer.tokenize()
+
+    cat_tokens, dog_tokens = CatDogSlicer.slice_frames(tokens)
+
+    print("\n[CAT FRAME] ==================== (OFFSET +0) ====================")
+    cat_ast = SmcParser(cat_tokens).parse()
+    cat_vm = DexterVM()
+    cat_res = cat_vm.run(cat_ast)
+    for line in cat_res["stdout"]:
+        print(line)
+
+    print("\n[DOG FRAME] ==================== (OFFSET +1) ====================")
+    dog_ast = SmcParser(dog_tokens).parse()
+    dog_vm = DexterVM()
+    dog_res = dog_vm.run(dog_ast)
+    for line in dog_res["stdout"]:
+        print(line)
+    print("===================================================================\n")
+
+
+def print_tokens(file_path: Path | str) -> None:
+    path = Path(file_path)
+    if not path.is_file():
+        print(f"Error: File not found at '{path}'")
+        sys.exit(1)
+
+    source = path.read_text(encoding="utf-8")
+    lexer = SmcLexer(source)
+    tokens = lexer.tokenize()
+
+    print(f"\n--- TOKEN STREAM FOR {path.name} ---")
+    for t in tokens:
+        mut_flag = " [MUTATION REPAIRED!]" if t.was_mutated else ""
+        op_str = f" -> Opcode.{t.resolved_opcode.value}" if t.resolved_opcode else ""
+        print(f"Line {t.line:02d}:{t.column:02d} | {t.token_type.value:<12} | '{t.value}'{op_str}{mut_flag}")
+    print("------------------------------------\n")
+
+
+def main() -> None:
+    # If invoked with no arguments, launch REPL directly
+    if len(sys.argv) == 1:
+        start_repl()
+        return
+
+    parser = argparse.ArgumentParser(
+        description="SMC (Saturday Morning Cartoons) Language CLI",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # repl command
+    subparsers.add_parser("repl", help="Launch interactive live REPL shell")
+
+    # run command
+    run_parser = subparsers.add_parser("run", help="Execute an SMC script")
+    run_parser.add_argument("file", type=str, help="Path to .smc file")
+
+    # catdog command
+    catdog_parser = subparsers.add_parser("catdog", help="Execute dual-frame CatDog interleaved program")
+    catdog_parser.add_argument("file", type=str, help="Path to .smc file")
+
+    # tokens command
+    tokens_parser = subparsers.add_parser("tokens", help="Inspect tokens and degenerate wobble mappings")
+    tokens_parser.add_argument("file", type=str, help="Path to .smc file")
+
+    args = parser.parse_args()
+
+    if args.command == "repl":
+        start_repl()
+    elif args.command == "run":
+        run_file(args.file)
+    elif args.command == "catdog":
+        run_catdog(args.file)
+    elif args.command == "tokens":
+        print_tokens(args.file)
+
+
+if __name__ == "__main__":
+    main()

smc_lang-0.1.0/src/smc/lexer.py

@@ -0,0 +1,192 @@
+"""Fault-Tolerant Lexer for SMC ("Saturday Morning Cartoons") Language.
+
+Tokenizes source text and applies biological codon degeneracy to resolve
+synonyms and mutated keywords without throwing fatal syntax errors.
+Supports arithmetic operators, logical comparisons, and control flow tokens.
+"""
+
+from __future__ import annotations
+
+from smc.tokens import (
+    CanonicalToken,
+    KEYWORD_TO_OPCODE,
+    Opcode,
+    TokenType,
+    resolve_wobble_opcode,
+)
+
+
+class SmcLexer:
+    """Tokenizes SMC source code with codon wobble tolerancing."""
+
+    def __init__(self, source_text: str) -> None:
+        self.source = source_text
+        self.pos = 0
+        self.line = 1
+        self.col = 1
+        self.length = len(source_text)
+
+    def _peek(self, offset: int = 0) -> str:
+        idx = self.pos + offset
+        return self.source[idx] if idx < self.length else "\0"
+
+    def _advance(self) -> str:
+        ch = self._peek()
+        self.pos += 1
+        if ch == "\n":
+            self.line += 1
+            self.col = 1
+        else:
+            self.col += 1
+        return ch
+
+    def _skip_whitespace_and_comments(self) -> None:
+        while self.pos < self.length:
+            ch = self._peek()
+            if ch in " \t\r\n":
+                self._advance()
+            elif ch == "#":
+                # Comment until end of line
+                while self.pos < self.length and self._peek() != "\n":
+                    self._advance()
+            else:
+                break
+
+    def tokenize(self) -> list[CanonicalToken]:
+        """Convert full source into a list of CanonicalToken objects."""
+        tokens: list[CanonicalToken] = []
+
+        while self.pos < self.length:
+            self._skip_whitespace_and_comments()
+            if self.pos >= self.length:
+                break
+
+            ch = self._peek()
+            start_line = self.line
+            start_col = self.col
+
+            # Multi-character comparison operators
+            if ch == "=" and self._peek(1) == "=":
+                self._advance()
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.EQ_EQ, "==", start_line, start_col))
+            elif ch == "!" and self._peek(1) == "=":
+                self._advance()
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.NOT_EQ, "!=", start_line, start_col))
+            elif ch == "<" and self._peek(1) == "=":
+                self._advance()
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.LTE, "<=", start_line, start_col))
+            elif ch == ">" and self._peek(1) == "=":
+                self._advance()
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.GTE, ">=", start_line, start_col))
+
+            # Single-character delimiters and operators
+            elif ch == "(":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.LPAREN, "(", start_line, start_col))
+            elif ch == ")":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.RPAREN, ")", start_line, start_col))
+            elif ch == "[":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.LBRACKET, "[", start_line, start_col))
+            elif ch == "]":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.RBRACKET, "]", start_line, start_col))
+            elif ch == "{":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.LBRACE, "{", start_line, start_col))
+            elif ch == "}":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.RBRACE, "}", start_line, start_col))
+            elif ch == "=":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.EQUALS, "=", start_line, start_col))
+            elif ch == ",":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.COMMA, ",", start_line, start_col))
+            elif ch == "+":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.PLUS, "+", start_line, start_col))
+            elif ch == "-":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.MINUS, "-", start_line, start_col))
+            elif ch == "*":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.STAR, "*", start_line, start_col))
+            elif ch == "/":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.SLASH, "/", start_line, start_col))
+            elif ch == "%":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.PERCENT, "%", start_line, start_col))
+            elif ch == "<":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.LT, "<", start_line, start_col))
+            elif ch == ">":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.GT, ">", start_line, start_col))
+            elif ch == "!":
+                self._advance()
+                tokens.append(CanonicalToken(TokenType.NOT, "!", start_line, start_col))
+
+            # String literals
+            elif ch in ('"', "'"):
+                quote_char = self._advance()
+                val_chars = []
+                while self.pos < self.length and self._peek() != quote_char:
+                    val_chars.append(self._advance())
+                if self._peek() == quote_char:
+                    self._advance()  # closing quote
+                tokens.append(CanonicalToken(TokenType.STRING, "".join(val_chars), start_line, start_col))
+
+            # Numbers
+            elif ch.isdigit():
+                num_chars = []
+                while self.pos < self.length and (self._peek().isdigit() or self._peek() == "."):
+                    num_chars.append(self._advance())
+                num_str = "".join(num_chars)
+                val = float(num_str) if "." in num_str else int(num_str)
+                tokens.append(CanonicalToken(TokenType.NUMBER, val, start_line, start_col))
+
+            # Identifiers and Opcode Keywords
+            elif ch.isalpha() or ch == "_":
+                ident_chars = []
+                while self.pos < self.length and (self._peek().isalnum() or self._peek() == "_"):
+                    ident_chars.append(self._advance())
+                ident_str = "".join(ident_chars)
+
+                # Attempt wobble opcode resolution
+                resolved_op = resolve_wobble_opcode(ident_str, max_distance=2)
+                if resolved_op:
+                    was_mut = (ident_str.upper() not in KEYWORD_TO_OPCODE)
+                    tokens.append(
+                        CanonicalToken(
+                            token_type=TokenType.KEYWORD,
+                            value=ident_str,
+                            line=start_line,
+                            column=start_col,
+                            resolved_opcode=resolved_op,
+                            was_mutated=was_mut,
+                            original_text=ident_str,
+                        )
+                    )
+                else:
+                    tokens.append(
+                        CanonicalToken(
+                            token_type=TokenType.IDENTIFIER,
+                            value=ident_str,
+                            line=start_line,
+                            column=start_col,
+                            original_text=ident_str,
+                        )
+                    )
+            else:
+                # Unknown character, advance gracefully (biological neutral mutation)
+                self._advance()
+
+        tokens.append(CanonicalToken(TokenType.EOF, "", self.line, self.col))
+        return tokens