Add UNLICENSE; improve REPL, module import/export, I/O and freezing

Add UNLICENSE (public-domain dedication).
Wire REPL to behave like script top-level: use <string> as source filename, create a top-level frame, and route input/output via configurable input_provider/output_sink. Ensure prompts start on a fresh line when prior output exists and reset call stack after errored evaluations so the REPL remains usable.
Add module caching for IMPORT: cache module Environment and created Function objects so subsequent imports reuse the same namespace instance and avoid re-executing module code. Publish module top-level bindings as dotted names (module.name) into the caller environment.
Add EXPORT(symbol, module) to copy a caller binding into an imported module's dotted namespace.
Improve INPUT to accept an optional prompt, forward prompts to the output sink, and record prompts in the I/O log for deterministic replay.
Add shushing controls: SHUSH/UNSHUSH to temporarily suppress forwarding of console output (while still recording I/O events); make RUN temporarily disable shushing so run-invoked output is always forwarded.
Make PRINT, child process output, and other forwarders respect the shushed flag so forwarded console output is suppressed when shushed.
Add identifier freeze controls: FREEZE, THAW, PERMAFREEZE with runtime enforcement (prevent reassignment/deletion of frozen bindings), plus query helpers FROZEN and PERMAFROZEN.
Add EXPORT, FROZEN, PERMAFROZEN builtins and hook their behaviors into the interpreter environment.
Improve READFILE to read raw bytes and decode robustly (UTF-8 with/without BOM, UTF-16, fallback with replacement) to avoid decoding crashes on BOM or different encodings.
Update lexer to accept both single and double quotes for string literals (must open and close with same delimiter).
Add small warning in collection.asmln and expand test.asmln to print progress and success messages for library tests.
Update spec.txt to document new behaviors: string quoting, INPUT(prompt), SHUSH/UNSHUSH, freezing semantics, EXPORT, and IMPORT caching semantics.

Author: python-processing-unit

UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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 more information, please refer to https://unlicense.org

asmln.exe

@@ -19,14 +19,26 @@ def _parse_statements_from_source(text: str, filename: str) -> List[Statement]:
 
 def run_repl(verbose: bool) -> int:
     print("\x1b[38;2;153;221;255mASM-Lang\033[0m REPL. Enter statements, blank line to run buffer.")
-    interpreter = Interpreter(source="", filename="<repl>", verbose=verbose)
+    # Use "<string>" as the REPL's effective source filename so that MAIN() and imports behave
+    had_output = False
+    def _output_sink(text: str) -> None:
+        nonlocal had_output
+        had_output = True
+        print(text, end="")
+
+    interpreter = Interpreter(source="", filename="<string>", verbose=verbose, input_provider=(lambda: input()), output_sink=_output_sink)
     global_env = Environment()
-    global_frame = interpreter._new_frame("<repl>", global_env, None)
+    # Make the REPL top-level frame mimic script top-level frame
+    global_frame = interpreter._new_frame("<top-level>", global_env, None)
     interpreter.call_stack.append(global_frame)
     buffer: List[str] = []
 
     while True:
         prompt = "\x1b[38;2;153;221;255m>>>\033[0m " if not buffer else "\x1b[38;2;153;221;255m..>\033[0m "
+        if had_output:
+            # Ensure prompt starts on a fresh line if the program printed anything
+            print()
+            had_output = False
         try:
             line = input(prompt)
         except EOFError:
@@ -45,20 +57,21 @@ def run_repl(verbose: bool) -> int:
 
         if not buffer and stripped != "" and not is_block_start:
             try:
-                statements = _parse_statements_from_source(line, "<repl>")
+                statements = _parse_statements_from_source(line, "<string>")
                 try:
                     interpreter._execute_block(statements, global_env)
                 except ExitSignal as sig:
                     return sig.code
             except ASMParseError:
+                # If a single-line parse fails, treat it as start of multi-line input
                 buffer.append(line)
             continue
 
         if stripped == "" and buffer:
             source_text = "\n".join(buffer)
             buffer.clear()
             try:
-                statements = _parse_statements_from_source(source_text, "<repl>")
+                statements = _parse_statements_from_source(source_text, "<string>")
                 interpreter._execute_block(statements, global_env)
             except ExitSignal as sig:
                 return sig.code
@@ -69,13 +82,12 @@ def run_repl(verbose: bool) -> int:
                     error.step_index = interpreter.logger.entries[-1].step_index
                 formatter = TracebackFormatter(interpreter)
                 print(formatter.format_text(error, verbose=interpreter.verbose), file=sys.stderr)
+                # reset call stack to single top-level frame to keep REPL usable
                 interpreter.call_stack = [global_frame]
             continue
 
         buffer.append(line)
 
-    return 0
-
 
 def run_cli(argv: Optional[List[str]] = None) -> int:
     parser = argparse.ArgumentParser(description="ASM-Lang reference interpreter")