@autochitect/engine 1.1.2 → 1.1.4

package/README.md

@@ -8,27 +8,88 @@ A 245KB WebAssembly cost estimation engine. Define cost models in a purpose-buil
 npm install @autochitect/engine
 ```
 
-## Quick start
+## Node.js
 
 ```javascript
 import { createEngine } from '@autochitect/engine';
 
-const engine = await createEngine(
-  new URL('@autochitect/engine/engine.wasm', import.meta.url)
-);
+const engine = await createEngine();
 
 const result = engine.estimate(`
-  revenue: Input
-  cost_ratio: Input
-  costs = revenue * cost_ratio
-  profit = revenue - costs
+  seats: Input
+  base_price_per_seat = 12
+  storage_gb: Input
+  storage_price_per_gb = 0.50
+
+  seat_cost = seats * base_price_per_seat
+  storage_cost = storage_gb * storage_price_per_gb
+  subtotal = seat_cost + storage_cost
+
+  discount_rate = IF(seats > 50, 0.20, IF(seats > 20, 0.10, 0))
+  discount = subtotal * discount_rate
+  monthly_total = subtotal - discount
+  annual_total = monthly_total * 12
 `, {
-  revenue: 500000,
-  cost_ratio: 0.6
+  seats: 35,
+  storage_gb: 200,
 });
 
 console.log(result.results);
-// { revenue: 500000, cost_ratio: 0.6, costs: 300000, profit: 200000 }
+// {
+//   seats: 35, base_price_per_seat: 12, storage_gb: 200, storage_price_per_gb: 0.5,
+//   seat_cost: 420, storage_cost: 100, subtotal: 520,
+//   discount_rate: 0.1, discount: 52, monthly_total: 468, annual_total: 5616
+// }
+```
+
+## Browser
+
+No install needed — paste this into an HTML file and open it.
+
+```html
+<script type="module">
+  import { createEngine } from 'https://esm.sh/@autochitect/engine';
+
+  const engine = await createEngine(
+    'https://unpkg.com/@autochitect/engine/engine.wasm'
+  );
+
+  const result = engine.estimate(`
+    seats: Input
+    base_price_per_seat = 12
+    storage_gb: Input
+    storage_price_per_gb = 0.50
+
+    seat_cost = seats * base_price_per_seat
+    storage_cost = storage_gb * storage_price_per_gb
+    subtotal = seat_cost + storage_cost
+
+    discount_rate = IF(seats > 50, 0.20, IF(seats > 20, 0.10, 0))
+    discount = subtotal * discount_rate
+    monthly_total = subtotal - discount
+    annual_total = monthly_total * 12
+  `, {
+    seats: 35,
+    storage_gb: 200,
+  });
+
+  console.log(result.results);
+  // {
+  //   seats: 35, base_price_per_seat: 12, storage_gb: 200, storage_price_per_gb: 0.5,
+  //   seat_cost: 420, storage_cost: 100, subtotal: 520,
+  //   discount_rate: 0.1, discount: 52, monthly_total: 468, annual_total: 5616
+  // }
+</script>
+```
+
+If you use a bundler (Vite, webpack, etc.), import normally:
+
+```javascript
+import { createEngine } from '@autochitect/engine';
+
+const engine = await createEngine(
+  new URL('@autochitect/engine/engine.wasm', import.meta.url)
+);
 ```
 
 ## What you get
@@ -41,8 +102,6 @@ console.log(result.results);
 
 ## The DSL
 
-The language is deliberately small. It's designed for cost estimation and financial modeling specifically.
-
 ```
 # Inputs — bind to external data (your JSON)
 revenue: Input("annual_revenue")
@@ -72,81 +131,6 @@ cumulative = SCAN(monthly, 0, LAMBDA(acc, m, acc + m))
 
 **MAP** transforms arrays element-wise. **SCAN** accumulates (like reduce, but returns intermediate results). **LAMBDA** defines inline functions with named parameters.
 
