@hazae41/bobine 0.0.2

package/LICENSE.md

@@ -0,0 +1,19 @@
+# MIT
+
+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 without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

package/README.md

@@ -0,0 +1,224 @@
+# Bobine
+
+Your neighbor's chain of compute
+
+## HTTP API
+
+### POST /api/create
+
+Creates a new module using some WebAssembly code and some unique salt
+
+Accepts a form data with the following fields
+
+- `code` as bytes = your WebAssembly code (your .wasm file)
+
+- `salt` as bytes = some bytes (any length, can be 0) that will be hashed with your code to produce your module address
+
+- `effort` as bytes = some unique 32 bytes whose sha256 `hash` validates `((2n ** 256n) / BigInt("0x" + hash.toHex())) > (code.length + salt.length)`
+
+### POST /api/execute
+
+Execute some function on a module
+
+Accepts a form data with the following fields
+
+- `module` as string = your module address (32-bytes hex)
+
+- `method` as string = WebAssembly function to be executed
+
+- `params` as bytes = WebAssembly function parameters as pack-encoded bytes (see pack encoding below)
+
+- `effort` as bytes =  some unique 32 bytes whose sha256 `hash` whose result in `((2n ** 256n) / BigInt("0x" + hash.toHex()))` will be the maximum number of sparks (gas) used
+
+### POST /api/simulate
+
+Simulate some function on a module (it won't write anything to storage and will execute in mode `2` so verifications such as signatures can be skipped)
+
+Accepts a form data with the following fields
+
+- `module` as string = your module address (32-bytes hex)
+
+- `method` as string = WebAssembly function to be executed
+
+- `params` as bytes = WebAssembly function parameters as pack-encoded bytes (see pack encoding below)
+
+- `effort` as bytes =  some unique 32 bytes whose sha256 `hash` whose result in `((2n ** 256n) / BigInt("0x" + hash.toHex()))` will be the maximum number of sparks (gas) used
+
+## WebAssembly API
+
+### <module>
+
+You can use any module method by using the module address as hex
+
+```tsx
+@external("5feeee846376f6436990aa2757bc67fbc4498bcc9993b647788e273ad6fde474", "add")
+declare function add(x: u32, y: u32): u32
+```
+
+### blobs
+
+You can pass bytes between modules by storing them in the blob storage and loading them via reference
+
+- `blobs.save(offset: u32, length: u32): blobref` = save `length` bytes at `offset` of your memory to the blob storage
+
+- `blobs.load(blob: blobref, offset: u32): void` = load some blob into your memory at `offset`
+
+- `blobs.equals(left: blobref, right: blobref): bool` = check if two blobs are equals without loading them into memory
+
+- `blobs.concat(left: blobref, right: blobref): blobref` = concatenate two blobs without loading them into memory
+
+- `blob.to_hex/from_hex/to_base64/from_base64(blob: blobref): blobref` = convert blobs to/from hex/base64 without loading them into memory
+
+### bigints
+
+You can work with infinite-precision bigints
+
+- `bigints.add(left: bigintref, right: bigintref): bigintref` = add two bigints
+
+- `bigints.sub(left: bigintref, right: bigintref): bigintref` = subtract two bigints
+
+- `bigints.mul(left: bigintref, right: bigintref): bigintref` = multiply two bigints
+
+- `bigints.div(left: bigintref, right: bigintref): bigintref` = divide two bigints
+
+- `bigints.pow(left: bigintref, right: bigintref): bigintref` = left ** right
+
+- `bigints.encode(bigint: bigintref): blobref` = convert bigint to bytes
+
+- `bigints.decode(base16: blobref): bigintref` = convert bytes to bigint
+
+- `bigints.to_base16(bigint: bigintref): blobref` = convert bigint to hex utf8 bytes
+
+- `bigints.from_base16(base16: blobref): bigintref` = convert hex utf8 bytes to bigint
+
+- `bigints.to_base10(bigint: bigintref): blobref` = convert bigint to base10 utf8 bytes
+
+- `bigints.from_base10(base16: blobref): bigintref` = convert base10 utf8 bytes to bigint
+
+### packs
+
+You can pack various arguments (numbers, refs) into a pack which can be passed between modules and/or encoded/decoded into bytes
+
+- `packs.create(...values: any[]): packref` = create a new pack from the provided values (number, blobref, packref, null)
+
+- `packs.encode(pack: packref): blobref` = encodes values into bytes using the following pseudocode
+
+```tsx
+function writePack(pack: packref) {
+  for (const value of values) {
+    if (value == null) {
+      writeUint8(1)
+      continue
+    }
+
+    if (typeof value === "number") {
+      writeUint8(2)
+      writeFloat64(value, "little-endian")
+      continue
+    }
+    
+    if (typeof value === "bigint") {
+      writeUint8(3)
+      writeUint32(value.toHex().length, "little-endian")
+      writeBytes(value.toHex())
+      continue
+    }
+
+    if (isBlobref(value)) {
+      writeUint8(4)
+      writeUint32(value.length, "little-endian")
+      writeBytes(value)
+      continue
+    }
+
+    if (isPackref(value)) {
+      writeUint8(5)
+      writePack(value)
+      continue
+    }
+
+    writeUint8(1) // anything else if encoded as null
+    continue
+  }
+
+  writeUint8(0)
+}
+```
+
+- `packs.decode(blob: blobref): packref` = decodes bytes into a pack of values using the same pseudocode but for reading
+
+- `packs.concat(left: packref, right: packref)` = concatenate two packs into one (basically does `[...left, ...right]`)
+
+- `packs.get<T>(pack: packref, index: u32): T` = get the value of a pack at `index` (throws if not found)
+
+### env
+
+Get infos about the executing environment
+
+- `env.mode: u32` = `1` if execution, `2` is simulation
+
+- `env.uuid(): blobref` = get the unique uuid of this environment (similar to a chain id)
+
+### modules
+
+Modules are identified by their address as a blob of bytes (pure sha256-output 32-length bytes without any encoding)
+
+- `modules.load(module: blobref): blobref` = get the code of module as a blob
+
+- `modules.call(module: blobref, method: blobref, params: packref): packref` = dynamically call a module method with the given params as pack and return value as a 1-length pack
+
+- `modules.create(code: blobref, salt: blobref): blobref` = dynamically create a new module with the given code and salt, returns the module address
+
+- `modules.self(): blobref` = get your module address as blob
+
+### storage
+
+You can use a private storage (it works like storage and events at the same time)
+
+- `storage.set(key: blobref, value: blobref): void` = set some value to storage at key
+
+- `storage.get(key: blobref): blobref` = get the latest value from storage at key
+
+### sha256
+
+Use the SHA-256 hashing algorithm
+
+- `sha256.digest(payload: blobref): blobref` = hash the payload and returns the digest
+
+### ed25519
+
+Use the Ed25519 signing algorithm
+
+- `ed25519.verify(pubkey: blobref, signature: blobref, payload: blobref): boolean` = verify a signature
+
+- `ed25519.sign(payload: blobref): blobref` = (experimental) sign payload using the miner's private key
+
+### symbols (experimental)
+
+- `symbols.create(): symbolref` = create a unique reference that can be passed around
+
+### refs (experimental)
+
+- `refs.numerize(ref: symbolref/blobref/packref): u32` = translate any reference into a unique private pointer that can be stored into data structures
+
+- `refs.denumerize(pointer: u32): symbolref/blobref/packref` = get the exact same reference back from your private pointer 
+
+This can be useful if you want to check a reference for authenticity
+
+```tsx
+const sessions = new Set<u32>()
+
+export function login(password: blobref): symbolref {
+  const session = symbols.create()  
+
+  sessions.put(symbols.numerize(session))
+
+  return session
+}
+
+export function verify(session: symbolref) {
+  return sessions.has(symbols.numerize(session))
+}
+```
+
+You should never accept a pointer instead of a real reference because they can be easily guessed by an attacking module

package/out/libs/database/mod.d.ts

@@ -0,0 +1 @@
+export {};

package/out/libs/database/mod.js

@@ -0,0 +1 @@
+export {};

package/out/libs/metering/mod.d.ts

@@ -0,0 +1,2 @@
+import * as Wasm from "@hazae41/wasm";
+export declare function meter(module: Wasm.Module, from: string, name: string): void;

package/out/libs/metering/mod.js

@@ -0,0 +1,46 @@
+import * as Wasm from "@hazae41/wasm";
+export function meter(module, from, name) {
+    const wtype = module.body.sections.find(section => section.kind === Wasm.TypeSection.kind);
+    const wimport = module.body.sections.find(section => section.kind === Wasm.ImportSection.kind);
+    const wexport = module.body.sections.find(section => section.kind === Wasm.ExportSection.kind);
+    const wcode = module.body.sections.find(section => section.kind === Wasm.CodeSection.kind);
+    if (wtype == null)
+        throw new Error(`No type section`);
+    if (wimport == null)
+        throw new Error(`No import section`);
+    if (wexport == null)
+        throw new Error(`No export section`);
+    if (wcode == null)
+        throw new Error(`No code section`);
+    const wstart = module.body.sections.find(section => section.kind === Wasm.StartSection.kind);
+    wtype.descriptors.push({ prefix: Wasm.TypeSection.FuncType.kind, subtypes: [], body: new Wasm.TypeSection.FuncType([0x7f], []) });
+    wimport.descriptors.unshift({ from: new TextEncoder().encode(from), name: new TextEncoder().encode(name), body: new Wasm.ImportSection.FunctionImport(wtype.descriptors.length - 1) });
+    if (wstart != null)
+        wstart.funcidx++;
+    for (const body of wcode.bodies) {
+        const instructions = new Array();
+        const subinstructions = new Array();
+        for (const instruction of body.instructions) {
+            if ([0x10, 0x12, 0xd2].includes(instruction.opcode))
+                instruction.params[0].value++;
+            if ([0x03, 0x04, 0x05, 0x0B, 0x0c, 0x0D, 0x0E, 0x0F, 0xd5, 0xd6].includes(instruction.opcode)) {
+                subinstructions.push(instruction);
+                instructions.push(new Wasm.Instruction(0x41, [new Wasm.LEB128.I32(subinstructions.length)]));
+                instructions.push(new Wasm.Instruction(0x10, [new Wasm.LEB128.U32(0)]));
+                instructions.push(...subinstructions);
+                subinstructions.length = 0;
+            }
+            else {
+                subinstructions.push(instruction);
+            }
+        }
+        instructions.push(...subinstructions);
+        body.instructions = instructions;
+        continue;
+    }
+    for (const descriptor of wexport.descriptors) {
+        if (descriptor.kind !== 0x00)
+            continue;
+        descriptor.xidx++;
+    }
+}

package/out/libs/nullable/mod.d.ts

@@ -0,0 +1 @@
+export type Nullable<T> = T | null | undefined;

package/out/libs/nullable/mod.js

@@ -0,0 +1 @@
+export {};

package/out/libs/packs/mod.d.ts

@@ -0,0 +1,11 @@
+import type { Cursor } from "@hazae41/cursor";
+export declare class Pack {
+    readonly values: Array<Pack.Value>;
+    constructor(values: Array<Pack.Value>);
+    sizeOrThrow(): number;
+    writeOrThrow(cursor: Cursor): void;
+}
+export declare namespace Pack {
+    type Value = number | bigint | Uint8Array | Pack | null;
+    function readOrThrow(cursor: Cursor): Pack;
+}

package/out/libs/packs/mod.js

@@ -0,0 +1,98 @@
+export class Pack {
+    values;
+    constructor(values) {
+        this.values = values;
+    }
+    sizeOrThrow() {
+        let size = 0;
+        for (const value of this.values) {
+            if (typeof value === "number") {
+                size += 1 + 4;
+                continue;
+            }
+            if (typeof value === "bigint") {
+                const text = value.toString(16);
+                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
+                size += 1 + 4 + data.length;
+                continue;
+            }
+            if (value instanceof Uint8Array) {
+                size += 1 + 4 + value.length;
+                continue;
+            }
+            if (value instanceof Pack) {
+                size += 1 + value.sizeOrThrow();
+                continue;
+            }
+            size += 1;
+            continue;
+        }
+        size += 1;
+        return size;
+    }
+    writeOrThrow(cursor) {
+        for (const value of this.values) {
+            if (typeof value === "number") {
+                cursor.writeUint8OrThrow(2);
+                cursor.writeFloat64OrThrow(value, true);
+                continue;
+            }
+            if (typeof value === "bigint") {
+                cursor.writeUint8OrThrow(3);
+                const text = value.toString(16);
+                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
+                cursor.writeUint32OrThrow(data.length, true);
+                cursor.writeOrThrow(data);
+                continue;
+            }
+            if (value instanceof Uint8Array) {
+                cursor.writeUint8OrThrow(4);
+                cursor.writeUint32OrThrow(value.length, true);
+                cursor.writeOrThrow(value);
+                continue;
+            }
+            if (value instanceof Pack) {
+                cursor.writeUint8OrThrow(5);
+                value.writeOrThrow(cursor);
+                continue;
+            }
+            cursor.writeUint8OrThrow(1);
+            continue;
+        }
+        cursor.writeUint8OrThrow(0);
+        return;
+    }
+}
+(function (Pack) {
+    function readOrThrow(cursor) {
+        const values = [];
+        while (true) {
+            const type = cursor.readUint8OrThrow();
+            if (type === 0)
+                break;
+            if (type === 2) {
+                values.push(cursor.readFloat64OrThrow(true));
+                continue;
+            }
+            if (type === 3) {
+                const size = cursor.readUint32OrThrow(true);
+                const data = cursor.readOrThrow(size);
+                values.push(BigInt("0x" + data.toHex()));
+                continue;
+            }
+            if (type === 4) {
+                const size = cursor.readUint32OrThrow(true);
+                values.push(cursor.readOrThrow(size));
+                continue;
+            }
+            if (type === 5) {
+                values.push(Pack.readOrThrow(cursor));
+                continue;
+            }
+            values.push(null);
+            continue;
+        }
+        return new Pack(values);
+    }
+    Pack.readOrThrow = readOrThrow;
+})(Pack || (Pack = {}));

package/out/libs/sql/mod.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from "@tursodatabase/database";
+export declare function runAsImmediateOrThrow<T>(database: Database, callback: (database: Database) => Promise<T>): Promise<T>;
+export declare function runAsDeferredOrThrow<T>(database: Database, callback: (database: Database) => Promise<T>): Promise<T>;

package/out/libs/sql/mod.js

@@ -0,0 +1,24 @@
+export async function runAsImmediateOrThrow(database, callback) {
+    await database.exec("BEGIN IMMEDIATE TRANSACTION;");
+    try {
+        const result = await callback(database);
+        await database.exec("COMMIT;");
+        return result;
+    }
+    catch (e) {
+        await database.exec("ROLLBACK;");
+        throw e;
+    }
+}
+export async function runAsDeferredOrThrow(database, callback) {
+    await database.exec("BEGIN DEFERRED TRANSACTION;");
+    try {
+        const result = await callback(database);
+        await database.exec("COMMIT;");
+        return result;
+    }
+    catch (e) {
+        await database.exec("ROLLBACK;");
+        throw e;
+    }
+}

package/out/mod.d.ts

@@ -0,0 +1 @@
+export * from "./mods/mod.ts";

package/out/mod.js

@@ -0,0 +1 @@
+export * from "./mods/mod.js";

package/out/mods/helper/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/out/mods/helper/bin.js

@@ -0,0 +1,75 @@
+import { RpcMethodNotFoundError } from "@hazae41/jsonrpc";
+import { connect } from "@tursodatabase/database";
+import { runAsImmediateOrThrow } from "../../libs/sql/mod.js";
+const params = new URL(import.meta.url).searchParams;
+const database = await connect(params.get("database"));
+self.addEventListener("message", async (event) => {
+    try {
+        const request = event.data;
+        if (request.method === "storage_set") {
+            return await runAsImmediateOrThrow(database, async (database) => {
+                const [module, method, args, events] = event.data.params;
+                const moment = await database.prepare(`INSERT INTO moments (epoch, module, method, params) VALUES (0, ?, ?, ?);`).run(module, method, args);
+                const writer = database.prepare(`INSERT INTO events (moment, module, key, value) VALUES (?, ?, ?, ?);`);
+                for (const [module, key, value] of events)
+                    await writer.run(moment.lastInsertRowid, module, key, value);
+                request.result[0] = 1;
+                request.result[1] = moment.lastInsertRowid;
+                Atomics.notify(request.result, 0);
+                return;
+            });
+        }
+        if (request.method === "storage_get") {
+            const [module, key] = request.params;
+            const row = await database.prepare(`SELECT value FROM events event WHERE event.module = ? AND event.key = ? ORDER BY event.nonce DESC LIMIT 1;`).get(module, key);
+            if (row == null) {
+                request.result[0] = 1;
+                request.result[1] = 2;
+                Atomics.notify(request.result, 0);
+                return;
+            }
+            const valueAsBytes = new Uint8Array(row.value);
+            request.result[0] = 1;
+            request.result[1] = 1;
+            request.result[2] = valueAsBytes.length;
+            request.result.buffer.grow(request.result.buffer.byteLength + valueAsBytes.length);
+            new Uint8Array(request.result.buffer).set(valueAsBytes, 4 + 4 + 4);
+            Atomics.notify(request.result, 0);
+            return;
+        }
+        if (request.method === "sha256_digest") {
+            const [payloadAsBytes] = request.params;
+            const digestAsBytes = new Uint8Array(await crypto.subtle.digest("SHA-256", payloadAsBytes));
+            request.result[0] = 1;
+            new Uint8Array(request.result.buffer).set(digestAsBytes, 4);
+            Atomics.notify(request.result, 0);
+            return;
+        }
+        if (request.method === "ed25519_verify") {
+            const [pubkeyAsBytes, signatureAsBytes, payloadAsBytes] = request.params;
+            const pubkeyAsKey = await crypto.subtle.importKey("raw", pubkeyAsBytes, "Ed25519", true, ["verify"]);
+            const verified = await crypto.subtle.verify("Ed25519", pubkeyAsKey, signatureAsBytes, payloadAsBytes);
+            request.result[0] = 1;
+            request.result[1] = verified ? 1 : 0;
+            Atomics.notify(request.result, 0);
+            return;
+        }
+        if (request.method === "ed25519_sign") {
+            const [privkeyAsBytes, payloadAsBytes] = request.params;
+            const privkeyAsKey = await crypto.subtle.importKey("pkcs8", privkeyAsBytes, "Ed25519", false, ["sign"]);
+            const signatureAsBytes = new Uint8Array(await crypto.subtle.sign("Ed25519", privkeyAsKey, payloadAsBytes));
+            request.result[0] = 1;
+            new Uint8Array(request.result.buffer).set(signatureAsBytes, 4);
+            Atomics.notify(request.result, 0);
+            return;
+        }
+        throw new RpcMethodNotFoundError();
+    }
+    catch (error) {
+        const request = event.data;
+        console.error(error);
+        request.result[0] = 2;
+        Atomics.notify(request.result, 0);
+        return;
+    }
+});

package/out/mods/mod.d.ts

@@ -0,0 +1 @@
+export * from "./server/mod.ts";

package/out/mods/mod.js

@@ -0,0 +1 @@
+export * from "./server/mod.js";

package/out/mods/server/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/out/mods/server/bin.js

@@ -0,0 +1,34 @@
+import { readFileSync } from "node:fs";
+import process from "node:process";
+import { serveWithEnv } from "./mod.js";
+const { PORT = process.env.PORT || "8080", CERT = process.env.CERT, KEY = process.env.KEY, } = process.env;
+const port = Number(PORT);
+const cert = CERT != null ? readFileSync(CERT, "utf8") : undefined;
+const key = KEY != null ? readFileSync(KEY, "utf8") : undefined;
+const server = await serveWithEnv();
+const route = async (request) => {
+    if (request.method === "OPTIONS")
+        return new Response(null, { status: 204 });
+    if (request.headers.get("Upgrade") === "websocket") {
+        const { socket, response } = Deno.upgradeWebSocket(request);
+        await server.onWebSocketRequest(request, socket);
+        return response;
+    }
+    return await server.onHttpRequest(request);
+};
+const onHttpRequest = async (request) => {
+    try {
+        const response = await route(request);
+        if (response.status === 101)
+            return response;
+        response.headers.set("Access-Control-Allow-Origin", "*");
+        response.headers.set("Access-Control-Allow-Methods", "*");
+        response.headers.set("Access-Control-Allow-Headers", "*");
+        return response;
+    }
+    catch (cause) {
+        console.error(cause);
+        return new Response("Error", { status: 500 });
+    }
+};
+Deno.serve({ hostname: "0.0.0.0", port, cert, key }, onHttpRequest);

package/out/mods/server/mod.d.ts

@@ -0,0 +1,8 @@
+export declare function serveWithEnv(prefix?: string): Promise<{
+    onHttpRequest(request: Request): Promise<Response>;
+    onWebSocketRequest(request: Request, socket: WebSocket): Promise<void>;
+}>;
+export declare function serve(databaseAsPath: string, scriptsAsPath: string, ed25519PrivateKeyAsHex: string, ed25519PublicKeyAsHex: string): Promise<{
+    onHttpRequest(request: Request): Promise<Response>;
+    onWebSocketRequest(request: Request, socket: WebSocket): Promise<void>;
+}>;

package/out/mods/server/mod.js

@@ -0,0 +1,299 @@
+// deno-lint-ignore-file no-cond-assign no-unused-vars require-await
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { Writable } from "@hazae41/binary";
+import { RpcRequest, RpcResponse } from "@hazae41/jsonrpc";
+import { Mutex } from "@hazae41/mutex";
+import { connect } from "@tursodatabase/database";
+import { existsSync, mkdirSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import process from "node:process";
+import { Pack } from "../../libs/packs/mod.js";
+export async function serveWithEnv(prefix = "") {
+    const { DATABASE_PATH = process.env[prefix + "DATABASE_PATH"], SCRIPTS_PATH = process.env[prefix + "SCRIPTS_PATH"], ED25519_PRIVATE_KEY_HEX = process.env[prefix + "ED25519_PRIVATE_KEY_HEX"], ED25519_PUBLIC_KEY_HEX = process.env[prefix + "ED25519_PUBLIC_KEY_HEX"], } = {};
+    if (DATABASE_PATH == null)
+        throw new Error("DATABASE_PATH is not set");
+    if (SCRIPTS_PATH == null)
+        throw new Error("SCRIPTS_PATH is not set");
+    if (ED25519_PRIVATE_KEY_HEX == null)
+        throw new Error("ED25519_PRIVATE_KEY_HEX is not set");
+    if (ED25519_PUBLIC_KEY_HEX == null)
+        throw new Error("ED25519_PUBLIC_KEY_HEX is not set");
+    mkdirSync(dirname(DATABASE_PATH), { recursive: true });
+    return await serve(DATABASE_PATH, SCRIPTS_PATH, ED25519_PRIVATE_KEY_HEX, ED25519_PUBLIC_KEY_HEX);
+}
+export async function serve(databaseAsPath, scriptsAsPath, ed25519PrivateKeyAsHex, ed25519PublicKeyAsHex) {
+    const database = await connect(databaseAsPath);
+    await database.exec(`CREATE TABLE IF NOT EXISTS events (
+    nonce INTEGER PRIMARY KEY AUTOINCREMENT,
+
+    moment INTEGER NOT NULL,
+
+    module TEXT NOT NULL,
+    
+    key BLOB NOT NULL,
+    value BLOB NOT NULL
+  );`);
+    await database.exec(`CREATE TABLE IF NOT EXISTS moments (
+    nonce INTEGER PRIMARY KEY AUTOINCREMENT,
+    
+    epoch INTEGER NOT NULL,
+
+    module TEXT NOT NULL,
+    method TEXT NOT NULL,
+    params BLOB NOT NULL
+  );`);
+    await database.close();
+    mkdirSync(scriptsAsPath, { recursive: true });
+    const setOfEffortsAsHex = new Set();
+    const worker = new Mutex(new Worker(import.meta.resolve(`@/mods/worker/bin.ts?database=${databaseAsPath}&scripts=${scriptsAsPath}&ed25519PrivateKeyAsHex=${ed25519PrivateKeyAsHex}&ed25519PublicKeyAsHex=${ed25519PublicKeyAsHex}`), { name: "worker", type: "module" }));
+    const onHttpRequest = async (request) => {
+        let match;
+        if (match = new URLPattern("/api/create", request.url).exec(request.url)) {
+            if (request.method === "POST") {
+                const form = await request.formData();
+                const wasmAsEntry = form.get("code");
+                if (wasmAsEntry == null)
+                    return Response.json(null, { status: 400 });
+                if (typeof wasmAsEntry === "string")
+                    return Response.json(null, { status: 400 });
+                const wasmAsBytes = await wasmAsEntry.bytes();
+                const saltAsEntry = form.get("salt");
+                if (saltAsEntry == null)
+                    return Response.json(null, { status: 400 });
+                if (typeof saltAsEntry === "string")
+                    return Response.json(null, { status: 400 });
+                const saltAsBytes = await saltAsEntry.bytes();
+                const effortAsEntry = form.get("effort");
+                if (effortAsEntry == null)
+                    return Response.json(null, { status: 400 });
+                if (typeof effortAsEntry === "string")
+                    return Response.json(null, { status: 400 });
+                const effortAsBytes = await effortAsEntry.bytes();
+                if (effortAsBytes.length !== 32)
+                    return Response.json(null, { status: 400 });
+                const effortAsHex = effortAsBytes.toHex();
+                if (setOfEffortsAsHex.has(effortAsHex))
+                    return Response.json(null, { status: 402 });
+                setOfEffortsAsHex.add(effortAsHex);
+                const sparksAsBigInt = (2n ** 256n) / BigInt("0x" + new Uint8Array(await crypto.subtle.digest("SHA-256", effortAsBytes)).toHex());
+                if (sparksAsBigInt < (wasmAsBytes.length + saltAsBytes.length))
+                    return Response.json(null, { status: 402 });
+                const packAsBytes = Writable.writeToBytesOrThrow(new Pack([wasmAsBytes, saltAsBytes]));
+                const digestOfWasmAsBytes = new Uint8Array(await crypto.subtle.digest("SHA-256", wasmAsBytes));
+                const digestOfPackAsBytes = new Uint8Array(await crypto.subtle.digest("SHA-256", packAsBytes));
+                const digestOfWasmAsHex = digestOfWasmAsBytes.toHex();
+                const digestOfPackAsHex = digestOfPackAsBytes.toHex();
+                if (!existsSync(`${scriptsAsPath}/${digestOfWasmAsHex}.wasm`))
+                    writeFileSync(`${scriptsAsPath}/${digestOfWasmAsHex}.wasm`, wasmAsBytes);
+                if (!existsSync(`${scriptsAsPath}/${digestOfPackAsHex}.wasm`))
+                    symlinkSync(`./${digestOfWasmAsHex}.wasm`, `${scriptsAsPath}/${digestOfPackAsHex}.wasm`);
+                return Response.json(digestOfPackAsHex);
+            }
+            return Response.json(null, { status: 405, headers: { "Allow": "POST" } });
+        }
+        if (match = new URLPattern("/api/execute", request.url).exec(request.url)) {
+            if (request.method === "POST") {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const stack = __addDisposableResource(env_1, new DisposableStack(), false);
+                    const form = await request.formData();
+                    const moduleAsEntry = form.get("module");
+                    if (moduleAsEntry == null)
+                        return Response.json(null, { status: 400 });
+                    if (typeof moduleAsEntry !== "string")
+                        return Response.json(null, { status: 400 });
+                    const methodAsEntry = form.get("method");
+                    if (methodAsEntry == null)
+                        return Response.json(null, { status: 400 });
+                    if (typeof methodAsEntry !== "string")
+                        return Response.json(null, { status: 400 });
+                    const paramsAsEntry = form.get("params");
+                    if (paramsAsEntry == null)
+                        return Response.json(null, { status: 400 });
+                    if (typeof paramsAsEntry === "string")
+                        return Response.json(null, { status: 400 });
+                    const paramsAsBytes = await paramsAsEntry.bytes();
+                    const effortAsEntry = form.get("effort");
+                    if (effortAsEntry == null)
+                        return Response.json(null, { status: 400 });
+                    if (typeof effortAsEntry === "string")
+                        return Response.json(null, { status: 400 });
+                    const effortAsBytes = await effortAsEntry.bytes();
+                    if (effortAsBytes.length !== 32)
+                        return Response.json(null, { status: 400 });
+                    const effortAsHex = effortAsBytes.toHex();
+                    if (setOfEffortsAsHex.has(effortAsHex))
+                        return Response.json(null, { status: 402 });
+                    setOfEffortsAsHex.add(effortAsHex);
+                    const sparksAsBigInt = (2n ** 256n) / BigInt("0x" + new Uint8Array(await crypto.subtle.digest("SHA-256", effortAsBytes)).toHex());
+                    const future = Promise.withResolvers();
+                    const aborter = new AbortController();
+                    stack.defer(() => aborter.abort());
+                    stack.use(await worker.lockOrWait());
+                    worker.get().addEventListener("message", (event) => {
+                        RpcResponse.from(event.data).inspectSync(future.resolve).inspectErrSync(future.reject);
+                    }, { signal: aborter.signal });
+                    worker.get().addEventListener("error", (event) => {
+                        future.reject(event.error);
+                    }, { signal: aborter.signal });
+                    worker.get().addEventListener("messageerror", (event) => {
+                        future.reject(event.data);
+                    }, { signal: aborter.signal });
+                    AbortSignal.timeout(1000).addEventListener("abort", (reason) => {
+                        future.reject(reason);
+                    }, { signal: aborter.signal });
+                    worker.get().postMessage(new RpcRequest(null, "execute", [moduleAsEntry, methodAsEntry, paramsAsBytes, sparksAsBigInt]));
+                    return new Response(await future.promise);
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_1);
+                }
+            }
+            return Response.json(null, { status: 405, headers: { "Allow": "POST" } });
+        }
+        if (match = new URLPattern("/api/simulate", request.url).exec(request.url)) {
+            if (request.method === "POST") {
+                const env_2 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const stack = __addDisposableResource(env_2, new DisposableStack(), false);
+                    const form = await request.formData();
+                    const moduleAsEntry = form.get("module");
+                    if (moduleAsEntry == null)
+                        return Response.json(null, { status: 400 });
+                    if (typeof moduleAsEntry !== "string")
+                        return Response.json(null, { status: 400 });
+                    const methodAsEntry = form.get("method");
+                    if (methodAsEntry == null)
+                        return Response.json(null, { status: 400 });
+                    if (typeof methodAsEntry !== "string")
+                        return Response.json(null, { status: 400 });
+                    const paramsAsEntry = form.get("params");
+                    if (paramsAsEntry == null)
+                        return Response.json(null, { status: 400 });
+                    if (typeof paramsAsEntry === "string")
+                        return Response.json(null, { status: 400 });
+                    const paramsAsBytes = await paramsAsEntry.bytes();
+                    const effortAsEntry = form.get("effort");
+                    if (effortAsEntry == null)
+                        return Response.json(null, { status: 400 });
+                    if (typeof effortAsEntry === "string")
+                        return Response.json(null, { status: 400 });
+                    const effortAsBytes = await effortAsEntry.bytes();
+                    if (effortAsBytes.length !== 32)
+                        return Response.json(null, { status: 400 });
+                    const effortAsHex = effortAsBytes.toHex();
+                    if (setOfEffortsAsHex.has(effortAsHex))
+                        return Response.json(null, { status: 402 });
+                    setOfEffortsAsHex.add(effortAsHex);
+                    const sparksAsBigInt = (2n ** 256n) / BigInt("0x" + new Uint8Array(await crypto.subtle.digest("SHA-256", effortAsBytes)).toHex());
+                    const future = Promise.withResolvers();
+                    const aborter = new AbortController();
+                    stack.defer(() => aborter.abort());
+                    stack.use(await worker.lockOrWait());
+                    worker.get().addEventListener("message", (event) => {
+                        RpcResponse.from(event.data).inspectSync(future.resolve).inspectErrSync(future.reject);
+                    }, { signal: aborter.signal });
+                    worker.get().addEventListener("error", (event) => {
+                        future.reject(event.error);
+                    }, { signal: aborter.signal });
+                    worker.get().addEventListener("messageerror", (event) => {
+                        future.reject(event.data);
+                    }, { signal: aborter.signal });
+                    AbortSignal.timeout(1000).addEventListener("abort", (reason) => {
+                        future.reject(reason);
+                    }, { signal: aborter.signal });
+                    worker.get().postMessage(new RpcRequest(null, "simulate", [moduleAsEntry, methodAsEntry, paramsAsBytes, sparksAsBigInt]));
+                    return new Response(await future.promise);
+                }
+                catch (e_2) {
+                    env_2.error = e_2;
+                    env_2.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_2);
+                }
+            }
+            return Response.json(null, { status: 405, headers: { "Allow": "POST" } });
+        }
+        return Response.json(null, { status: 404 });
+    };
+    const onWebSocketRequest = async (request, socket) => {
+        const routeOrThrow = (_message) => {
+            return;
+        };
+        const handleOrClose = async (request) => {
+            try {
+                if (!request)
+                    return;
+                const response = await routeOrThrow(request);
+                if (response == null)
+                    return;
+                socket.send(JSON.stringify(response));
+            }
+            catch {
+                socket.close();
+            }
+        };
+        socket.addEventListener("message", async (event) => {
+            if (typeof event.data !== "string")
+                return;
+            return await handleOrClose(event.data);
+        });
+    };
+    return { onHttpRequest, onWebSocketRequest };
+}

