justfile

@@ -27,9 +27,9 @@ git_status := `git status -s`
 # publish this branch into release
 release:
     echo {{ if git_status == "" {"git status ok"} else {error("please commit changes first")} }}
-    just build
     git checkout release
     git merge {{from_branch}}
+    just build
     -git commit -am "release build"
     git push
     git checkout {{from_branch}}

pkg/rudus.d.ts

@@ -11,11 +11,11 @@ export interface InitOutput {
   readonly __externref_table_alloc: () => number;
   readonly __wbindgen_export_2: WebAssembly.Table;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_export_4: WebAssembly.Table;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-  readonly closure334_externref_shim: (a: number, b: number, c: any) => void;
-  readonly closure356_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly __wbindgen_export_6: WebAssembly.Table;
+  readonly closure343_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure365_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }
 

pkg/rudus.js

@@ -35,41 +35,6 @@ function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(state => {
-    wasm.__wbindgen_export_4.get(state.dtor)(state.a, state.b)
-});
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_4.get(state.dtor)(a, state.b);
-                CLOSURE_DTORS.unregister(state);
-            } else {
-                state.a = a;
-            }
-        }
-    };
-    real.original = state;
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
 let WASM_VECTOR_LEN = 0;
 
 const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
@@ -134,6 +99,41 @@ function getDataViewMemory0() {
     }
     return cachedDataViewMemory0;
 }
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => {
+    wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b)
+});
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
+                CLOSURE_DTORS.unregister(state);
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
 /**
  * @param {string} src
  * @returns {Promise<void>}
@@ -146,11 +146,11 @@ export function ludus(src) {
 }
 
 function __wbg_adapter_18(arg0, arg1, arg2) {
-    wasm.closure334_externref_shim(arg0, arg1, arg2);
+    wasm.closure343_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_38(arg0, arg1, arg2, arg3) {
-    wasm.closure356_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_44(arg0, arg1, arg2, arg3) {
+    wasm.closure365_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 async function __wbg_load(module, imports) {
@@ -195,6 +195,17 @@ function __wbg_get_imports() {
         const ret = arg0.call(arg1, arg2);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
     imports.wbg.__wbg_io_5a3c8ea72d8c6ea3 = function() { return handleError(function (arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
@@ -217,7 +228,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_38(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_44(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -228,6 +239,10 @@ function __wbg_get_imports() {
             state0.a = state0.b = 0;
         }
     };
+    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+        const ret = new Error();
+        return ret;
+    };
     imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return ret;
@@ -251,6 +266,13 @@ function __wbg_get_imports() {
         const ret = Promise.resolve(arg0);
         return ret;
     };
+    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+        const ret = arg1.stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
         const ret = typeof global === 'undefined' ? null : global;
         return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -284,8 +306,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper1023 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 335, __wbg_adapter_18);
+    imports.wbg.__wbindgen_closure_wrapper1044 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 344, __wbg_adapter_18);
         return ret;
     };
     imports.wbg.__wbindgen_init_externref_table = function() {

pkg/rudus_bg.wasm.d.ts

@@ -6,9 +6,9 @@ export const __wbindgen_exn_store: (a: number) => void;
 export const __externref_table_alloc: () => number;
 export const __wbindgen_export_2: WebAssembly.Table;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __wbindgen_export_4: WebAssembly.Table;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-export const closure334_externref_shim: (a: number, b: number, c: any) => void;
-export const closure356_externref_shim: (a: number, b: number, c: any, d: any) => void;
+export const __wbindgen_export_6: WebAssembly.Table;
+export const closure343_externref_shim: (a: number, b: number, c: any) => void;
+export const closure365_externref_shim: (a: number, b: number, c: any, d: any) => void;
 export const __wbindgen_start: () => void;

src/base.rs

@@ -112,7 +112,7 @@ pub fn chars(x: &Value) -> Value {
 }
 
 pub fn words(str: &Value) -> Value {
-    // console_log!("wordsing words");
+    console_log!("wordsing words");
     let str = Value::as_string(str);
     let mut words = Vector::new();
     let mut word = String::new();
@@ -124,7 +124,7 @@ pub fn words(str: &Value) -> Value {
             word = String::new()
         }
     }
-    // console_log!("words gathered into vector; returning to ludus");
+    console_log!("words gathered into vector; returning to ludus");
     Value::list(words)
 }
 

src/io.rs

@@ -95,7 +95,7 @@ pub async fn do_io (msgs: Vec<MsgOut>) -> Vec<MsgIn> {
     if !inbox.is_empty() {
         // console_log!("ludus received messages");
         for msg in inbox.iter() {
-            // console_log!("{}", msg);
+            console_log!("{}", msg);
         }
     }
     inbox

src/lib.rs

@@ -111,7 +111,7 @@ fn prelude() -> HashMap<Key, Value> {
 #[wasm_bindgen]
 pub async fn ludus(src: String) {
     // instrument wasm to report rust panics
-    // console_error_panic_hook::set_once();
+    console_error_panic_hook::set_once();
     // leak the source so it lives FOREVER
     let src = src.to_string().leak();
 

src/vm.rs

@@ -256,7 +256,7 @@ impl Creature {
     }
 
     fn broadcast_panic(&mut self) {
-        // console_log!("broadcasting panic in {}", self.pid);
+        console_log!("broadcasting panic in {}", self.pid);
         let Err(panic) = self.result.clone().unwrap() else {
             unreachable!("expected panic in broadcast panic");
         };
@@ -369,7 +369,7 @@ impl Creature {
             }
             "yield" => {
                 self.r#yield = true;
-                // console_log!("yielding from {}", self.pid);
+                console_log!("yielding from {}", self.pid);
                 self.push(Value::Keyword("ok"));
             }
             "alive" => {
@@ -389,19 +389,19 @@ impl Creature {
             "flush" => {
                 let msgs = self.mbx.iter().cloned().collect::<Vec<_>>();
                 let msgs = Vector::from(msgs);
-                // console_log!(
-                //     "delivering messages: {}",
-                //     msgs.iter()
-                //         .map(|x| x.show())
-                //         .collect::<Vec<_>>()
-                //         .join(" | ")
-                // );
+                console_log!(
+                    "delivering messages: {}",
+                    msgs.iter()
+                        .map(|x| x.show())
+                        .collect::<Vec<_>>()
+                        .join(" | ")
+                );
                 self.mbx = VecDeque::new();
-                // console_log!("flushing messages in {}", self.pid);
+                console_log!("flushing messages in {}", self.pid);
                 self.push(Value::List(Box::new(msgs)));
             }
             "sleep" => {
-                // console_log!("sleeping {} for {}", self.pid, args[1]);
+                console_log!("sleeping {} for {}", self.pid, args[1]);
                 let Value::Number(ms) = args[1] else {
                     unreachable!()
                 };
@@ -584,7 +584,7 @@ impl Creature {
                 PanicNoLetMatch => {
                     if !self.matches {
                         self.ip -= 2;
-                        // console_log!("panic at bytecode {}", self.ip);
+                        console_log!("panic at bytecode {}", self.ip);
                         return self.panic(PanicMsg::NoLetMatch);
                     }
                 }
@@ -793,10 +793,10 @@ impl Creature {
                     let dict = match self.get_value_at(dict_idx) {
                         Value::Dict(dict) => dict,
                         value => {
-                            // console_log!(
-                            //     "internal Ludus error in function {}",
-                            //     self.frame.function.as_fn().name()
-                            // );
+                            console_log!(
+                                "internal Ludus error in function {}",
+                                self.frame.function.as_fn().name()
+                            );
                             unreachable!("expected dict, got {value}")
                         }
                     };