@ruvector/ruvllm 2.7.0 → 3.0.0

package/README.md

@@ -26,20 +26,91 @@ const llm = new RuvLLM();
 // Or with custom configuration
 const llm = new RuvLLM({ embeddingDim: 384, learningEnabled: true });
 
-// Routing, memory and embeddings
+// Routing, memory and embeddings (no model needed)
 const decision = llm.route('Explain quantum computing');
 llm.addMemory('RuvLLM routes queries with FastGRNN', { source: 'docs' });
 const hits = llm.searchMemory('how are queries routed?', 3);
 const vec = llm.embed('Explain quantum computing');
 ```
 
-> **Text generation.** This package does not load model files (`modelPath` is
-> ignored), and the native engine has no language-model weights, so the text
-> returned by `generate()` and `query()` is not model output. The first such
-> call emits a `RUVLLM_NO_LANGUAGE_MODEL` warning; pass `{ strict: true }` to
-> throw instead. For GGUF inference, run the CLI (`ruvllm serve <model>`, with
-> `--strict` to exit if the model fails to load) or any OpenAI-compatible
-> server, and call it over HTTP.
+## Text Generation (GGUF)
+
+Text comes only from a model you load. `loadModel()` runs a local GGUF file
+on the native candle backend (CPU; Metal on macOS builds with the `metal`
+feature):
+
+```typescript
+const llm = new RuvLLM();
+llm.loadModel('./qwen2.5-0.5b-instruct-q4_k_m.gguf', { maxContext: 4096 });
+
+const out = llm.chat([{ role: 'user', content: 'What is the capital of France?' }], {
+  maxTokens: 64,
+  temperature: 0,
+});
+// { text: 'The capital of France is Paris.', promptTokens: 15,
+//   completionTokens: 8, finishReason: 'stop' }
+```
+
+- **Architectures**: GGUF `llama`, `mistral`, `qwen2` (Qwen2.5) and `qwen3`.
+  Any other architecture (phi, gemma, qwen3.5, ...) fails to load with an error
+  naming it.
+- **Tokenizer**: a `tokenizer.json` next to the GGUF, else the tokenizer
+  embedded in the GGUF. The embedded one works for byte-level BPE (`gpt2`)
+  vocabularies such as Qwen and Llama 3; GGUFs with a SentencePiece vocabulary
+  (Llama 2, Mistral, TinyLlama) need the `tokenizer.json`, otherwise loading
+  fails with `RUVLLM_TOKENIZER_MISSING`.
+- **`chat()`** applies the model's chat template, read from the GGUF's
+  embedded `tokenizer.chat_template` (ChatML for Qwen). A `qwen2`/`qwen3` GGUF
+  whose template is not ChatML (e.g. DeepSeek-R1-Distill-Qwen) fails to load
+  with `RUVLLM_MODEL_LOAD_FAILED` rather than run under the wrong format.
+- **`generate()`** continues the prompt verbatim; **`query()`** routes, then
+  answers as a single chat message.
+- **Usage**: `promptTokens`/`completionTokens` are counted with the model's
+  tokenizer; `finishReason` is `stop` (end-of-sequence token or a stop
+  sequence) or `length` (`maxTokens` reached or the context is full).
+- **Blocking**: loading and generation are synchronous and block the event
+  loop; run them in a worker thread if that matters.
+
+Without a loaded model, `generate()`, `query()`, `chat()` and
+`generateDetailed()` throw `RUVLLM_NO_LANGUAGE_MODEL`; they never return text
+that is not model output. For demos and tests, `new RuvLLM({ allowPlaceholder:
+true })` (or `RUVLLM_ALLOW_MOCK=1`) makes `generate()`/`query()` return the
+labelled `PLACEHOLDER_TEXT` instead, with a one-time warning.
+
+### Native binary requirements
+
+Model loading needs a native binary built with the `candle` feature;
+`supportsModelLoading()` reports whether the installed one was.
+
+| Native binary | `loadModel()` |
+|---------------|---------------|
+| Built from this source (`npm run build:native`) | Works |
+| `@ruvector/ruvllm-<platform>` 3.x (built by the release workflow with `candle`) | Works |
+| `@ruvector/ruvllm-<platform>` 2.0.x | Throws `RUVLLM_NATIVE_TOO_OLD`: they predate model loading |
+| Built with `--features napi` only (no `candle`) | Throws `RUVLLM_NO_INFERENCE_BACKEND` |
+| None for your platform | Throws `RUVLLM_NATIVE_UNAVAILABLE` |
+
+To use a binary you built, point `RUVLLM_NATIVE_PATH` at it (it takes
+precedence over the installed platform package):
+
+```bash
+npm run build:native   # writes ruvllm.<platform>.node (needs a Rust toolchain)
+RUVLLM_NATIVE_PATH=$PWD/ruvllm.linux-x64-gnu.node node app.js
+```
+
+Until the 3.x platform packages are on npm, build the binary from source as
+above, or use the ruvllm CLI (`ruvllm serve <model>`, an OpenAI-compatible
+server that exits if the model fails to load).
+
+| Error code | Meaning |
+|------------|---------|
+| `RUVLLM_NO_LANGUAGE_MODEL` | Generation was requested with no model loaded |
+| `RUVLLM_NATIVE_UNAVAILABLE` | No native binary could be loaded |
+| `RUVLLM_NATIVE_TOO_OLD` | The native binary predates model loading (2.0.x platform packages) |
+| `RUVLLM_NO_INFERENCE_BACKEND` | The native binary was built without the `candle` backend |
+| `RUVLLM_MODEL_NOT_FOUND` | The model path does not exist |
+| `RUVLLM_MODEL_LOAD_FAILED` | The file could not be loaded (unsupported architecture, not GGUF, ...) |
+| `RUVLLM_TOKENIZER_MISSING` | Weights loaded but no usable tokenizer was found |
 
 ## What's New in v2.5
 
@@ -82,9 +153,10 @@ import { simd } from '@ruvector/ruvllm/simd';
 ## CLI Usage
 
 ```bash