package/out/mods/worker/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/out/mods/worker/bin.js

@@ -0,0 +1,351 @@
+// deno-lint-ignore-file no-explicit-any no-unused-vars ban-unused-ignore
+import { Readable, Writable } from "@hazae41/binary";
+import { RpcErr, RpcError, RpcMethodNotFoundError, RpcOk } from "@hazae41/jsonrpc";
+import * as Wasm from "@hazae41/wasm";
+import { Buffer } from "node:buffer";
+import { existsSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
+import { meter } from "../../libs/metering/mod.js";
+import { Pack } from "../../libs/packs/mod.js";
+const params = new URL(import.meta.url).searchParams;
+const scriptsAsPath = params.get("scripts");
+const ed25519PrivkeyAsHex = params.get("ed25519PrivateKeyAsHex");
+const ed25519PrivkeyAsBytes = Uint8Array.fromHex(ed25519PrivkeyAsHex);
+const helper = new Worker(import.meta.resolve(`@/mods/helper/bin.ts?${params.toString()}`), { type: "module" });
+function run(module, method, params, mode, maxsparks) {
+    let sparks = 0n;
+    const exports = {};
+    const caches = new Map();
+    const writes = new Array();
+    const pack_encode = (pack) => {
+        return Writable.writeToBytesOrThrow(pack);
+    };
+    const pack_decode = (bytes) => {
+        return Readable.readFromBytesOrThrow(Pack, bytes);
+    };
+    const sparks_consume = (amount) => {
+        sparks += amount;
+        if (maxsparks != null && sparks > maxsparks)
+            throw new Error("Out of sparks");
+        return;
+    };
+    const sha256_digest = (payload) => {
+        sparks_consume(BigInt(payload.length) * 256n);
+        const result = new Int32Array(new SharedArrayBuffer(4 + 32));
+        helper.postMessage({ method: "sha256_digest", params: [payload], result });
+        if (Atomics.wait(result, 0, 0) !== "ok")
+            throw new Error("Failed to wait");
+        if (result[0] === 2)
+            throw new Error("Internal error");
+        return new Uint8Array(result.buffer, 4, 32).slice();
+    };
+    const ed25519_verify = (pubkey, signature, payload) => {
+        sparks_consume(BigInt(payload.length) * 256n);
+        const result = new Int32Array(new SharedArrayBuffer(4 + 4));
+        helper.postMessage({ method: "ed25519_verify", params: [pubkey, signature, payload], result });
+        if (Atomics.wait(result, 0, 0) !== "ok")
+            throw new Error("Failed to wait");
+        if (result[0] === 2)
+            throw new Error("Internal error");
+        return result[1] === 1;
+    };
+    const ed25519_sign = (subpayload) => {
+        sparks_consume(BigInt(subpayload.length) * 256n);
+        const payload = pack_encode(new Pack([Uint8Array.fromHex(module), subpayload]));
+        const result = new Int32Array(new SharedArrayBuffer(4 + 64));
+        helper.postMessage({ method: "ed25519_sign", params: [ed25519PrivkeyAsBytes, payload], result });
+        if (Atomics.wait(result, 0, 0) !== "ok")
+            throw new Error("Failed to wait");
+        if (result[0] === 2)
+            throw new Error("Internal error");
+        return new Uint8Array(result.buffer, 4, 64).slice();
+    };
+    const load = (module) => {
+        const current = {};
+        caches.set(module, new Map());
+        const imports = {};
+        imports["env"] = {
+            mode: mode,
+            abort: () => {
+                throw new Error("Aborted");
+            },
+            uuid: () => {
+                return Uint8Array.fromHex("8a8f19d1de0e4fcd9ab15cd7ed5de6dd");
+            }
+        };
+        imports["sparks"] = {
+            remaining: () => {
+                return sparks;
+            },
+            consume: (amount) => {
+                sparks_consume(BigInt(amount >>> 0));
+            }
+        };
+        imports["console"] = {
+            log: (blob) => {
+                console.log(new TextDecoder().decode(blob));
+            }
+        };
+        imports["blobs"] = {
+            save: (offset, length) => {
+                const { memory } = current.instance.exports;
+                const view = new Uint8Array(memory.buffer, offset >>> 0, length >>> 0);
+                return view.slice();
+            },
+            size: (blob) => {
+                return blob.length;
+            },
+            load: (blob, offset) => {
+                const { memory } = current.instance.exports;
+                const view = new Uint8Array(memory.buffer, offset >>> 0, blob.length);
+                view.set(blob);
+            },
+            concat: (left, right) => {
+                const concat = new Uint8Array(left.length + right.length);
+                concat.set(left, 0);
+                concat.set(right, left.length);
+                return concat;
+            },
+            equals: (left, right) => {
+                return !Buffer.compare(left, right);
+            },
+            from_base16: (text) => {
+                return Uint8Array.fromHex(new TextDecoder().decode(text));
+            },
+            from_base64: (text) => {
+                return Uint8Array.fromBase64(new TextDecoder().decode(text));
+            },
+            to_base16: (bytes) => {
+                return new TextEncoder().encode(bytes.toHex());
+            },
+            to_base64: (bytes) => {
+                return new TextEncoder().encode(bytes.toBase64());
+            }
+        };
+        imports["bigints"] = {
+            add: (left, right) => {
+                return left + right;
+            },
+            sub: (left, right) => {
+                return left - right;
+            },
+            mul: (left, right) => {
+                return left * right;
+            },
+            div: (left, right) => {
+                return left / right;
+            },
+            pow: (left, right) => {
+                return left ** right;
+            },
+            encode: (bigint) => {
+                const text = bigint.toString(16);
+                const data = Uint8Array.fromHex(text.length % 2 === 1 ? "0" + text : text);
+                return data;
+            },
+            decode: (bytes) => {
+                return BigInt("0x" + bytes.toHex());
+            },
+            from_base16: (text) => {
+                return BigInt("0x" + new TextDecoder().decode(text));
+            },
+            to_base16: (bigint) => {
+                return new TextEncoder().encode(bigint.toString(16));
+            },
+            from_base10: (text) => {
+                return BigInt(new TextDecoder().decode(text));
+            },
+            to_base10: (bigint) => {
+                return new TextEncoder().encode(bigint.toString());
+            }
+        };
+        imports["symbols"] = {
+            create: () => {
+                return Symbol();
+            }
+        };
+        const refs = new Array();
+        const ptrs = new Map();
+        imports["refs"] = {
+            numerize: (ref) => {
+                const stale = ptrs.get(ref);
+                if (stale != null)
+                    return stale;
+                const fresh = refs.push(ref) - 1;
+                ptrs.set(ref, fresh);
+                return fresh;
+            },
+            denumerize: (ptr) => {
+                const ref = refs.at(ptr >>> 0);
+                if (ref == null)
+                    throw new Error("Not found");
+                return ref;
+            }
+        };
+        imports["modules"] = {
+            create: (wasmAsBytes, saltAsBytes) => {
+                const packAsBytes = pack_encode(new Pack([wasmAsBytes, saltAsBytes]));
+                const digestOfWasmAsBytes = sha256_digest(wasmAsBytes);
+                const digestOfPackAsBytes = sha256_digest(packAsBytes);
+                const digestOfWasmAsHex = digestOfWasmAsBytes.toHex();
+                const digestOfPackAsHex = digestOfPackAsBytes.toHex();
+                if (!existsSync(`${scriptsAsPath}/${digestOfWasmAsHex}.wasm`))
+                    writeFileSync(`${scriptsAsPath}/${digestOfWasmAsHex}.wasm`, wasmAsBytes);
+                if (!existsSync(`${scriptsAsPath}/${digestOfPackAsHex}.wasm`))
+                    symlinkSync(`./${digestOfWasmAsHex}.wasm`, `${scriptsAsPath}/${digestOfPackAsHex}.wasm`, "file");
+                return digestOfPackAsBytes;
+            },
+            call: (moduleAsBytes, methodAsBytes, paramsAsPack) => {
+                const moduleAsString = moduleAsBytes.toHex();
+                const methodAsString = new TextDecoder().decode(methodAsBytes);
+                if (exports[moduleAsString] == null)
+                    load(moduleAsString);
+                if (typeof exports[moduleAsString][methodAsString] !== "function")
+                    throw new Error("Not found");
+                return new Pack([exports[moduleAsString][methodAsString](...paramsAsPack.values)]);
+            },
+            load: (moduleAsBytes) => {
+                return readFileSync(`${scriptsAsPath}/${moduleAsBytes.toHex()}.wasm`);
+            },
+            self: () => {
+                return Uint8Array.fromHex(module);
+            }
+        };
+        imports["sha256"] = {
+            digest: (payload) => {
+                return sha256_digest(payload);
+            }
+        };
+        imports["ed25519"] = {
+            verify: (pubkey, signature, payload) => {
+                return ed25519_verify(pubkey, signature, payload);
+            },
+            sign: (payload) => {
+                return ed25519_sign(payload);
+            }
+        };
+        imports["packs"] = {
+            create: (...values) => {
+                return new Pack(values);
+            },
+            concat: (left, right) => {
+                return new Pack([...left.values, ...right.values]);
+            },
+            length: (pack) => {
+                return pack.values.length;
+            },
+            get(pack, index) {
+                const value = pack.values[index >>> 0];
+                if (value === undefined)
+                    throw new Error("Not found");
+                return value;
+            },
+            encode: (pack) => {
+                return pack_encode(pack);
+            },
+            decode: (blob) => {
+                return pack_decode(blob);
+            }
+        };
+        imports["storage"] = {
+            set: (key, value) => {
+                const cache = caches.get(module);
+                cache.set(key, value);
+                writes.push([module, key, value]);
+                return;
+            },
+            get: (key) => {
+                const cache = caches.get(module);
+                const stale = cache.get(key);
+                if (stale != null)
+                    return stale;
+                const result = new Int32Array(new SharedArrayBuffer(4 + 4 + 4, { maxByteLength: ((4 + 4 + 4) + (1024 * 1024)) }));
+                helper.postMessage({ method: "storage_get", params: [module, key], result });
+                if (Atomics.wait(result, 0, 0) !== "ok")
+                    throw new Error("Failed to wait");
+                if (result[0] === 2)
+                    throw new Error("Internal error");
+                if (result[1] === 2)
+                    return null;
+                const fresh = new Uint8Array(result.buffer, 4 + 4 + 4, result[2]).slice();
+                cache.set(key, fresh);
+                return fresh;
+            }
+        };
+        let meteredWasmAsBytes;
+        if (!existsSync(`${scriptsAsPath}/${module}.metered.wasm`)) {
+            const wasmAsBytes = readFileSync(`${scriptsAsPath}/${module}.wasm`);
+            const wasmAsParsed = Readable.readFromBytesOrThrow(Wasm.Module, wasmAsBytes);
+            meter(wasmAsParsed, "sparks", "consume");
+            meteredWasmAsBytes = Writable.writeToBytesOrThrow(wasmAsParsed);
+            writeFileSync(`${scriptsAsPath}/${module}.metered.wasm`, meteredWasmAsBytes);
+        }
+        else {
+            meteredWasmAsBytes = readFileSync(`${scriptsAsPath}/${module}.metered.wasm`);
+        }
+        const meteredWasmAsModule = new WebAssembly.Module(meteredWasmAsBytes);
+        for (const descriptor of WebAssembly.Module.imports(meteredWasmAsModule)) {
+            if (imports[descriptor.module] != null) {
+                // NOOP
+                continue;
+            }
+            if (exports[descriptor.module] != null) {
+                imports[descriptor.module] = exports[descriptor.module];
+                continue;
+            }
+            const { instance } = load(descriptor.module);
+            imports[descriptor.module] = instance.exports;
+            continue;
+        }
+        const meteredWasmAsInstance = new WebAssembly.Instance(meteredWasmAsModule, imports);
+        current.instance = meteredWasmAsInstance;
+        current.module = meteredWasmAsModule;
+        exports[module] = meteredWasmAsInstance.exports;
+        return current;
+    };
+    const { instance } = load(module);
+    if (typeof instance.exports[method] !== "function")
+        throw new Error("Not found");
+    const result = pack_encode(new Pack([instance.exports[method](...pack_decode(params).values)]));
+    return { result, writes, sparks };
+}
+self.addEventListener("message", (event) => {
+    try {
+        const request = event.data;
+        if (request.method === "execute") {
+            const [module, method, params, maxsparks] = request.params;
+            const start = performance.now();
+            const { result, writes, sparks } = run(module, method, params, 1, maxsparks);
+            const until = performance.now();
+            console.log(`Evaluated ${(until - start).toFixed(2)}ms with ${sparks} sparks`);
+            if (writes.length) {
+                const result = new Int32Array(new SharedArrayBuffer(4 + 4));
+                helper.postMessage({ method: "storage_set", params: [module, method, params, writes], result });
+                if (Atomics.wait(result, 0, 0) !== "ok")
+                    throw new Error("Failed to wait");
+                if (result[0] === 2)
+                    throw new Error("Internal error");
+                console.log(`Wrote ${writes.length} events to storage`);
+            }
+            self.postMessage(new RpcOk(request.id, result));
+            return;
+        }
+        if (request.method === "simulate") {
+            const [module, method, params, maxsparks] = request.params;
+            const start = performance.now();
+            const { result, sparks } = run(module, method, params, 2, maxsparks);
+            const until = performance.now();
+            console.log(`Evaluated ${(until - start).toFixed(2)}ms with ${sparks} sparks`);
+            self.postMessage(new RpcOk(request.id, result));
+            return;
+        }
+        if (request.method === "verify") {
+            // TODO
+        }
+        throw new RpcMethodNotFoundError();
+    }
+    catch (cause) {
+        const request = event.data;
+        console.error(cause);
+        self.postMessage(new RpcErr(request.id, RpcError.rewrap(cause)));
+    }
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "type": "module",
+  "name": "@hazae41/bobine",
+  "version": "0.0.2",
+  "description": "Your neighbor's chain of compute",
+  "repository": "github:hazae41/bobine",
+  "author": "hazae41",
+  "license": "MIT",
+  "scripts": {
+    "examine": "deno lint ./src && deno check ./src && deno test -R ./src",
+    "version": "deno -RW ./x.vsync.ts && git add deno.json",
+    "prepare": "deno -RW ./x.dsync.ts && deno install",
+    "prepack": "rm -rf ./out && tsc && tscousin",
+    "develop": "deno --env-file=./.env.local -A ./src/mods/server/bin.ts"
+  },
+  "files": [
+    "./out"
+  ],
+  "exports": {
+    ".": {
+      "types": "./out/mod.d.ts",
+      "import": "./out/mod.js"
+    },
+    "./worker": {
+      "types": "./out/mods/worker/bin.d.ts",
+      "import": "./out/mods/worker/bin.js"
+    },
+    "./helper": {
+      "types": "./out/mods/helper/bin.d.ts",
+      "import": "./out/mods/helper/bin.js"
+    }
+  },
+  "dependencies": {
+    "@hazae41/binary": "^2.0.2",
+    "@hazae41/cursor": "^2.1.3",
+    "@hazae41/jsonrpc": "^1.1.11",
+    "@hazae41/mutex": "^3.0.1",
+    "@hazae41/wasm": "^1.0.0",
+    "@tursodatabase/database": "^0.3.2"
+  },
+  "devDependencies": {
+    "@hazae41/phobos": "^2.0.16",
+    "@hazae41/tscousin": "^1.0.28",
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "jsonrpc",
+    "webassembly",
+    "typescript",
+    "esmodules",
+    "tested",
+    "unit-tested"
+  ]
+}