@six5536/smllm-wasm 0.0.0 → 0.4.1

package/dist/wrap.js

@@ -0,0 +1,104 @@
+// The typed layer over the raw string API: objects in and
+// out, and an object-based host. Each entry module subclasses `Engine` with
+// its build's wasm-bindgen `Engine` as `Raw`.
+const parse = (text) => JSON.parse(text);
+/** The raw host: `host`'s methods, JSON parsed, defaults filled in. */
+function adapt(host) {
+    return {
+        supports: (kind) => Boolean(host.supports?.(kind)),
+        check: (kind, params, env, cwd) => host.check ? Boolean(host.check(kind, parse(params), parse(env), cwd)) : false,
+        run: (kind, params, env, cwd) => host.run ? (host.run(kind, parse(params), parse(env), cwd) ?? "") : `${kind} is not supported`,
+        read: (file) => host.read?.(file) ?? undefined,
+        isMatch: (pattern, value) => host.isMatch ? host.isMatch(pattern, value) : new RegExp(pattern).test(value),
+        now: () => (host.now ? host.now() : Date.now()),
+        random: () => (host.random ? host.random() : crypto.getRandomValues(new Uint32Array(1))[0]),
+        history: (machine, id, entry) => {
+            host.history?.(machine, id, parse(entry));
+        },
+        put: (kind, key, record) => {
+            host.put?.(kind, key, parse(record));
+        },
+    };
+}
+/** smllm's engine over compiled machines (`smllm compile` output). */
+export class Engine {
+    /** The build's raw `Engine`: set by the entry module's subclass. */
+    static Raw;
+    #raw;
+    /**
+     * `storage`, when given, is loaded now and then receives every saved
+     * record and history entry (its `put` and `history` go before `host`'s).
+     */
+    constructor(compiled, host = {}, storage) {
+        const json = typeof compiled === "string" ? compiled : JSON.stringify(compiled);
+        const Raw = this.constructor.Raw;
+        const all = storage
+            ? {
+                ...host,
+                put: (kind, key, record) => {
+                    storage.put(kind, key, record);
+                    host.put?.(kind, key, record);
+                },
+                history: (machine, id, entry) => {
+                    storage.history(machine, id, entry);
+                    host.history?.(machine, id, entry);
+                },
+            }
+            : host;
+        this.#raw = new Raw(json, adapt(all));
+        const saved = storage?.load();
+        if (saved) {
+            this.importState(saved);
+        }
+    }
+    /** The agent-facing tool, to hand to an LLM's tool list (HOST-13). */
+    tool() {
+        return parse(this.#raw.tool());
+    }
+    /** Answer a tool call as the MCP server does; a malformed call is `ok: false`, never a throw. */
+    callTool(args = {}) {
+        return parse(this.#raw.callTool(JSON.stringify(args)));
+    }
+    /** Guard and action kinds the machines use that this host cannot run. */
+    unsupported() {
+        return parse(this.#raw.unsupported());
+    }
+    /** Bind a harness session (reused when `hostSession` is already bound). */
+    bind(harness, hostSession, cwd = "") {
+        return parse(this.#raw.bind(harness, hostSession, cwd));
+    }
+    /** Where the session is; changes nothing. */
+    view(key) {
+        return parse(this.#raw.view(key));
+    }
+    /** The events list of the session's state. */
+    events(key) {
+        return parse(this.#raw.events(key));
+    }
+    status(key) {
+        return parse(this.#raw.status(key));
+    }
+    /** Fire an event; with no key, only `enter` (it starts a session). */
+    fire(key, event, params = {}) {
+        return parse(this.#raw.fire(key, event, JSON.stringify(params)));
+    }
+    stop(key, stopHookActive = false) {
+        return parse(this.#raw.stop(key, stopHookActive));
+    }
+    promptSubmitted(key) {
+        this.#raw.promptSubmitted(key);
+    }
+    exportState() {
+        return parse(this.#raw.exportState());
+    }
+    importState(state) {
+        this.#raw.importState(typeof state === "string" ? state : JSON.stringify(state));
+    }
+    /** Free the wasm memory now, rather than when collected. */
+    free() {
+        this.#raw.free();
+    }
+    [Symbol.dispose]() {
+        this.free();
+    }
+}

package/package.json

@@ -1,10 +1,65 @@
 {
   "name": "@six5536/smllm-wasm",
-  "version": "0.0.0",
-  "description": "Reserves the name for smllm's first release, so that its trusted publisher can be set up. Install a later version.",
+  "version": "0.4.1",
+  "description": "smllm's engine as WebAssembly: run smllm state machines that drive an LLM agent, in a browser or Node.",
   "homepage": "https://github.com/six5536/smllm#readme",
-  "repository": { "type": "git", "url": "git+https://github.com/six5536/smllm.git" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/six5536/smllm.git",
+    "directory": "packages/smllm-wasm"
+  },
+  "bugs": {
+    "url": "https://github.com/six5536/smllm/issues"
+  },
+  "author": "six5536 <10079653+six5536@users.noreply.github.com>",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "llm",
+    "agent",
+    "state-machine",
+    "xstate",
+    "wasm"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./bundler": {
+      "types": "./dist/bundler.d.ts",
+      "default": "./dist/bundler.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.js"
+    },
+    "./raw": {
+      "types": "./wasm/web/smllm_wasm.d.ts",
+      "default": "./wasm/web/smllm_wasm.js"
+    },
+    "./raw/bundler": {
+      "types": "./wasm/bundler/smllm_wasm.d.ts",
+      "default": "./wasm/bundler/smllm_wasm.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "wasm/web/",
+    "wasm/bundler/"
+  ],
+  "sideEffects": [
+    "./wasm/bundler/smllm_wasm.js",
+    "./dist/bundler.js"
+  ],
   "license": "MIT",
-  "files": ["README.md"],
-  "publishConfig": { "registry": "https://registry.npmjs.org", "access": "public" }
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  }
 }

package/wasm/bundler/smllm_wasm.d.ts

@@ -0,0 +1,70 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * An smllm engine with an in-memory store.
+ */
+export class Engine {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Bind a session; returns the reply JSON (its `session` is the key).
+     */
+    bind(harness: string, host_session: string | null | undefined, cwd: string): string;
+    /**
+     * A tool call: the agent's arguments as JSON, answered as the MCP
+     * server answers them (HOST-13). A malformed call or an engine error is
+     * a reply with `ok: false` and `error: …`, never a throw: the agent
+     * sees its mistake as the tool's answer.
+     */
+    callTool(args: string): string;
+    /**
+     * The events list.
+     */
+    events(key: string): string;
+    /**
+     * Sessions, bindings and instances as JSON (history went to the host).
+     */
+    exportState(): string;
+    /**
+     * Fire an event; `params` is a JSON object of strings.
+     */
+    fire(key: string | null | undefined, event: string, params: string): string;
+    /**
+     * Replace the store from [`Engine::export_state`] JSON.
+     */
+    importState(state: string): void;
+    /**
+     * Load compiled machines (`smllm compile` output).
+     */
+    constructor(compiled: string, host: any);
+    /**
+     * A user prompt arrived.
+     */
+    promptSubmitted(key: string): void;
+    /**
+     * Where the session is, as the `smllm statusline --json` object (STL-8).
+     */
+    status(key: string): string;
+    /**
+     * The stop decision as JSON (TURN-4..6): `{"decision": "allow"}` = may
+     * stop; `{"decision": "block", "text"}` = hold the agent with the events
+     * list; `{"decision": "runaway", "text"}` = let it stop, showing the
+     * list to the user (the harness was already continuing because of a
+     * block, and no event was fired since).
+     */
+    stop(key: string, stop_hook_active: boolean): string;
+    /**
+     * The agent-facing tool, as JSON `{name, description, inputSchema}`:
+     * the core's definition, as the MCP server offers it (HOST-13).
+     */
+    tool(): string;
+    /**
+     * Guard and action kinds this host cannot run, as a JSON array.
+     */
+    unsupported(): string;
+    /**
+     * Read-only view.
+     */
+    view(key: string): string;
+}

package/wasm/bundler/smllm_wasm.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./smllm_wasm.d.ts" */
+import * as wasm from "./smllm_wasm_bg.wasm";
+import { __wbg_set_wasm } from "./smllm_wasm_bg.js";
+
+__wbg_set_wasm(wasm);
+
+export {
+    Engine
+} from "./smllm_wasm_bg.js";