motely-node 2.2.0

package/index.d.ts

@@ -0,0 +1,102 @@
+export interface VersionInfo {
+    version: string;
+    runtime: string;
+    features: string[];
+}
+export interface CapabilitiesInfo {
+    simd: boolean;
+    threads: boolean;
+    processorCount: number;
+    runtime: string;
+    version: string;
+}
+export interface ShopItemInfo {
+    id: string;
+    name: string;
+}
+export interface PackInfo {
+    type: string;
+    items: string[];
+}
+export interface AnteAnalysisInfo {
+    ante: number;
+    boss: string;
+    voucher: string;
+    smallBlindTag: string;
+    bigBlindTag: string;
+    shopQueue: ShopItemInfo[];
+    packs: PackInfo[];
+}
+export interface SeedAnalysisInfo {
+    seed: string;
+    deck: string;
+    stake: string;
+    error?: string | null;
+    antes: AnteAnalysisInfo[];
+}
+export interface SearchResultInfo {
+    seed: string;
+    score: number;
+}
+export interface SearchProgressInfo {
+    type: 'progress';
+    seedsSearched: number;
+    matchingSeeds: number;
+    elapsedMs: number;
+    resultCount: number;
+}
+export interface SearchCompleteInfo {
+    type: 'done';
+    searchId: string;
+}
+export interface ValidateResult {
+    valid: boolean;
+    error?: string | null;
+    name?: string | null;
+    deck?: string | null;
+    stake?: string | null;
+}
+export interface SearchOptions {
+    /** Thread count (default 1 — Node.js WASM is single-threaded) */
+    threadCount?: number;
+    /** Batch character count 1-7 (default 4) */
+    batchCharCount?: number;
+    randomSeeds?: number;
+    cutoff?: string;
+    startBatch?: number;
+    endBatch?: number;
+    specificSeed?: string;
+    palindrome?: boolean;
+    onProgress?: (seedsSearched: number, matchingSeeds: number, elapsedMs: number, resultCount: number) => void;
+    onResult?: (seed: string, score: number) => void;
+}
+export interface ErrorResult {
+    error: string;
+}
+export interface MotelyNodeApi {
+    /** Get runtime capabilities (SIMD, threads, etc.) */
+    getCapabilities(): Promise<CapabilitiesInfo>;
+    /** Analyze a single seed. Returns full ante-by-ante breakdown. */
+    analyzeSeed(seed: string, deck: string, stake: string): Promise<SeedAnalysisInfo>;
+    /** Validate a JAML filter string. */
+    validateJaml(jamlContent: string): Promise<ValidateResult>;
+    /**
+     * Start a JAML search. Returns a Promise that resolves when search completes.
+     * Progress is pushed to onProgress/onResult callbacks.
+     */
+    startJamlSearch(jamlContent: string, options?: SearchOptions): Promise<void>;
+    /** Dispose and cleanup */
+    dispose(): void;
+}
+declare global {
+    var __motelyOnProgress: (totalSeedsSearched: number, matchingSeeds: number, elapsedMs: number, resultCount: number) => void;
+    var __motelyOnResult: (seed: string, score: number) => void;
+}
+/**
+ * Load the Motely WASM runtime for Node.js and return the API.
+ * Uses the browser WASM build with Node.js runtime adapter.
+ * Call once at app startup; the returned object is reusable.
+ */
+export declare function loadMotely(options?: {
+    frameworkPath?: string;
+}): Promise<MotelyNodeApi>;

package/index.js

@@ -0,0 +1,72 @@
+// Motely Node.js Package Entry Point
+// Uses the browser WASM build with Node.js runtime adapter
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+/**
+ * Load the Motely WASM runtime for Node.js and return the API.
+ * Uses the browser WASM build with Node.js runtime adapter.
+ * Call once at app startup; the returned object is reusable.
+ */
+export async function loadMotely(options) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const defaultFrameworkPath = join(__dirname, '_framework');
+    const frameworkPath = options?.frameworkPath || defaultFrameworkPath;
+    const dotnetJsPath = join(frameworkPath, 'dotnet.js');
+    // Install no-op callbacks before runtime boots
+    globalThis.__motelyOnProgress = () => { };
+    globalThis.__motelyOnResult = () => { };
+    // Convert to file:// URL for dynamic import
+    const dotnetUrl = pathToFileURL(dotnetJsPath).href;
+    // Dynamic import of .NET WASM entry point
+    const { dotnet } = await import(dotnetUrl);
+    const runtime = await dotnet.create();
+    const config = runtime.getConfig();
+    const allExports = await runtime.getAssemblyExports(config.mainAssemblyName);
+    const raw = allExports.Motely.BrowserWasm.MotelyWasmExports;
+    runtime.runMain().catch(err => console.error('[motely-node] runMain failed:', err));
+    const [versionJson, capabilitiesJson] = await Promise.all([
+        raw.GetVersionAsync(),
+        raw.GetCapabilitiesAsync(),
+    ]);
+    const cachedCapabilities = JSON.parse(capabilitiesJson);
+    const api = {
+        async getCapabilities() {
+            return cachedCapabilities;
+        },
+        async analyzeSeed(seed, deck, stake) {
+            const json = await raw.AnalyzeSeedAsync(seed, deck, stake);
+            const result = JSON.parse(json);
+            if (result.error && !result.seed)
+                throw new Error(result.error);
+            return result;
+        },
+        async validateJaml(jaml) {
+            const json = await raw.ValidateJamlAsync(jaml);
+            return JSON.parse(json);
+        },
+        async startJamlSearch(jamlContent, options) {
+            const { onProgress, onResult, ...searchParams } = options ?? {};
+            globalThis.__motelyOnProgress = onProgress ?? (() => { });
+            globalThis.__motelyOnResult = onResult ?? (() => { });
+            // Default threadCount=1 and batchCharCount=4 for Node.js single-threaded WASM
+            const withDefaults = {
+                threadCount: 1,
+                batchCharCount: 4,
+                ...searchParams,
+            };
+            const optionsJson = JSON.stringify(withDefaults);
+            const resultJson = await raw.StartJamlSearch(jamlContent, optionsJson);
+            globalThis.__motelyOnProgress = () => { };
+            globalThis.__motelyOnResult = () => { };
+            const result = JSON.parse(resultJson);
+            if (result.error)
+                throw new Error(result.error);
+        },
+        dispose: () => {
+            raw.DisposeSearch();
+        },
+    };
+    return api;
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "motely-node",
+  "version": "2.2.0",
+  "description": "MotelyJAML for Node.js/V8 - Balatro seed analyzer and JAML filter engine using .NET WASM",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.cjs",
+      "types": "./index.d.ts"
+    },
+    "./jaml.schema.json": "./jaml.schema.json"
+  },
+  "files": [
+    "_framework/",
+    "index.js",
+    "index.cjs",
+    "index.d.ts",
+    "README.md",
+    "jaml.schema.json"
+  ],
+  "keywords": [
+    "balatro",
+    "seed",
+    "wasm",
+    "webassembly",
+    "dotnet",
+    "node",
+    "v8",
+    "jaml",
+    "filter",
+    "finder",
+    "search"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OptimusPi/MotelyJAML.git",
+    "directory": "Motely.node"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "copy-framework": "node copy-framework.js",
+    "prepare": "npm run build && npm run copy-framework",
+    "prepublishOnly": "npm run build"
+  }
+}