@onimaxxing/sussy-seeds-mcp 0.1.2 → 0.1.4

package/dist/index.js

@@ -140811,10 +140811,409 @@ var CONSTRAINT_KIND_CATALOG = [
 import { z as z4 } from "zod";
 
 // src/wasm.ts
-import { readFileSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { createRequire } from "module";
 import { dirname, join } from "path";
-import init, { Roller } from "@tigin-backwards/oxygen-not-included-gambling";
+import { fileURLToPath } from "url";
+
+// ../../node_modules/.pnpm/@tigin-backwards+oxygen-not-included-gambling@0.4.0/node_modules/@tigin-backwards/oxygen-not-included-gambling/oni_roll_wasm.js
+var Roller = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    RollerFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_roller_free(ptr, 0);
+  }
+  /**
+   * Runs the position-aware scan path: phase 1 placement (cached
+   * rings) + trait selection (`_into`) over `n_seeds` consecutive
+   * cluster_seeds. Returns the cumulative trait count so the JIT
+   * can't elide the work. Use to measure the combined phase 1 +
+   * trait cost under real WASM (what scan_chunk runs for queries
+   * that read world positions).
+   * @param {number} n_seeds
+   * @returns {number}
+   */
+  benchPhase1AndTraits(n_seeds) {
+    const ret = wasm.roller_benchPhase1AndTraits(this.__wbg_ptr, n_seeds);
+    return ret >>> 0;
+  }
+  /**
+   * Same as `bench_phase1_and_traits` but uses the uncached
+   * `compute_world_placements` for an A/B against the cache.
+   * @param {number} n_seeds
+   * @returns {number}
+   */
+  benchPhase1AndTraitsUncached(n_seeds) {
+    const ret = wasm.roller_benchPhase1AndTraitsUncached(this.__wbg_ptr, n_seeds);
+    return ret >>> 0;
+  }
+  /**
+   * Same shape as `bench_traits_scratch` but uses the returning
+   * `select_traits_pooled` (allocates a fresh `Vec<Arc<str>>` per
+   * call). Lets the JS-side bench measure the alloc overhead vs
+   * the scratch path under real WASM/V8.
+   * @param {number} n_seeds
+   * @returns {number}
+   */
+  benchTraitsReturning(n_seeds) {
+    const ret = wasm.roller_benchTraitsReturning(this.__wbg_ptr, n_seeds);
+    return ret >>> 0;
+  }
+  /**
+   * Micro-benchmark exit. Runs `Cluster::select_traits_pooled_into`
+   * (the path scan_chunk hits for positionless trait queries) over
+   * `n_seeds` consecutive cluster_seeds starting at 0, against
+   * every world. Returns the cumulative trait count so the JIT
+   * can't elide the work.
+   *
+   * Used by `scripts/wasm_bench_traits.mjs` to measure real WASM
+   * throughput from JS via `performance.now()`. The trait_pool +
+   * trait_scratch + trait_out_bufs already in `Roller` are the
+   * exact buffers scan_chunk uses, so the numbers reflect what a
+   * real `scanChunk` call would see for its trait-selection slice.
+   * @param {number} n_seeds
+   * @returns {number}
+   */
+  benchTraitsScratch(n_seeds) {
+    const ret = wasm.roller_benchTraitsScratch(this.__wbg_ptr, n_seeds);
+    return ret >>> 0;
+  }
+  /**
+   * Cluster type id (e.g. "expansion1::clusters/VanillaSandstoneCluster").
+   * @returns {string}
+   */
+  get clusterId() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.roller_clusterId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Replace the resident `SettingsCache` with one built from a
+   * `{path: jsonString}` files map. Optional override for mod /
+   * overlay flows; the default cache (baked-in U59 codegen) is
+   * loaded lazily on first `new Roller(coord)`. Existing Roller
+   * instances keep their `Arc` handles to the previous cache, so
+   * versions are isolated.
+   * @param {string} overlay_json
+   */
+  static loadSnapshot(overlay_json) {
+    const ptr0 = passStringToWasm0(overlay_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.roller_loadSnapshot(ptr0, len0);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * Create a new roller for a given cluster coord. `coord` is any
+   * valid game coord for the target cluster type — the seed field
+   * is ignored (we vary it ourselves via `summarize`).
+   * @param {string} coord
+   */
+  constructor(coord) {
+    const ptr0 = passStringToWasm0(coord, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.roller_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    RollerFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Run a compiled query bytecode against every cluster_seed in
+   * `[lo, hi)` and return the top-K matches as JS objects.
+   *
+   * Only matches cross the WASM boundary — the main perf win vs
+   * per-seed `summarize()` + JS filter. The inner loop stays in
+   * WASM with zero allocations per cluster after the first call.
+   *
+   * Each returned match is `{ cluster_seed, score, columns: {key: value, ...} }`.
+   * @param {number} lo
+   * @param {number} hi
+   * @param {Uint8Array} bytecode
+   * @param {number} top_k
+   * @returns {any}
+   */
+  scanChunk(lo, hi, bytecode, top_k) {
+    const ptr0 = passArray8ToWasm0(bytecode, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.roller_scanChunk(this.__wbg_ptr, lo, hi, ptr0, len0, top_k);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Full summary for one cluster_seed. Returns a JS object of shape
+   * `ClusterSummary`.
+   * @param {number} cluster_seed
+   * @returns {any}
+   */
+  summarize(cluster_seed) {
+    const ret = wasm.roller_summarize(this.__wbg_ptr, cluster_seed);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * World-trait lists (one Vec per world) for the given
+   * cluster_seed. Pure seed hash, cheap. Separate from `summarize`
+   * because traits aren't always needed.
+   *
+   * Fragment-aware: if a slot was swapped by world-mixing on this
+   * seed, the returned Vec at that slot reflects the fragment's
+   * rules (not the vanilla config's) — matching what `summarize`
+   * puts in `ClusterSummary.world_traits` and what
+   * `Cluster::generate_with_settings` actually runs at capture time.
+   * @param {number} cluster_seed
+   * @returns {any}
+   */
+  traits(cluster_seed) {
+    const ret = wasm.roller_traits(this.__wbg_ptr, cluster_seed);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Number of worlds in this cluster layout.
+   * @returns {number}
+   */
+  get world_count() {
+    const ret = wasm.roller_world_count(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+};
+if (Symbol.dispose) Roller.prototype[Symbol.dispose] = Roller.prototype.free;
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg_Error_83742b46f01ce22d: function(arg0, arg1) {
+      const ret = Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_String_8564e559799eccda: function(arg0, arg1) {
+      const ret = String(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_6ddd609b62940d55: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg_new_a70fbab9066b301f: function() {
+      const ret = new Array();
+      return ret;
+    },
+    __wbg_new_ab79df5bd7c26067: function() {
+      const ret = new Object();
+      return ret;
+    },
+    __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
+      arg0[arg1 >>> 0] = arg2;
+    },
+    __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+      arg0[arg1] = arg2;
+    },
+    __wbindgen_cast_0000000000000001: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000002: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+      const ret = getStringFromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000004: function(arg0) {
+      const ret = BigInt.asUintN(64, arg0);
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm.__wbindgen_externrefs;
+      const offset2 = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset2 + 0, void 0);
+      table.set(offset2 + 1, null);
+      table.set(offset2 + 2, true);
+      table.set(offset2 + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./oni_roll_wasm_bg.js": import0
+  };
+}
+var RollerFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_roller_free(ptr >>> 0, 1));
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset2 = 0;
+  for (; offset2 < len; offset2++) {
+    const code = arg.charCodeAt(offset2);
+    if (code > 127) break;
+    mem[ptr + offset2] = code;
+  }
+  if (offset2 !== len) {
+    if (offset2 !== 0) {
+      arg = arg.slice(offset2);
+    }
+    ptr = realloc(ptr, len, len = offset2 + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset2, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset2 += ret.written;
+    ptr = realloc(ptr, len, offset2, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset2;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var wasmModule;
+var wasm;
+function __wbg_finalize_init(instance, module) {
+  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 (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        const validResponse = module.ok && 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);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (module_or_path !== void 0) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (module_or_path === void 0) {
+    module_or_path = new URL("oni_roll_wasm_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
+}
+
+// src/wasm.ts
 var require2 = createRequire(import.meta.url);
 var bootPromise = null;
 async function boot() {
@@ -140826,12 +141225,16 @@ async function boot() {
   }
   return bootPromise;
 }
-async function doBoot() {
+function resolveWasmPath() {
+  const bundled = join(dirname(fileURLToPath(import.meta.url)), "oni_roll_wasm_bg.wasm");
+  if (existsSync(bundled)) return bundled;
   const entryPath = require2.resolve("@tigin-backwards/oxygen-not-included-gambling");
-  const wasmPath = join(dirname(entryPath), "oni_roll_wasm_bg.wasm");
-  const wasmBytes = readFileSync(wasmPath);
-  const wasmModule = new WebAssembly.Module(wasmBytes);
-  await init({ module_or_path: wasmModule });
+  return join(dirname(entryPath), "oni_roll_wasm_bg.wasm");
+}
+async function doBoot() {
+  const wasmBytes = readFileSync(resolveWasmPath());
+  const wasmModule2 = new WebAssembly.Module(wasmBytes);
+  await __wbg_init({ module_or_path: wasmModule2 });
 }
 var ROLLER_CACHE = /* @__PURE__ */ new Map();
 function coordPrefix(coord) {
@@ -140863,7 +141266,7 @@ async function boot2() {
   return bootPromise2;
 }
 async function doBoot2() {
-  wg = require3("@tigin-backwards/oxygen-not-included-worldgen-node");
+  wg = require3("@onimaxxing/worldgen-node");
   await wg.default();
   wg.worldgen.snapshot.loadVanillaExtensions();
 }
@@ -144457,7 +144860,7 @@ pp$8.parseForStatement = function(node) {
   var containsEsc = this.containsEsc;
   var refDestructuringErrors = new DestructuringErrors();
   var initPos = this.start;
-  var init2 = awaitAt > -1 ? this.parseExprSubscripts(refDestructuringErrors, "await") : this.parseExpression(true, refDestructuringErrors);
+  var init = awaitAt > -1 ? this.parseExprSubscripts(refDestructuringErrors, "await") : this.parseExpression(true, refDestructuringErrors);
   if (this.type === types$1._in || (isForOf = this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
     if (awaitAt > -1) {
       if (this.type === types$1._in) {
@@ -144465,28 +144868,28 @@ pp$8.parseForStatement = function(node) {
       }
       node.await = true;
     } else if (isForOf && this.options.ecmaVersion >= 8) {
-      if (init2.start === initPos && !containsEsc && init2.type === "Identifier" && init2.name === "async") {
+      if (init.start === initPos && !containsEsc && init.type === "Identifier" && init.name === "async") {
         this.unexpected();
       } else if (this.options.ecmaVersion >= 9) {
         node.await = false;
       }
     }
     if (startsWithLet && isForOf) {
-      this.raise(init2.start, "The left-hand side of a for-of loop may not start with 'let'.");
+      this.raise(init.start, "The left-hand side of a for-of loop may not start with 'let'.");
     }
-    this.toAssignable(init2, false, refDestructuringErrors);
-    this.checkLValPattern(init2);
-    return this.parseForIn(node, init2);
+    this.toAssignable(init, false, refDestructuringErrors);
+    this.checkLValPattern(init);
+    return this.parseForIn(node, init);
   } else {
     this.checkExpressionErrors(refDestructuringErrors, true);
   }
   if (awaitAt > -1) {
     this.unexpected(awaitAt);
   }
-  return this.parseFor(node, init2);
+  return this.parseFor(node, init);
 };
-pp$8.parseForAfterInit = function(node, init2, awaitAt) {
-  if ((this.type === types$1._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) && init2.declarations.length === 1) {
+pp$8.parseForAfterInit = function(node, init, awaitAt) {
+  if ((this.type === types$1._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) && init.declarations.length === 1) {
     if (this.options.ecmaVersion >= 9) {
       if (this.type === types$1._in) {
         if (awaitAt > -1) {
@@ -144496,12 +144899,12 @@ pp$8.parseForAfterInit = function(node, init2, awaitAt) {
         node.await = awaitAt > -1;
       }
     }
-    return this.parseForIn(node, init2);
+    return this.parseForIn(node, init);
   }
   if (awaitAt > -1) {
     this.unexpected(awaitAt);
   }
-  return this.parseFor(node, init2);
+  return this.parseFor(node, init);
 };
 pp$8.parseFunctionStatement = function(node, isAsync, declarationPosition) {
   this.next();
@@ -144689,8 +145092,8 @@ pp$8.parseBlock = function(createNewLexicalScope, node, exitStrict) {
   }
   return this.finishNode(node, "BlockStatement");
 };
-pp$8.parseFor = function(node, init2) {
-  node.init = init2;
+pp$8.parseFor = function(node, init) {
+  node.init = init;
   this.expect(types$1.semi);
   node.test = this.type === types$1.semi ? null : this.parseExpression();
   this.expect(types$1.semi);
@@ -144701,16 +145104,16 @@ pp$8.parseFor = function(node, init2) {
   this.labels.pop();
   return this.finishNode(node, "ForStatement");
 };
-pp$8.parseForIn = function(node, init2) {
+pp$8.parseForIn = function(node, init) {
   var isForIn = this.type === types$1._in;
   this.next();
-  if (init2.type === "VariableDeclaration" && init2.declarations[0].init != null && (!isForIn || this.options.ecmaVersion < 8 || this.strict || init2.kind !== "var" || init2.declarations[0].id.type !== "Identifier")) {
+  if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.options.ecmaVersion < 8 || this.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
     this.raise(
-      init2.start,
+      init.start,
       (isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer"
     );
   }
-  node.left = init2;
+  node.left = init;
   node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
   this.expect(types$1.parenR);
   node.body = this.parseStatement("for");
@@ -149102,8 +149505,204 @@ function parse3(input, options) {
   return Parser.parse(input, options);
 }
 
-// ../../apps/onimaxxing/src/gambling/query/compile.ts
-import { OP, Program } from "@tigin-backwards/oxygen-not-included-gambling/query";
+// ../../node_modules/.pnpm/@tigin-backwards+oxygen-not-included-gambling@0.4.0/node_modules/@tigin-backwards/oxygen-not-included-gambling/query.js
+var OP = {
+  Nop: 0,
+  PushI32: 1,
+  PushF32: 2,
+  PushBool: 3,
+  Pop: 4,
+  Dup: 5,
+  Swap: 6,
+  AddI: 16,
+  SubI: 17,
+  MulI: 18,
+  NegI: 19,
+  AddF: 20,
+  SubF: 21,
+  MulF: 22,
+  DivF: 23,
+  AbsI: 24,
+  AbsF: 25,
+  MinI: 26,
+  MaxI: 27,
+  MinF: 28,
+  MaxF: 29,
+  I2F: 30,
+  F2I: 31,
+  LtI: 32,
+  LeI: 33,
+  GtI: 34,
+  GeI: 35,
+  EqI: 36,
+  NeI: 37,
+  LtF: 38,
+  LeF: 39,
+  GtF: 40,
+  GeF: 41,
+  EqF: 42,
+  NeF: 43,
+  And: 48,
+  Or: 49,
+  Not: 50,
+  FloorF: 51,
+  CeilF: 52,
+  RoundF: 53,
+  ClampI: 54,
+  ClampF: 55,
+  Jmp: 64,
+  JmpIfFalse: 65,
+  JmpIfTrue: 66,
+  ReturnFail: 67,
+  ReturnScoreI: 68,
+  ReturnScoreF: 69,
+  FindWorld: 80,
+  WorldQ: 81,
+  WorldR: 82,
+  WorldDistHome: 83,
+  WorldHasTrait: 84,
+  WorldTraitCount: 85,
+  CountWorldsWithTrait: 86,
+  WorldHasAnyTrait: 87,
+  WorldHasAllTraits: 88,
+  FindPoi: 96,
+  PoiQ: 97,
+  PoiR: 98,
+  PoiCapacityRoll: 99,
+  PoiRechargeRoll: 100,
+  CountPoiAboveCap: 101,
+  CountPoiByType: 102,
+  CountHarvestable: 103,
+  MeanPoiCap: 104,
+  MaxPoiCap: 105,
+  SumPoiCapAbove: 106,
+  CountPoiCapRech: 107,
+  CountPoiAboveCapOfType: 108,
+  CountPoiCapRechOfType: 109,
+  MeanPoiCapOfType: 110,
+  MeanPoiRechOfType: 111,
+  HasVanilla: 112,
+  VanillaMinDist: 113,
+  CountVanilla: 114,
+  HexDist: 128,
+  HexTaxicab: 129,
+  WorldToWorldDist: 130,
+  PoiToWorldDist: 131,
+  PoiDistHome: 132,
+  PoiToPoiDist: 133,
+  EmitColI: 144,
+  EmitColF: 145,
+  PackLex: 160,
+  HypotheticalGeyserAvg: 161
+};
+var Program = class {
+  constructor() {
+    this.strings = [];
+    this.code = [];
+    this.labels = /* @__PURE__ */ new Map();
+  }
+  str(s) {
+    const i = this.strings.indexOf(s);
+    if (i >= 0) return i;
+    this.strings.push(s);
+    return this.strings.length - 1;
+  }
+  emitU8(b) {
+    this.code.push(b & 255);
+  }
+  emitU16(n) {
+    this.code.push(n & 255, n >> 8 & 255);
+  }
+  emitI16(n) {
+    this.emitU16(n < 0 ? n + 65536 : n);
+  }
+  emitI32(n) {
+    const u = n < 0 ? n + 4294967296 : n;
+    this.code.push(u & 255, u >> 8 & 255, u >> 16 & 255, u >> 24 & 255);
+  }
+  emitF32(n) {
+    const buf = new ArrayBuffer(4);
+    new Float32Array(buf)[0] = n;
+    const b = new Uint8Array(buf);
+    this.code.push(b[0], b[1], b[2], b[3]);
+  }
+  // Vararg trait-set emit for OP.WorldHasAnyTrait / OP.WorldHasAllTraits.
+  // Encoding: opcode u8, count u8, count × (str index u16).
+  // Caller: worldIdx already on the stack, then emitTraitSet(OP, [...]).
+  emitTraitSet(op, traits2) {
+    if (traits2.length > 255) {
+      throw new Error(`emitTraitSet: at most 255 traits (got ${traits2.length})`);
+    }
+    this.emitU8(op);
+    this.emitU8(traits2.length);
+    for (const t of traits2) this.emitU16(this.str(t));
+  }
+  // Label support for jumps. `jmpTo("end")` emits a JMP_IF_FALSE with a
+  // placeholder offset; `label("end")` later patches the placeholder.
+  emitJmp(op, labelName) {
+    this.emitU8(op);
+    const patchPos = this.code.length;
+    this.emitI16(0);
+    const entry = this.labels.get(labelName) || { target: void 0, patches: [] };
+    entry.patches.push({ patchPos, opEnd: this.code.length });
+    this.labels.set(labelName, entry);
+  }
+  label(name) {
+    const pos = this.code.length;
+    const entry = this.labels.get(name) || { target: void 0, patches: [] };
+    entry.target = pos;
+    for (const p of entry.patches) {
+      const off = pos - p.opEnd;
+      this.code[p.patchPos] = off & 255;
+      this.code[p.patchPos + 1] = off >> 8 & 255;
+    }
+    entry.patches = [];
+    this.labels.set(name, entry);
+  }
+  // Build the final Uint8Array.
+  build() {
+    for (const [name, entry] of this.labels) {
+      if (entry.patches.length > 0) {
+        throw new Error(`unresolved label: ${name} (${entry.patches.length} refs)`);
+      }
+    }
+    const enc = new TextEncoder();
+    const stringBlock = [];
+    for (const s of this.strings) {
+      const bytes = enc.encode(s);
+      stringBlock.push(bytes.length & 255, bytes.length >> 8 & 255);
+      for (const b of bytes) stringBlock.push(b);
+    }
+    const codeLen = this.code.length;
+    const header = [
+      79,
+      82,
+      81,
+      66,
+      // "ORQB"
+      1,
+      0,
+      // version
+      0,
+      0,
+      // flags
+      this.strings.length & 255,
+      this.strings.length >> 8 & 255
+    ];
+    const out = new Uint8Array(header.length + stringBlock.length + 4 + codeLen);
+    let off = 0;
+    out.set(header, off);
+    off += header.length;
+    out.set(stringBlock, off);
+    off += stringBlock.length;
+    out[off++] = codeLen & 255;
+    out[off++] = codeLen >> 8 & 255;
+    out[off++] = codeLen >> 16 & 255;
+    out[off++] = codeLen >> 24 & 255;
+    out.set(this.code, off);
+    return out;
+  }
+};
 
 // ../../apps/onimaxxing/src/gambling/query/cluster-vocab.ts
 function clusterKnownWorlds(clusterCoord) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onimaxxing/sussy-seeds-mcp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "MCP server for Oxygen Not Included seed hunting. Runs the sussy-seeds wasm scanner over stdio; the LLM composes Builder AST specs and drives cluster / summary / map-tier scans against the game's real worldgen.",
   "keywords": [
     "claude",
@@ -35,35 +35,34 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "build": "tsup",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
-    "lint": "pnpm run typecheck && oxfmt . && oxlint src --deny-warnings --report-unused-disable-directives",
-    "format": "oxfmt .",
-    "test": "vitest run --passWithNoTests",
-    "prepublishOnly": "pnpm run build"
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.26.0",
-    "@tigin-backwards/oxygen-not-included-gambling": "0.4.0",
-    "@tigin-backwards/oxygen-not-included-worldgen-node": "0.14.1",
+    "@onimaxxing/worldgen-node": "0.15.1",
     "zod": "^3.25.0"
   },
   "devDependencies": {
-    "@onimaxxing/coord-codec": "workspace:*",
-    "@onimaxxing/i18n": "workspace:*",
-    "@onimaxxing/knowledge-graph": "workspace:*",
-    "@onimaxxing/prefab-kind": "workspace:*",
+    "@tigin-backwards/oxygen-not-included-gambling": "0.4.0",
     "@types/node": "^24.10.1",
     "oxfmt": "0.53.0",
     "oxlint": "^1.0.0",
     "tsup": "^8.3.0",
     "tsx": "^4.19.0",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.0.18",
+    "@onimaxxing/coord-codec": "0.0.0",
+    "@onimaxxing/i18n": "0.0.0",
+    "@onimaxxing/knowledge-graph": "0.0.0",
+    "@onimaxxing/prefab-kind": "0.0.0"
   },
   "engines": {
     "node": ">=20"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "pnpm run typecheck && oxfmt . && oxlint src --deny-warnings --report-unused-disable-directives",
+    "format": "oxfmt .",
+    "test": "vitest run --passWithNoTests"
   }
-}
+}