-The engine compiles this into a directed acyclic graph, topologically sorts it, and estimates in one pass. The graph is immutable — switching scenarios just swaps the input context, so it's instant.
-
-## Node.js usage
-
-```javascript
-import { createEngine } from '@autochitect/engine';
-import { createRequire } from 'module';
-
-const require = createRequire(import.meta.url);
-const wasmPath = require.resolve('@autochitect/engine/engine.wasm');
-const engine = await createEngine(wasmPath);
-
-const result = engine.estimate(`
-  headcount: Input
-  avg_salary = 85000
-  benefits_rate = 0.3
-
-  labor_cost = headcount * avg_salary
-  benefits = labor_cost * benefits_rate
-  total_people_cost = labor_cost + benefits
-`, {
-  headcount: 12,
-});
-
-console.log(result.results);
-// {
-//   headcount: 12,
-//   avg_salary: 85000,
-//   benefits_rate: 0.3,
-//   labor_cost: 1020000,
-//   benefits: 306000,
-//   total_people_cost: 1326000
-// }
-```
-
-## Browser usage
-
-```html
-<script type="module">
-  import { createEngine } from './node_modules/@autochitect/engine/index.mjs';
-
-  const engine = await createEngine(
-    new URL('./node_modules/@autochitect/engine/engine.wasm', import.meta.url)
-  );
-
-  const result = engine.estimate(`
-    units: Input
-    price_per_unit: Input
-    discount_rate: Input
-
-    subtotal = units * price_per_unit
-    discount = subtotal * discount_rate
-    total = subtotal - discount
-  `, {
-    units: 1000,
-    price_per_unit: 49.99,
-    discount_rate: 0.15,
-  });
-
-  console.log(result.results);
-  // { units: 1000, price_per_unit: 49.99, discount_rate: 0.15,
-  //   subtotal: 49990, discount: 7498.5, total: 42491.5 }
-</script>
-```
-
-When using a bundler (Vite, webpack, etc.), import the WASM file directly:
-
-```javascript
-import { createEngine } from '@autochitect/engine';
-
-const engine = await createEngine(
-  new URL('@autochitect/engine/engine.wasm', import.meta.url)
-);
-```
-
 ## Options
 
 ```javascript

package/index.browser.mjs

@@ -0,0 +1,125 @@
+const WASI_SHIM = {
+  fd_write: (fd, iovs_ptr, iovs_len, nwritten_ptr, mem) => {
+    const view = new DataView(mem.buffer);
+    let written = 0;
+    for (let i = 0; i < iovs_len; i++) {
+      written += view.getUint32(iovs_ptr + i * 8 + 4, true);
+    }
+    view.setUint32(nwritten_ptr, written, true);
+    return 0;
+  },
+  fd_close: () => 0,
+  fd_seek: (fd, lo, hi, whence, ptr, mem) => {
+    new DataView(mem.buffer).setBigUint64(ptr, 0n, true);
+    return 0;
+  },
+  fd_fdstat_get: (fd, buf, mem) => {
+    for (let i = 0; i < 24; i++) new DataView(mem.buffer).setUint8(buf + i, 0);
+    return 0;
+  },
+  environ_sizes_get: (cp, bp, mem) => {
+    const v = new DataView(mem.buffer);
+    v.setUint32(cp, 0, true);
+    v.setUint32(bp, 0, true);
+    return 0;
+  },
+  args_sizes_get: (ap, bp, mem) => {
+    const v = new DataView(mem.buffer);
+    v.setUint32(ap, 0, true);
+    v.setUint32(bp, 0, true);
+    return 0;
+  },
+  clock_time_get: (id, prec, ptr, mem) => {
+    new DataView(mem.buffer).setBigUint64(ptr, BigInt(Date.now()) * 1000000n, true);
+    return 0;
+  },
+  proc_exit: (code) => { throw new Error(`proc_exit(${code})`); },
+};
+
+const STUB_ERRNO = {
+  fd_read: 0, fd_sync: 0, fd_pread: 0, fd_pwrite: 0, fd_readdir: 0,
+  fd_prestat_get: 8, fd_prestat_dir_name: 28,
+  fd_filestat_get: 0, fd_filestat_set_size: 0, fd_filestat_set_times: 0,
+  environ_get: 0, args_get: 0,
+  path_open: 44, path_create_directory: 44, path_filestat_get: 44,
+  path_filestat_set_times: 44, path_link: 44, path_readlink: 44,
+  path_remove_directory: 44, path_rename: 44, path_symlink: 44,
+  path_unlink_file: 44, sched_yield: 0, poll_oneoff: 0,
+  sock_accept: 58, sock_recv: 58, sock_send: 58, sock_shutdown: 58,
+};
+
+function buildWasiImports(memoryRef) {
+  const imports = {};
+  for (const [name, fn] of Object.entries(WASI_SHIM)) {
+    if (typeof fn === 'function') {
+      if (name === 'proc_exit') {
+        imports[name] = fn;
+      } else {
+        imports[name] = (...args) => fn(...args, memoryRef.current);
+      }
+    }
+  }
+  for (const [name, errno] of Object.entries(STUB_ERRNO)) {
+    imports[name] = () => errno;
+  }
+  imports.clock_res_get = (id, ptr) => {
+    new DataView(memoryRef.current.buffer).setBigUint64(ptr, 1000000n, true);
+    return 0;
+  };
+  imports.random_get = (buf, len) => {
+    const view = new Uint8Array(memoryRef.current.buffer, buf, len);
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+      crypto.getRandomValues(view);
+    } else {
+      for (let i = 0; i < len; i++) view[i] = Math.floor(Math.random() * 256);
+    }
+    return 0;
+  };
+  return imports;
+}
+
+export async function createEngine(wasmSource) {
+  const memoryRef = { current: null };
+  const imports = { wasi_snapshot_preview1: buildWasiImports(memoryRef) };
+
+  let bytes;
+  if (wasmSource instanceof ArrayBuffer || ArrayBuffer.isView(wasmSource)) {
+    bytes = wasmSource;
+  } else if (wasmSource instanceof Response || (typeof wasmSource === 'object' && typeof wasmSource.then === 'function')) {
+    const response = await wasmSource;
+    bytes = await response.arrayBuffer();
+  } else if (wasmSource instanceof URL) {
+    bytes = await (await fetch(wasmSource)).arrayBuffer();
+  } else if (typeof wasmSource === 'string') {
+    bytes = await (await fetch(wasmSource)).arrayBuffer();
+  } else {
+    throw new Error('wasmSource must be a URL, URL string, Response, or ArrayBuffer');
+  }
+
+  const { instance } = await WebAssembly.instantiate(bytes, imports);
+  memoryRef.current = instance.exports.memory;
+
+  function writeString(str) {
+    const enc = new TextEncoder().encode(str);
+    const ptr = instance.exports.wasm_alloc(enc.length);
+    if (ptr === 0) throw new Error('WASM allocation failed');
+    new Uint8Array(memoryRef.current.buffer, ptr, enc.length).set(enc);
+    return { ptr, len: enc.length };
+  }
+
+  return {
+    estimate(source, inputs = {}, options = {}) {
+      const includeGraph = options.graph !== false;
+      const src = writeString(source);
+      const json = writeString(JSON.stringify(inputs));
+      const resultLen = instance.exports.wasm_estimate(
+        src.ptr, src.len,
+        json.ptr, json.len,
+        includeGraph ? 1 : 0
+      );
+      const resultPtr = instance.exports.wasm_result_ptr();
+      const resultBytes = new Uint8Array(memoryRef.current.buffer, resultPtr, resultLen);
+      return JSON.parse(new TextDecoder().decode(resultBytes));
+    },
+  };
+}

package/index.d.ts

@@ -21,7 +21,7 @@ export interface EstimateOptions {
 }
 
 export interface Engine {
-  estimate(source: string, inputs?: Record<string, unknown>, options?: EstimateOptions): EstimateResult;
+  estimate(source: string, inputs?: Record<string, unknown> | object, options?: EstimateOptions): EstimateResult;
 }
 
-export function createEngine(wasmSource: string | Response | ArrayBuffer): Promise<Engine>;
+export function createEngine(wasmSource?: string | URL | Response | ArrayBuffer): Promise<Engine>;

package/index.mjs

@@ -82,6 +82,13 @@ export async function createEngine(wasmSource) {
   const memoryRef = { current: null };
   const imports = { wasi_snapshot_preview1: buildWasiImports(memoryRef) };
 
+  if (wasmSource == null && typeof globalThis.process !== 'undefined') {
+    const { fileURLToPath } = await import('url');
+    const { dirname, join } = await import('path');
+    const fs = await import('fs');
+    wasmSource = join(dirname(fileURLToPath(import.meta.url)), 'engine.wasm');
+  }
+
   let bytes;
   if (wasmSource instanceof ArrayBuffer || ArrayBuffer.isView(wasmSource)) {
     bytes = wasmSource;

package/package.json

@@ -1,13 +1,23 @@
 {
   "name": "@autochitect/engine",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "A 245KB WebAssembly financial modeling engine. Define cost models in a purpose-built DSL, get instant estimates with full dependency tracing. No server required.",
   "license": "MIT",
   "type": "module",
   "main": "index.mjs",
   "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "browser": "./index.browser.mjs",
+      "import": "./index.mjs",
+      "default": "./index.mjs"
+    },
+    "./engine.wasm": "./engine.wasm"
+  },
   "files": [
     "index.mjs",
+    "index.browser.mjs",
     "index.d.ts",
     "engine.wasm",
     "LICENSE",
@@ -26,7 +36,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git@github.com:autochitect/engine.git"
+    "url": "git+ssh://git@github.com/autochitect/engine.git"
   },
   "homepage": "https://autochitect.com/engine"
 }