code-wasm 0.1.0 → 1.0.0

package/README.md

@@ -1,14 +1,11 @@
 # code-wasm
 
-Run [Code](https://codelovesme.github.io/code/) — a constraint-based
-programming language with no user-defined functions and no core I/O — in
-any browser or JS host. A small WASM bridge around the language's real
-parser and interpreter, zero JS dependencies.
+Run [Code](https://codelovesme.github.io/code/) — a language with no
+user-defined functions, where behavior comes from emitting particles at
+compiled-in or linked handlers — in any browser or JS host. A small WASM
+bridge around the language's real parser and interpreter.
 
-Try it live first: [playground](https://codelovesme.github.io/code/playground/).
-Learn the language: [guide](https://codelovesme.github.io/code/guide.html) ·
-[tutorial](https://codelovesme.github.io/code/tutorial.html) ·
-[reference](https://codelovesme.github.io/code/reference.html).
+Try it live first: [playground](https://codelovesme.github.io/code/).
 
 ## Install
 
@@ -18,42 +15,29 @@ npm install code-wasm
 
 ## Usage
 
-One export, `run_source(src)`, plus a default init function you call once
-before the first run. `run_source` is synchronous — no `await` on the call
-itself, only on `init()`.
+Two exports — `run(src)` and `run_with_modules(src, modules)` — plus a
+default init function you call once before the first run. Both `run`
+functions are synchronous — no `await` on the call itself, only on
+`init()`.
 
 ### In a bundler (Vite, webpack 5, Rollup, …)
 
 ```js
-import init, { run_source } from "code-wasm";
+import init, { run } from "code-wasm";
 
 await init();
 
-const result = run_source(`
-  a = 5
-  b > 3
-  b < 10
-  assert a = 5
-`);
-
-console.log(result);
-// {
-//   ok: true,
-//   bindings: [
-//     { name: "a", value: "5", kind: "Number" },
-//     { name: "b", domain: "3 < _ < 10" },   // narrowed, never pinned to one value
-//   ],
-//   diagnostics: [],
-// }
+console.log(run("let a = 5\nassert a = 5\n"));
+// "a = 5\n"
 ```
 
 ### Directly in a browser, no bundler
 
 ```html
 <script type="module">
-  import init, { run_source } from "https://esm.sh/code-wasm";
+  import init, { run } from "https://esm.sh/code-wasm";
   await init();
-  console.log(run_source("x = 1 + 1\nassert x = 2\n"));
+  console.log(run("let x = 1 + 1\nassert x = 2\n"));
 </script>
 ```
 
@@ -67,51 +51,112 @@ plain Node. Pass the bytes directly instead, resolved with
 
 ```js
 import { readFileSync } from "node:fs";
-import init, { run_source } from "code-wasm";
+import init, { run } from "code-wasm";
 
 const wasmUrl = import.meta.resolve("code-wasm/dist/code_wasm_bg.wasm");
 await init({ module_or_path: readFileSync(new URL(wasmUrl)) });
 
-console.log(run_source("a = 1\n"));
+console.log(run("let a = 1\n"));
 ```
 
-## The `run_source` result shape
+## `run(src)`
 
-This is a public contract — see this package's
-[source ticket](https://github.com/codelovesme/code/blob/main/docs/tickets/low/19-browser-playground.md)
-before depending on internals beyond what's documented here.
+Returns the program's final top-level bindings, rendered exactly like
+`code run`'s stdout (`name = value`, one per line, JSON-shaped values) —
+or `"error: ..."` on any failure (parse error, undefined variable, a
+failed `assert`, …). There is no structured result type; parse the string
+yourself if you need one.
 
-```ts
-type RunResult = {
-  ok: boolean;
-  bindings: Binding[];
-  diagnostics: Diagnostic[];
+```js
+run("let a = 5\nlet b = \"hi\"\nassert a = 5\n");
+// 'a = 5\nb = "hi"\n'
+```
+
+## `run_with_modules(src, modules)`
+
+Lets `src` `link` third-party modules — the thing plain `run` refuses (see
+Scope below). `modules` is a plain JS object; each own-enumerable key is a
+name your script can `link "<name>" as <alias>`, mapped to
+`{ dispatch(particleJson) -> resultJson, vars?() -> varsJson }`:
+
+- **`dispatch`** is called once per `emit <particle> to <alias>` — `code`
+  serializes the particle to a JSON string (its own value model already
+  *is* JSON), calls your function, and parses whatever JSON string it
+  returns back into a value. Both calls are synchronous.
+- **`vars`** (optional) is called once, when `link` runs, and becomes
+  `<alias>.<name>` field access — the same role a `.so` module's exported
+  variables play natively. A module with no `vars` gets an empty object.
+
+```js
+const modules = {
+  math: {
+    dispatch(particleJson) {
+      const p = JSON.parse(particleJson);
+      if (p._class === "Double") {
+        return JSON.stringify({ _class: "DoubleResult", value: p.value * 2 });
+      }
+      throw new Error("unknown handler");
+    },
+    vars() {
+      return JSON.stringify({ pi: 3.14159 });
+    },
+  },
 };
 
-type Binding =
-  | { name: string; value: string; kind: string }   // resolved to one value
-  | { name: string; domain: string };                // narrowed, never pinned
+run_with_modules(
+  'link "math" as m\n' +
+    'emit Double { "_class": "Double", "value": 21 } to m get n\n' +
+    "assert n.value = 42\n",
+  modules,
+);
+```
+
+`code` never touches WebAssembly bytes directly — turning an actual
+`.wasm` file into this `{dispatch, vars}` shape (instantiating it, reading
+its exports, marshaling to/from its linear memory) is entirely your job.
+A minimal sketch, assuming the module exports `alloc`/`dispatch`/`dealloc`
+functions that read/write UTF-8 JSON through its own memory:
 
-type Diagnostic = {
-  message: string;
-  start: number;  // char offset into the source you passed in
-  end: number;
+```js
+const { instance } = await WebAssembly.instantiateStreaming(fetch(url));
+const enc = new TextEncoder(), dec = new TextDecoder();
+
+function callWasm(fn, json) {
+  const bytes = enc.encode(json);
+  const ptr = instance.exports.alloc(bytes.length);
+  new Uint8Array(instance.exports.memory.buffer, ptr, bytes.length).set(bytes);
+  const [outPtr, outLen] = fn(ptr, bytes.length); // your module's own convention
+  const result = dec.decode(new Uint8Array(instance.exports.memory.buffer, outPtr, outLen));
+  instance.exports.dealloc(ptr, bytes.length);
+  return result;
+}
+
+const modules = {
+  mymodule: {
+    dispatch: (json) => callWasm(instance.exports.dispatch, json),
+  },
 };
 ```
 
-Code has no core I/O — a program never prints anything. Its only
-observable result is its final top-level variable bindings (plus any
-`assert` that fails, surfaced as a diagnostic). That's what `bindings`
-is: the entire visible output of the program, the same thing a
-constraint-solver's final variable assignment would be.
+Because everything crosses this boundary as plain JSON text, a module
+backed by a plain JS function (no WebAssembly at all, as in the first
+example above) is just as valid — `code` can't tell the difference, and
+doesn't need to.
+
+`link` is resolved entirely before `run_with_modules` starts running
+`src` — there is no way for a script to trigger a *new*
+`WebAssembly.instantiate` mid-run (that's inherently asynchronous;
+`link`ing isn't). Provide every module you might need up front.
 
-## Scope (v1)
+## Scope
 
-- A single, self-contained snippet — no `link` (module import) support yet.
-  No filesystem access in a browser; module linking via an in-memory
-  source map is a planned follow-up, not yet wired into this bridge.
-- No native (`.so`) module linking — native code has no meaning in a wasm
-  sandbox.
+- `run` (no modules) has no `link` support at all, deliberately — the
+  playground's plain snippets never need it.
+- No native `.so`/`.a` module linking — native machine code has no
+  meaning inside a WebAssembly sandbox; see
+  [`docs/todo/native-module-linking.md`](https://github.com/codelovesme/code/blob/main/docs/todo/native-module-linking.md)
+  for why `.wasm`/JS modules are the wasm32 answer to what `.so`/`.a` are
+  natively.
 
 ## Releasing (maintainers)
 
@@ -121,6 +166,18 @@ anywhere. The workflow exchanges a short-lived GitHub OIDC token for a
 short-lived npm publish credential at publish time; there's no
 long-lived secret to leak or rotate.
 
+`code-wasm` on npm already has `0.1.0`/`0.1.1` published under this same
+repo, from the *old* language (a different API entirely —
+`run_source`/structured `{ok, bindings, diagnostics}`, superseded here by
+plain `run`/`run_with_modules` string results). That's why this package
+starts at `1.0.0` rather than continuing the `0.1.x` line: a real API
+break deserves a major bump, not a version someone's `^0.1.0` pin would
+silently accept. If the old repo's Trusted Publisher was already
+configured for this exact package name + repo + workflow filename, the
+one-time npm-side setup below is likely already done — check the
+package's **Settings → Trusted Publisher** page on npmjs.com before
+redoing it.
+
 **One-time setup (can't be done from CI — this is npmjs.com account
 configuration, done once by whoever's publishing this the first time):**
 
@@ -160,12 +217,12 @@ source of truth for what's being published, rather than trusting a
 hand-edited `package.json` matches), builds, smoke-tests the actual
 packaged artifact, and publishes with `--provenance`. Bump the version
 deliberately — this JS API is a public contract the moment it's
-published (see the T19 ticket in the main repo).
+published.
 
 `workflow_dispatch` (the "Run workflow" button in the Actions tab) does
 everything except the actual publish — a real dry run against the exact
 package that would ship, not a separate code path. To test locally
-before tagging:
+before tagging (already verified once while building this):
 
 ```bash
 bash build.sh                # builds dist/ from the current Rust source

package/dist/code_wasm.d.ts

@@ -2,18 +2,45 @@
 /* eslint-disable */
 
 /**
- * Run a single `.code` snippet. Returns a `RunResult` serialized to a plain
- * JS object: `{ ok, bindings, diagnostics }`.
+ * Runs `src` and returns either the bindings dump (matching `code run`'s
+ * stdout exactly, via the same `format_bindings`) or `"error: ..."` — a
+ * single string return keeps the JS side trivial for now. No module
+ * support — see `run_with_modules` for that.
  */
-export function run_source(src: string): any;
+export function run(src: string): string;
+
+/**
+ * Like `run`, but `src` may `link` any alias present as an own-enumerable
+ * key of `modules`. Each value must be a plain JS object shaped
+ * `{ dispatch(particleJson) -> resultJson, vars?() -> varsJson }` —
+ * `dispatch` is called synchronously for every `emit ... to <alias>`,
+ * `vars` (optional, called once, up front) becomes `<alias>.<name>` field
+ * access exactly like a `.so`'s exported variables
+ * (`tests/native_link_vars.code`). Both exchange plain JSON text; a module
+ * with no `vars` gets an empty object, matching `.so`'s "no
+ * `code_module_vars` export" default.
+ *
+ * Deliberately synchronous, not async: every module must already be
+ * resolvable before this call (see `PreloadedModules`) — instantiating a
+ * real `.wasm` file (`WebAssembly.instantiateStreaming`, necessarily async)
+ * is the caller's job, done before calling this, not something `link`
+ * triggers mid-run.
+ */
+export function run_with_modules(src: string, modules: object): string;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly run_source: (a: number, b: number) => number;
-    readonly __wbindgen_export: (a: number, b: number) => number;
-    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly run: (a: number, b: number) => [number, number];
+    readonly run_with_modules: (a: number, b: number, c: any) => [number, number];
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
 }
 
 export type SyncInitInput = BufferSource | WebAssembly.Module;

package/dist/code_wasm.js

@@ -1,62 +1,124 @@
 /* @ts-self-types="./code_wasm.d.ts" */
 
 /**
- * Run a single `.code` snippet. Returns a `RunResult` serialized to a plain
- * JS object: `{ ok, bindings, diagnostics }`.
+ * Runs `src` and returns either the bindings dump (matching `code run`'s
+ * stdout exactly, via the same `format_bindings`) or `"error: ..."` — a
+ * single string return keeps the JS side trivial for now. No module
+ * support — see `run_with_modules` for that.
  * @param {string} src
- * @returns {any}
+ * @returns {string}
  */
-export function run_source(src) {
-    const ptr0 = passStringToWasm0(src, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.run_source(ptr0, len0);
-    return takeObject(ret);
+export function run(src) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.run(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Like `run`, but `src` may `link` any alias present as an own-enumerable
+ * key of `modules`. Each value must be a plain JS object shaped
+ * `{ dispatch(particleJson) -> resultJson, vars?() -> varsJson }` —
+ * `dispatch` is called synchronously for every `emit ... to <alias>`,
+ * `vars` (optional, called once, up front) becomes `<alias>.<name>` field
+ * access exactly like a `.so`'s exported variables
+ * (`tests/native_link_vars.code`). Both exchange plain JSON text; a module
+ * with no `vars` gets an empty object, matching `.so`'s "no
+ * `code_module_vars` export" default.
+ *
+ * Deliberately synchronous, not async: every module must already be
+ * resolvable before this call (see `PreloadedModules`) — instantiating a
+ * real `.wasm` file (`WebAssembly.instantiateStreaming`, necessarily async)
+ * is the caller's job, done before calling this, not something `link`
+ * triggers mid-run.
+ * @param {string} src
+ * @param {object} modules
+ * @returns {string}
+ */
+export function run_with_modules(src, modules) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.run_with_modules(ptr0, len0, modules);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
 }
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
-            const ret = Error(getStringFromWasm0(arg0, arg1));
-            return addHeapObject(ret);
+        __wbg___wbindgen_debug_string_a57024b9c6e4a48b: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            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);
         },
-        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
-            throw new Error(getStringFromWasm0(arg0, arg1));
+        __wbg___wbindgen_is_function_5e4570eb24ffa122: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
         },
-        __wbg_new_32b398fb48b6d94a: function() {
-            const ret = new Array();
-            return addHeapObject(ret);
+        __wbg___wbindgen_string_get_d154f1e671052120: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_new_da52cf8fe3429cb2: function() {
-            const ret = new Object();
-            return addHeapObject(ret);
+        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
-            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+        __wbg_call_1c5886ab9c57d1c7: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_call_35dba3c747ad7521: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_get_971a0c45d172643f: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_unchecked_e20b893aeafc3fca: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
         },
-        __wbg_set_8a16b38e4805b298: function(arg0, arg1, arg2) {
-            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+        __wbg_keys_ec7f8c0c2370d91d: function(arg0) {
+            const ret = Object.keys(arg0);
+            return ret;
         },
-        __wbindgen_cast_0000000000000001: function(arg0) {
-            // Cast intrinsic for `F64 -> Externref`.
-            const ret = arg0;
-            return addHeapObject(ret);
+        __wbg_length_ecfa2c63d3d0d82c: function(arg0) {
+            const ret = arg0.length;
+            return ret;
         },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000003: function(arg0) {
-            // Cast intrinsic for `U64 -> Externref`.
-            const ret = BigInt.asUintN(64, arg0);
-            return addHeapObject(ret);
+            return ret;
         },
-        __wbindgen_object_clone_ref: function(arg0) {
-            const ret = getObject(arg0);
-            return addHeapObject(ret);
-        },
-        __wbindgen_object_drop_ref: function(arg0) {
-            takeObject(arg0);
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
         },
     };
     return {
@@ -65,19 +127,83 @@ function __wbg_get_imports() {
     };
 }
 
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
     return idx;
 }
 
-function dropObject(idx) {
-    if (idx < 1028) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
 }
 
 function getStringFromWasm0(ptr, len) {
@@ -92,12 +218,18 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-function getObject(idx) { return heap[idx]; }
-
-let heap = new Array(1024).fill(undefined);
-heap.push(undefined, null, true, false);
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
 
-let heap_next = heap.length;
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
 
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
@@ -136,12 +268,6 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
@@ -176,17 +302,23 @@ function __wbg_finalize_init(instance, module) {
     wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
+    cachedDataViewMemory0 = null;
     cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
     return wasm;
 }
 
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
             } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
+                const validResponse = expectedResponseType(module.type);
 
                 if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);

package/dist/code_wasm_bg.wasm.d.ts

@@ -1,6 +1,12 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const run_source: (a: number, b: number) => number;
-export const __wbindgen_export: (a: number, b: number) => number;
-export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const run: (a: number, b: number) => [number, number];
+export const run_with_modules: (a: number, b: number, c: any) => [number, number];
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "code-wasm",
-  "version": "0.1.0",
-  "description": "Run Code — a constraint-based programming language with no user-defined functions and no core I/O — in any browser or JS host. A small WASM bridge, zero JS dependencies.",
+  "version": "1.0.0",
+  "description": "Run Code — a language with no user-defined functions, particle emission for behavior, and browser-embeddable third-party modules — in any browser or JS host. A small WASM bridge around the language's real parser and interpreter.",
   "type": "module",
   "main": "dist/code_wasm.js",
   "module": "dist/code_wasm.js",
@@ -23,9 +23,9 @@
   "keywords": [
     "wasm",
     "webassembly",
-    "constraint-programming",
     "interpreter",
     "playground",
-    "language"
+    "language",
+    "plugins"
   ]
 }