-# Query a model
-ruvllm query "What is machine learning?"
+# Query a model (this package's `ruvllm` bin; needs --model, see above)
+ruvllm query "What is machine learning?" --model ./qwen2.5-0.5b-instruct-q4_k_m.gguf
 
+# The commands below are the Rust ruvllm CLI (crate ruvllm-cli)
 # Stream output
 ruvllm query --stream "Write a poem"
 
@@ -106,11 +178,18 @@ ruvllm eval --model ./models/model.gguf --subset lite --max-tasks 50
 class RuvLLM {
   constructor(config?: RuvLLMConfig);
 
-  // Routed query; text is not model output (see "Text generation" above)
-  query(text: string, config?: GenerationConfig): QueryResponse;
+  // Language model (see "Text Generation" above)
+  loadModel(path: string, options?: LoadModelOptions): LoadedModelInfo;
+  unloadModel(): void;
+  isModelLoaded(): boolean;
+  modelInfo(): LoadedModelInfo | null;
+  supportsModelLoading(): boolean; // native binary can load models
 
-  // Text from the native engine; not model output (see above)
+  // Generation; all throw RUVLLM_NO_LANGUAGE_MODEL without a loaded model
+  chat(messages: ChatMessage[], config?: GenerationConfig): GenerationResult;
+  generateDetailed(prompt: string, config?: GenerationConfig): GenerationResult;
   generate(prompt: string, config?: GenerationConfig): string;
+  query(text: string, config?: GenerationConfig): QueryResponse; // routed, + token usage
 
   // Routing, memory and embeddings
   route(text: string): RoutingDecision;
@@ -118,8 +197,8 @@ class RuvLLM {
   searchMemory(text: string, k?: number): MemoryResult[];
   embed(text: string): Embedding;
 
-  // Not in this package: loadModel(), stream() (streaming lives in
-  // StreamingGenerator), mistral-rs backends. Use the ruvllm CLI for GGUF.
+  // Not in this package: token streaming (StreamingGenerator chunks a
+  // finished generate() result), mistral-rs backends.
 
   // Get SONA learning stats
   sonaStats(): SonaStats | null;
@@ -133,26 +212,33 @@ class RuvLLM {
 
 ```typescript
 interface RuvLLMConfig {
-  modelPath?: string;       // Not supported: ignored with a RUVLLM_UNSUPPORTED_OPTION warning
-  strict?: boolean;         // Throw instead of warning about placeholder text (default: false)
-  sonaEnabled?: boolean;    // Enable SONA learning (default: true)
-  flashAttention?: boolean; // Use Flash Attention 2 (default: true)
-  maxTokens?: number;       // Max generation tokens (default: 256)
-  temperature?: number;     // Sampling temperature (default: 0.7)
-  topP?: number;            // Top-p sampling (default: 0.9)
+  modelPath?: string;              // GGUF to load in the constructor (throws if it cannot be loaded)
+  modelOptions?: LoadModelOptions; // { maxContext?: number } for modelPath
+  allowPlaceholder?: boolean;      // generate()/query() return PLACEHOLDER_TEXT instead of
+                                   // throwing when no model is loaded (default: false)
+  strict?: boolean;                // Throw instead of warning for unsupported options (`backend`)
+  // ...plus routing/memory options (embeddingDim, hnswM, ...), see types.ts
 }
 ```
 
-### Generate Parameters
+### Generation Config and Result
 
 ```typescript
-interface GenerateParams {
-  maxTokens?: number;
-  temperature?: number;
-  topP?: number;
-  topK?: number;
-  repetitionPenalty?: number;
-  stopSequences?: string[];
+interface GenerationConfig {
+  maxTokens?: number;          // default 256
+  temperature?: number;        // default 0.7; 0 = greedy
+  topP?: number;               // default 0.9, in (0, 1]
+  topK?: number;               // default 50; 0 disables
+  repetitionPenalty?: number;  // default 1.1
+  stopSequences?: string[];    // stop text is not included in the output
+  seed?: number;               // reproducible sampling at temperature > 0
+}
+
+interface GenerationResult {
+  text: string;
+  promptTokens: number;        // after the chat template, for chat()
+  completionTokens: number;    // includes an end-of-sequence token that ended generation
+  finishReason: 'stop' | 'length' | 'cancelled';
 }
 ```
 
@@ -188,6 +274,9 @@ simd.rmsNorm(hidden, weights, epsilon);
 
 ## Evaluation Harness
 
+> **Not in this npm package**: `EvaluationHarness` and `AblationMode` are
+> not exported by `@ruvector/ruvllm`. The sketch below shows the intended API.
+
 Run model evaluations with SWE-Bench integration:
 
 ```typescript
@@ -250,20 +339,30 @@ await llm.loadModel('mistralai/Mistral-7B-Instruct-v0.2');
 const response = await llm.query('Write production code');
 ```
 
-> **Note**: mistral-rs features require the Rust backend with `mistral-rs` feature enabled. Native bindings will use mistral-rs when available.
+> **Not in this npm package**: `MistralBackend` is not exported, the
+> `backend` option is ignored (with a `RUVLLM_UNSUPPORTED_OPTION` warning), and
+> `loadModel()` takes a local GGUF path, not a Hub id. mistral-rs serving is a
+> feature of the Rust crate (`mistral-rs` feature).
 
 ## Supported Models
 
+GGUF files loadable with `loadModel()` (architectures llama, mistral, qwen2, qwen3):
+
 - **RuvLTRA-Small** (494M) - Q4K, Q5K, Q8
 - **RuvLTRA-Medium** (3B) - Q4K, Q5K, Q8
-- **Qwen 2.5** (0.5B-72B)
+- **Qwen 2.5 / Qwen 3** (0.5B-72B)
 - **Llama 3.x** (8B-70B)
 - **Mistral** (7B-22B)
-- **Phi-3** (3.8B-14B)
-- **Gemma-2** (2B-27B)
+
+Phi-3, Gemma-2 and Qwen3.5 GGUFs are not supported: loading fails with an
+error naming the architecture.
 
 ## Platform Support
 
+The table covers routing, memory and embeddings. Model loading additionally
+needs a native binary built with the `candle` feature (see "Native binary
+requirements").
+
 | Platform | Architecture | Status |
 |----------|--------------|--------|
 | macOS | arm64 (M1-M4) | ✅ Full support |

package/bin/cli.js

@@ -3,8 +3,8 @@
  * RuvLLM CLI - Self-learning LLM orchestration
  *
  * Usage:
- *   ruvllm query "What is machine learning?"
- *   ruvllm generate "Write a haiku about AI"
+ *   ruvllm query "What is machine learning?" --model ./model.gguf
+ *   ruvllm generate "Write a haiku about AI" --model ./model.gguf
  *   ruvllm memory add "Important context"
  *   ruvllm memory search "context"
  *   ruvllm models list
@@ -54,33 +54,46 @@ function formatTable(data) {
 }
 
 // Commands
-async function runQuery(llm, text, flags) {
+function generationConfig(flags) {
   const config = {};
   if (flags.temperature) config.temperature = parseFloat(flags.temperature);
   if (flags['max-tokens']) config.maxTokens = parseInt(flags['max-tokens']);
   if (flags['top-p']) config.topP = parseFloat(flags['top-p']);
   if (flags['top-k']) config.topK = parseInt(flags['top-k']);
+  return config;
+}
 
-  const response = llm.query(text, config);
+// query/generate need a model: without --model they fail with
+// RUVLLM_NO_LANGUAGE_MODEL (and the CLI exits 1).
+function loadModelFromFlags(llm, flags) {
+  if (!flags.model || flags.model === true) return;
+  const options = {};
+  if (flags['max-context']) options.maxContext = parseInt(flags['max-context']);
+  const info = llm.loadModel(flags.model, options);
+  if (!flags.json) console.error(`Loaded ${info.name} (${info.architecture}, ${info.quantization ?? 'quantization unknown'})`);
+}
+
+async function runQuery(llm, text, flags) {
+  loadModelFromFlags(llm, flags);
+  const response = llm.query(text, generationConfig(flags));
 
   if (flags.json) {
     console.log(formatJson(response));
   } else {
     console.log('\n' + response.text);
-    console.log(`\n--- Model: ${response.model} | Confidence: ${(response.confidence * 100).toFixed(1)}% | Latency: ${response.latencyMs.toFixed(2)}ms ---`);
+    console.log(`\n--- Route: ${response.model} | Confidence: ${(response.confidence * 100).toFixed(1)}% | Tokens: ${response.promptTokens}+${response.completionTokens} (${response.finishReason}) | Latency: ${response.latencyMs.toFixed(2)}ms ---`);
   }
 }
 
 async function runGenerate(llm, prompt, flags) {
-  console.error('Warning: Built-in SIMD inference is experimental. For production use, configure an external LLM provider (Ollama, OpenAI, etc.).');
-
-  const config = {};
-  if (flags.temperature) config.temperature = parseFloat(flags.temperature);
-  if (flags['max-tokens']) config.maxTokens = parseInt(flags['max-tokens']);
-  if (flags['top-p']) config.topP = parseFloat(flags['top-p']);
+  loadModelFromFlags(llm, flags);
+  const config = generationConfig(flags);
 
-  const text = llm.generate(prompt, config);
-  console.log(text);
+  if (flags.json) {
+    console.log(formatJson(llm.generateDetailed(prompt, config)));
+  } else {
+    console.log(llm.generate(prompt, config));
+  }
 }
 
 async function runMemoryAdd(llm, content, flags) {
@@ -780,8 +793,9 @@ RuvLLM - Self-learning LLM Orchestration
 Usage: ruvllm <command> [options]
 
 Commands:
-  query <text>              Query the LLM with automatic routing
-  generate <prompt>         Generate text with SIMD inference
+  query <text> --model <gguf>     Route, then answer with the model (chat template)
+  generate <prompt> --model <gguf>
+                            Continue a raw prompt with the model
   route <text>              Get routing decision for query
   memory add <content>      Add content to memory
   memory search <query>     Search memory for similar content
@@ -813,7 +827,10 @@ Training & Fine-tuning:
 
 Options:
   --json                    Output as JSON
-  --temperature <float>     Sampling temperature (0.0-2.0)
+  --model <path>            GGUF file to load for query/generate (required for them;
+                            needs a native binary with model support, see README)
+  --max-context <int>       Context window for --model (default: 4096)
+  --temperature <float>     Sampling temperature (0 = greedy)
   --max-tokens <int>        Maximum tokens to generate
   --top-p <float>           Nucleus sampling (0.0-1.0)
   --top-k <int>             Top-k sampling
@@ -835,8 +852,8 @@ Available Models (from https://huggingface.co/ruv/ruvltra):
   medium                    RuvLTRA Medium (669MB) - General purpose
 
 Examples:
-  ruvllm query "What is machine learning?"
-  ruvllm generate "Write a poem about AI" --temperature 0.9
+  ruvllm query "What is machine learning?" --model ./qwen2.5-0.5b-instruct-q4_k_m.gguf
+  ruvllm generate "Once upon a time" --model ./model.gguf --max-tokens 64 --json
   ruvllm memory add "Important context" --metadata '{"type":"note"}'
   ruvllm memory search "context" --k 5
   ruvllm similarity "hello world" "hi there"
@@ -1007,6 +1024,9 @@ async function main() {
     }
   } catch (error) {
     console.error('Error:', error.message);
+    if (error.code === 'RUVLLM_NO_LANGUAGE_MODEL') {
+      console.error('Hint: pass --model <path to a GGUF file>');
+    }
     if (flags.verbose) {
       console.error(error.stack);
     }

package/dist/cjs/engine.d.ts

@@ -1,48 +1,113 @@
 /**
  * RuvLLM Engine - Main orchestrator for self-learning LLM
  */
-import { RuvLLMConfig, GenerationConfig, QueryResponse, RoutingDecision, MemoryResult, MemoryId, RuvLLMStats, Feedback, Embedding, BatchQueryRequest, BatchQueryResponse } from './types';
+import { RuvLLMConfig, GenerationConfig, QueryResponse, RoutingDecision, MemoryResult, MemoryId, RuvLLMStats, Feedback, Embedding, BatchQueryRequest, BatchQueryResponse, ChatMessage, GenerationResult, LoadModelOptions, LoadedModelInfo } from './types';
+/** Returned by generate()/query() only with `allowPlaceholder` / `RUVLLM_ALLOW_MOCK=1`. */
+export declare const PLACEHOLDER_TEXT = "[RuvLLM placeholder: no language model is loaded; this text is not model output]";
 /**
  * RuvLLM - Self-learning LLM orchestrator
  *
- * Combines SONA adaptive learning with HNSW memory,
- * FastGRNN routing, and SIMD-optimized inference.
+ * Combines SONA adaptive learning with HNSW memory, FastGRNN routing, and
+ * GGUF inference through the native candle backend.
+ *
+ * Text comes only from a model loaded with `loadModel()` (or the `modelPath`
+ * option). Without one, `generate()`, `query()`, `chat()` and
+ * `generateDetailed()` throw `RUVLLM_NO_LANGUAGE_MODEL`.
  *
  * @example
  * ```typescript
  * import { RuvLLM } from '@ruvector/ruvllm';
  *
- * const llm = new RuvLLM({ embeddingDim: 768 });
+ * const llm = new RuvLLM();
+ * llm.loadModel('./qwen2.5-0.5b-instruct-q4_k_m.gguf');
  *
- * // Query with automatic routing
- * const response = await llm.query('What is machine learning?');
- * console.log(response.text);
+ * const out = llm.chat([{ role: 'user', content: 'What is machine learning?' }], {
+ *   maxTokens: 128,
+ * });
+ * console.log(out.text, out.finishReason, out.completionTokens);
  *
- * // Provide feedback for learning
+ * // Routed query, answered by the loaded model
+ * const response = llm.query('What is machine learning?');
  * llm.feedback({ requestId: response.requestId, rating: 5 });
  * ```
  */
 export declare class RuvLLM {
     private native;
+    private nativeVersion;
     private config;
+    private allowPlaceholder;
     private fallbackState;
     /**
      * Create a new RuvLLM instance
      */
     constructor(config?: RuvLLMConfig);
     /**
-     * Query the LLM with automatic routing
+     * Whether the native binary can load and run a language model. False
+     * without a native binary, for binaries that predate `loadModel` (the 2.0.x
+     * `@ruvector/ruvllm-<platform>` packages), and for binaries built without
+     * the `candle` inference backend.
+     */
+    supportsModelLoading(): boolean;
+    /** Error for a binary that has `loadModel` but no inference backend. */
+    private noBackendError;
+    /**
+     * Load a GGUF model (or a directory holding one) for `generate()`,
+     * `chat()` and `query()`. Supported GGUF architectures: llama, mistral,
+     * qwen2, qwen3; others fail with an error naming the architecture. The
+     * tokenizer comes from a `tokenizer.json` beside the file, else from the
+     * GGUF itself. Replaces any loaded model; if loading fails, no model is
+     * loaded. Synchronous: blocks the event loop while the weights load.
+     *
+     * @throws `RUVLLM_NATIVE_UNAVAILABLE` without a native binary,
+     *   `RUVLLM_NATIVE_TOO_OLD` when the binary predates model loading,
+     *   `RUVLLM_NO_INFERENCE_BACKEND` when it was built without `candle`,
+     *   `RUVLLM_MODEL_NOT_FOUND` / `RUVLLM_MODEL_LOAD_FAILED` from the backend.
+     */
+    loadModel(path: string, options?: LoadModelOptions): LoadedModelInfo;
+    /**
+     * Unload the language model and free its memory
+     */
+    unloadModel(): void;
+    /**
+     * Whether a language model is loaded
+     */
+    isModelLoaded(): boolean;
+    /**
+     * The loaded language model, or null
+     */
+    modelInfo(): LoadedModelInfo | null;
+    /**
+     * Route `text`, then answer it with the loaded model (as one user message
+     * under the model's chat template).
+     *
+     * @throws `RUVLLM_NO_LANGUAGE_MODEL` when no model is loaded, unless
+     *   `allowPlaceholder` is set (then `text` is `PLACEHOLDER_TEXT`).
      */
     query(text: string, config?: GenerationConfig): QueryResponse;
     /**
-     * Generate text with SIMD-optimized inference
+     * Continue `prompt` verbatim with the loaded model (no chat template; use
+     * `chat()` for instruction-tuned models). Returns the generated text.
      *
-     * Note: the native engine has no language-model weights, so its text is
-     * not model output; the first call emits a `RUVLLM_NO_LANGUAGE_MODEL`
-     * warning (or throws with `strict: true`). Without the native module this
-     * returns an informational message.
+     * @throws `RUVLLM_NO_LANGUAGE_MODEL` when no model is loaded, unless
+     *   `allowPlaceholder` is set (then it returns `PLACEHOLDER_TEXT`).
      */
     generate(prompt: string, config?: GenerationConfig): string;
+    /**
+     * Like `generate()`, with token counts (from the model's tokenizer) and
+     * the finish reason. Always throws `RUVLLM_NO_LANGUAGE_MODEL` without a
+     * loaded model.
+     */
+    generateDetailed(prompt: string, config?: GenerationConfig): GenerationResult;
+    /**
+     * Run the loaded model on a conversation, formatted with the model's chat
+     * template (ChatML for Qwen, Llama 3 / Mistral formats for those models).
+     * Always throws `RUVLLM_NO_LANGUAGE_MODEL` without a loaded model.
+     */
+    chat(messages: ChatMessage[], config?: GenerationConfig): GenerationResult;
+    private requireModel;
+    private noModelError;
+    /** Throw `RUVLLM_NO_LANGUAGE_MODEL`, or return the labelled placeholder when opted in. */
+    private placeholderOrThrow;
     /**
      * Get routing decision for a query
      */

package/dist/cjs/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/engine.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,SAAS,EACT,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AA+DjB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,MAAM,CAAe;IAG7B,OAAO,CAAC,aAAa,CAInB;IAEF;;OAEG;gBACS,MAAM,CAAC,EAAE,YAAY;IAwBjC;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,aAAa;IA6B7D;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,MAAM;IA0B3D;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;IAsBpC;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,SAAK,GAAG,YAAY,EAAE;IAmClD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ;IAexE;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO;IAO/B;;OAEG;IACH,KAAK,IAAI,WAAW;IA8BpB;;OAEG;IACH,UAAU,IAAI,MAAM;IAOpB;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;IAmB9B;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IA6BhD;;OAEG;IACH,OAAO,IAAI,OAAO;IAOlB;;OAEG;IACH,gBAAgB,IAAI,MAAM,EAAE;IAO5B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,kBAAkB;IAS1D;;OAEG;IACH,cAAc,IAAI,OAAO;CAG1B"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/engine.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,SAAS,EACT,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EAEX,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EAChB,MAAM,SAAS,CAAC;AAsHjB,2FAA2F;AAC3F,eAAO,MAAM,gBAAgB,qFACuD,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,gBAAgB,CAAU;IAGlC,OAAO,CAAC,aAAa,CAInB;IAEF;;OAEG;gBACS,MAAM,CAAC,EAAE,YAAY;IA4BjC;;;;;OAKG;IACH,oBAAoB,IAAI,OAAO;IAQ/B,wEAAwE;IACxE,OAAO,CAAC,cAAc;IAUtB;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe;IA2BpE;;OAEG;IACH,WAAW,IAAI,IAAI;IAInB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,SAAS,IAAI,eAAe,GAAG,IAAI;IAKnC;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,aAAa;IA8B7D;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAK3D;;;;OAIG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,gBAAgB;IAO7E;;;;OAIG;IACH,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,gBAAgB;IAK1E,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,YAAY;IA0BpB,0FAA0F;IAC1F,OAAO,CAAC,kBAAkB;IAW1B;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;IAsBpC;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,SAAK,GAAG,YAAY,EAAE;IAmClD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ;IAexE;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO;IAO/B;;OAEG;IACH,KAAK,IAAI,WAAW;IA8BpB;;OAEG;IACH,UAAU,IAAI,MAAM;IAOpB;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;IAmB9B;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IA6BhD;;OAEG;IACH,OAAO,IAAI,OAAO;IAOlB;;OAEG;IACH,gBAAgB,IAAI,MAAM,EAAE;IAO5B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,kBAAkB;IAS1D;;OAEG;IACH,cAAc,IAAI,OAAO;CAG1B"}