mcard-js 2.1.41 → 2.1.43

package/dist/{chunk-K35KFTEA.js → chunk-N6KDHCBC.js}

@@ -4,15 +4,21 @@ import {
   LLMConfig,
   LLM_PROVIDERS,
   OllamaProvider
-} from "./chunk-QXPHMSPA.js";
+} from "./chunk-GNF4WAPV.js";
 import {
   IO
 } from "./chunk-MPMRBT5R.js";
 import {
   Either
 } from "./chunk-2KADE3SE.js";
+import {
+  LLM_DEFAULT_TIMEOUT_SECS
+} from "./chunk-A5S2PI37.js";
 
 // src/ptr/llm/providers/WebLLMProvider.ts
+function asOptionalNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
 var WebLLMProvider = class extends BaseLLMProvider {
   provider_name = "webllm";
   config;
@@ -38,11 +44,13 @@ var WebLLMProvider = class extends BaseLLMProvider {
         if (typeof window === "undefined") {
           throw new Error("WebLLM only supports browser environments.");
         }
-        let webllm = window.webllm;
+        const windowWithWebLLM = window;
+        let webllm = windowWithWebLLM.webllm;
         if (!webllm) {
           try {
             webllm = await import("@mlc-ai/web-llm");
           } catch (e) {
+            void e;
           }
         }
         if (!webllm) {
@@ -69,42 +77,44 @@ var WebLLMProvider = class extends BaseLLMProvider {
       return Either.right(this.engine);
     } catch (e) {
       this.initialization_promise = null;
-      return Either.left(`WebLLM init failed: ${e.message || e}`);
+      const error = e;
+      return Either.left(`WebLLM init failed: ${error.message || String(e)}`);
     }
   }
-  async complete(prompt, params) {
-    const model = params.model || this.config.default_model;
+  async complete(prompt, params, images) {
+    const model = typeof params.model === "string" ? params.model : this.config.default_model;
     const engineResult = await this._get_engine(model);
     if (engineResult.isLeft) return Either.left(engineResult.left);
     const engine = engineResult.right;
     try {
       const completion = await engine.chat.completions.create({
         messages: [{ role: "user", content: prompt }],
-        temperature: params.temperature,
-        max_tokens: params.max_tokens,
-        top_p: params.top_p,
+        temperature: asOptionalNumber(params.temperature),
+        max_tokens: asOptionalNumber(params.max_tokens),
+        top_p: asOptionalNumber(params.top_p),
         stream: false
       });
-      const content = completion.choices[0]?.message?.content || "";
+      const content = completion.choices?.[0]?.message?.content || "";
       return Either.right(content);
     } catch (e) {
-      return Either.left(`WebLLM completion error: ${e.message || e}`);
+      const error = e;
+      return Either.left(`WebLLM completion error: ${error.message || String(e)}`);
     }
   }
   async chat(messages, params) {
-    const model = params.model || this.config.default_model;
+    const model = typeof params.model === "string" ? params.model : this.config.default_model;
     const engineResult = await this._get_engine(model);
     if (engineResult.isLeft) return Either.left(engineResult.left);
     const engine = engineResult.right;
     try {
       const completion = await engine.chat.completions.create({
         messages,
-        temperature: params.temperature,
-        max_tokens: params.max_tokens,
-        top_p: params.top_p,
+        temperature: asOptionalNumber(params.temperature),
+        max_tokens: asOptionalNumber(params.max_tokens),
+        top_p: asOptionalNumber(params.top_p),
         stream: false
       });
-      const choice = completion.choices[0];
+      const choice = completion.choices?.[0];
       return Either.right({
         content: choice?.message?.content || "",
         role: choice?.message?.role || "assistant",
@@ -112,7 +122,8 @@ var WebLLMProvider = class extends BaseLLMProvider {
         usage: completion.usage
       });
     } catch (e) {
-      return Either.left(`WebLLM chat error: ${e.message || e}`);
+      const error = e;
+      return Either.left(`WebLLM chat error: ${error.message || String(e)}`);
     }
   }
   async validate_connection() {
@@ -138,7 +149,7 @@ var MLCLLMProvider = class extends BaseLLMProvider {
   base_url;
   timeout;
   config;
-  constructor(base_url = null, timeout = 120) {
+  constructor(base_url = null, timeout = LLM_DEFAULT_TIMEOUT_SECS) {
     super();
     this.config = LLM_PROVIDERS["mlc-llm"];
     this.base_url = (base_url || this.config.base_url).replace(/\/$/, "");
@@ -160,7 +171,8 @@ var MLCLLMProvider = class extends BaseLLMProvider {
         const data = await response.json();
         return Either.right(data);
       } catch (e) {
-        return Either.left(`Connection error: ${e.message}`);
+        const error = e;
+        return Either.left(`Connection error: ${error.message || String(e)}`);
       }
     }
     return this._node_request(endpoint, options);
@@ -202,10 +214,10 @@ var MLCLLMProvider = class extends BaseLLMProvider {
       req.end();
     });
   }
-  async complete(prompt, params) {
+  async complete(prompt, params, images) {
     const data = {
-      model: params.model || this.config.default_model,
-      prompt,
+      model: typeof params.model === "string" ? params.model : this.config.default_model,
+      messages: [{ role: "user", content: prompt }],
       max_tokens: params.max_tokens,
       temperature: params.temperature,
       top_p: params.top_p,
@@ -242,8 +254,8 @@ var MLCLLMProvider = class extends BaseLLMProvider {
     if (response.choices && response.choices.length > 0) {
       const message = response.choices[0].message;
       return Either.right({
-        content: message.content,
-        role: message.role,
+        content: message?.content || "",
+        role: message?.role || "assistant",
         model: response.model,
         usage: response.usage
       });
@@ -259,14 +271,14 @@ var MLCLLMProvider = class extends BaseLLMProvider {
     if (result.isLeft) return Either.left(result.left);
     const response = result.right;
     if (response.data && Array.isArray(response.data)) {
-      return Either.right(response.data.map((m) => m.id));
+      return Either.right(response.data.map((m) => m.id).filter((id) => typeof id === "string"));
     }
     return Either.left("Invalid models response");
   }
 };
 
 // src/ptr/llm/LLMRuntime.ts
-function get_provider(provider_name = DEFAULT_PROVIDER, base_url = null, timeout = 120) {
+function get_provider(provider_name = DEFAULT_PROVIDER, base_url = null, timeout = LLM_DEFAULT_TIMEOUT_SECS) {
   if (provider_name === "ollama") {
     return new OllamaProvider(base_url, timeout);
   }
@@ -301,32 +313,45 @@ var LLMRuntime = class {
       this._provider = get_provider(llmConfig.provider, llmConfig.endpoint_url, llmConfig.timeout);
     }
     let prompt = "";
+    let images;
     if (typeof context === "string") {
       prompt = context;
-    } else {
-      prompt = JSON.stringify(context);
+    } else if (context && typeof context === "object") {
+      const ctx = context;
+      if (typeof ctx.prompt === "string") {
+        prompt = ctx.prompt;
+        if (Array.isArray(ctx.images)) {
+          images = ctx.images;
+        }
+      } else {
+        prompt = JSON.stringify(context);
+      }
     }
     let result;
     if (llmConfig.system_prompt) {
-      result = await this._execute_chat(prompt, llmConfig);
+      result = await this._execute_chat(prompt, llmConfig, images);
     } else {
-      result = await this._execute_completion(prompt, llmConfig);
+      result = await this._execute_completion(prompt, llmConfig, images);
     }
     if (result.isLeft) {
       return `Error: ${result.left}`;
     }
     return this._format_response(result.right, llmConfig);
   }
-  async _execute_completion(prompt, config) {
+  async _execute_completion(prompt, config, images) {
     const params = config.to_provider_params();
-    return this.provider.complete(prompt, params);
+    return this.provider.complete(prompt, params, images);
   }
-  async _execute_chat(prompt, config) {
+  async _execute_chat(prompt, config, images) {
     const messages = [];
     if (config.system_prompt) {
       messages.push({ role: "system", content: config.system_prompt });
     }
-    messages.push({ role: "user", content: prompt });
+    const userMsg = { role: "user", content: prompt };
+    if (images && images.length > 0) {
+      userMsg.images = images;
+    }
+    messages.push(userMsg);
     if (config.assistant_instruction) {
       messages.push({ role: "assistant", content: config.assistant_instruction });
     }

package/dist/{chunk-2R4ESMZB.js → chunk-NFO5NU6B.js}

@@ -1,11 +1,13 @@
 import {
   AbstractSqlEngine,
   CORE_SCHEMAS
-} from "./chunk-RSTKX7WM.js";
+} from "./chunk-BFD4WSWU.js";
+import {
+  DEFAULT_SQLJS_WASM_URL
+} from "./chunk-A5S2PI37.js";
 import {
-  DEFAULT_SQLJS_WASM_URL,
   MCard
-} from "./chunk-3MMMJ7NH.js";
+} from "./chunk-2NFGZ6PA.js";
 
 // src/storage/engines/SqliteWasmEngine.ts
 var SqliteWasmEngine = class extends AbstractSqlEngine {

package/dist/chunk-OKWBHCKC.js

@@ -0,0 +1,170 @@
+import {
+  GTime,
+  HashValidator
+} from "./chunk-7NKII2JA.js";
+
+// src/model/ContentTypeInterpreter.ts
+import { detect_content_type, is_binary_content as wasm_is_binary, get_extension as wasm_ext } from "mcard-wasm";
+var ContentTypeInterpreter = class {
+  static detect(content) {
+    return this.detectContentType(content).mimeType;
+  }
+  static detectContentType(content, fileExtension) {
+    const buffer = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    const result = detect_content_type(buffer, fileExtension);
+    return { mimeType: result[0], extension: result[1] };
+  }
+  static getExtension(mimeType) {
+    return wasm_ext(mimeType) || "bin";
+  }
+  static isBinaryContent(content, mimeType) {
+    const buffer = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    return wasm_is_binary(buffer);
+  }
+  // Stub or bypass irrelevant manual TS rules now managed by mcard-core
+  static registerExtension(mimeType, extension) {
+  }
+  static registerExtensions(mapping) {
+  }
+  static isKnownLongLineExtension(extension) {
+    return false;
+  }
+  static isUnstructuredBinary(sample) {
+    if (sample.length < 512) return false;
+    let nullCount = 0;
+    let controlChars = 0;
+    for (let i = 0; i < sample.length; i++) {
+      const b = sample[i];
+      if (b === 0) nullCount++;
+      if (b < 32 && b !== 9 && b !== 10 && b !== 13) controlChars++;
+    }
+    const nullRatio = nullCount / sample.length;
+    const controlRatio = controlChars / sample.length;
+    return nullRatio > 0.1 || controlRatio > 0.2;
+  }
+  static hasPathologicalLines(sample, isKnownType) {
+    return false;
+  }
+};
+
+// src/types/dots.ts
+function createMCardDOTSMetadata(tightRefs = [], looseRefs = []) {
+  return {
+    role: "Carrier" /* CARRIER */,
+    eosRole: "InvariantContent" /* INVARIANT_CONTENT */,
+    plane: "Data" /* DATA */,
+    tightRefs,
+    looseRefs
+  };
+}
+function createPCardDOTSMetadata(isLens, tightRefs = [], looseRefs = []) {
+  return {
+    role: isLens ? "Lens" /* LENS */ : "Chart" /* CHART */,
+    eosRole: "GenerativeLens" /* GENERATIVE_LENS */,
+    plane: "Control" /* CONTROL */,
+    tightRefs,
+    looseRefs
+  };
+}
+function createVCardDOTSMetadata() {
+  return {
+    role: "Arena" /* ARENA */,
+    eosRole: "SovereignDecision" /* SOVEREIGN_DECISION */,
+    plane: "Application" /* APPLICATION */
+  };
+}
+
+// src/model/MCard.ts
+var MCard = class _MCard {
+  content;
+  hash;
+  g_time;
+  contentType;
+  // Defaulting to specific string or null
+  hashFunction;
+  constructor(content, hash, g_time, contentType, hashFunction) {
+    this.content = content;
+    this.hash = hash;
+    this.g_time = g_time;
+    this.contentType = contentType;
+    this.hashFunction = hashFunction;
+  }
+  /**
+   * Create a new MCard from content
+   */
+  static async create(content, hashAlgorithm = "sha256") {
+    if (content === null || content === void 0) {
+      throw new Error("Content cannot be null or undefined");
+    }
+    const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    if (bytes.length === 0) {
+      throw new Error("Content cannot be empty");
+    }
+    const hash = await HashValidator.computeHash(bytes, hashAlgorithm);
+    const g_time = GTime.stampNow(hashAlgorithm);
+    const contentType = ContentTypeInterpreter.detect(bytes);
+    return new _MCard(bytes, hash, g_time, contentType, hashAlgorithm);
+  }
+  /**
+   * Create an MCard from existing data (e.g., from database)
+   */
+  static fromData(content, hash, g_time) {
+    const alg = GTime.getHashAlgorithm(g_time);
+    const contentType = ContentTypeInterpreter.detect(content);
+    return new _MCard(content, hash, g_time, contentType, alg);
+  }
+  /**
+   * Get content as text (UTF-8 decoded)
+   */
+  getContentAsText() {
+    return new TextDecoder().decode(this.content);
+  }
+  /**
+   * Get content as raw bytes
+   */
+  getContent() {
+    return this.content;
+  }
+  /**
+   * Convert to plain object
+   */
+  toObject() {
+    return {
+      hash: this.hash,
+      content: this.getContentAsText(),
+      g_time: this.g_time,
+      contentType: this.contentType,
+      hashFunction: this.hashFunction
+    };
+  }
+  /**
+   * Get DOTS vocabulary metadata for this MCard
+   * 
+   * Returns the DOTS role information that positions this MCard
+   * in the Double Operadic Theory of Systems framework.
+   * 
+   * MCard is always a CARRIER object in the Data Plane.
+   * 
+   * @param tightRefs - Optional array of prerequisite MCard hashes (vertical composition)
+   * @param looseRefs - Optional array of alternative MCard hashes (horizontal composition)
+   * @returns DOTSMetadata describing this card's role in the compositional system
+   * 
+   * @example
+   * ```typescript
+   * const card = await MCard.create('Hello World');
+   * const meta = card.getDOTSMetadata();
+   * console.log(meta.role);  // 'Carrier'
+   * console.log(meta.plane); // 'Data'
+   * ```
+   */
+  getDOTSMetadata(tightRefs = [], looseRefs = []) {
+    return createMCardDOTSMetadata(tightRefs, looseRefs);
+  }
+};
+
+export {
+  ContentTypeInterpreter,
+  createPCardDOTSMetadata,
+  createVCardDOTSMetadata,
+  MCard
+};

package/dist/{chunk-FIE4LAJG.js → chunk-OX3K6UZJ.js}

@@ -1,7 +1,7 @@
 import {
   AbstractSqlEngine,
   initCoreSchemas
-} from "./chunk-RSTKX7WM.js";
+} from "./chunk-4VWWTGRW.js";
 import {
   createPage
 } from "./chunk-3EIBJPNF.js";
@@ -11,9 +11,11 @@ import {
 } from "./chunk-ADV52544.js";
 import {
   DEFAULT_PAGE_SIZE,
-  MCard,
   SQLITE_BUSY_TIMEOUT_MS
-} from "./chunk-3MMMJ7NH.js";
+} from "./chunk-BSEFN25Q.js";
+import {
+  MCard
+} from "./chunk-OKWBHCKC.js";
 import {
   __toCommonJS
 } from "./chunk-PNKVD2UK.js";

package/dist/{chunk-6SEX42H2.js → chunk-R3K7DG7O.js}

@@ -1,10 +1,10 @@
 import {
   ContentTypeInterpreter,
   MCard
-} from "./chunk-SOJ2UMO2.js";
+} from "./chunk-OKWBHCKC.js";
 import {
   __export
-} from "./chunk-SIAA4J6H.js";
+} from "./chunk-PNKVD2UK.js";
 
 // src/Loader.ts
 var Loader_exports = {};
@@ -183,6 +183,14 @@ async function processFileContent(filePath, options = {}) {
 var DEFAULT_MAX_PROBLEM_BYTES = 2 * 1024 * 1024;
 var WRAP_WIDTH_KNOWN = 1e3;
 var WRAP_WIDTH_DEFAULT = 80;
+var Logger = {
+  info: (...args) => console.log("[Loader]", ...args),
+  warn: (...args) => console.warn("[Loader]", ...args),
+  error: (...args) => console.error("[Loader]", ...args),
+  debug: (...args) => {
+    if (process.env.DEBUG) console.log("[Loader]", ...args);
+  }
+};
 async function processAndStoreFile(filePath, collection, options = {}) {
   const {
     allowProblematic = false,
@@ -194,13 +202,13 @@ async function processAndStoreFile(filePath, collection, options = {}) {
     let fileInfo;
     if (await isProblematicFile(filePath)) {
       if (!allowProblematic) {
-        console.warn(`Skipping problematic file: ${filePath}`);
+        Logger.warn(`Skipping problematic file: ${filePath}`);
         return null;
       }
       const extension = path2.extname(filePath).toLowerCase();
       const isKnownType = ContentTypeInterpreter.isKnownLongLineExtension(extension);
       const wrapWidth = isKnownType ? WRAP_WIDTH_KNOWN : WRAP_WIDTH_DEFAULT;
-      console.warn(`Problematic file detected, processing as safe text: ${filePath}`);
+      Logger.warn(`Problematic file detected, processing as safe text: ${filePath}`);
       try {
         const streamed = await streamReadNormalizedText(filePath, {
           byteCap: maxBytesOnProblem,
@@ -219,7 +227,7 @@ async function processAndStoreFile(filePath, collection, options = {}) {
           wrapWidth
         };
       } catch (e) {
-        console.warn(`Safe text processing failed, falling back to capped binary: ${filePath}`);
+        Logger.warn(`Safe text processing failed, falling back to capped binary: ${filePath}`, e);
         fileInfo = await processFileContent(filePath, {
           forceBinary: true,
           allowPathological: true,
@@ -227,15 +235,13 @@ async function processAndStoreFile(filePath, collection, options = {}) {
         });
       }
     } else {
-      console.log(`Processing file: ${filePath}`);
+      Logger.info(`Processing file: ${filePath}`);
       fileInfo = await processFileContent(filePath);
     }
     if (!fileInfo) return null;
     const content = fileInfo.content;
     if (!content || typeof content === "string" && content.length === 0 || content instanceof Uint8Array && content.length === 0) {
-      if (process.env.DEBUG) {
-        console.log(`Skipping empty file: ${filePath} (empty files cannot be stored as MCards)`);
-      }
+      Logger.debug(`Skipping empty file: ${filePath} (empty files cannot be stored as MCards)`);
       return {
         hash: "",
         contentType: fileInfo.mimeType,
@@ -263,11 +269,9 @@ async function processAndStoreFile(filePath, collection, options = {}) {
               await collection.addWithHandle(mcard, relPath);
               registered = true;
             } catch (e2) {
-              if (process.env.DEBUG) {
-                console.log(
-                  `Handle name '${handle}' already in use (common for files like README.md, LICENSE). MCard stored successfully with hash ${mcard.hash.slice(0, 8)}... (accessible by hash, not by handle)`
-                );
-              }
+              Logger.debug(
+                `Handle name '${handle}' already in use (common for files like README.md, LICENSE). MCard stored successfully with hash ${mcard.hash.slice(0, 8)}... (accessible by hash, not by handle)`
+              );
             }
           }
         }
@@ -275,6 +279,7 @@ async function processAndStoreFile(filePath, collection, options = {}) {
           try {
             await collection.add(mcard);
           } catch (e3) {
+            Logger.warn(`Hash fallback also failed for ${handle}:`, e3);
           }
         }
       }
@@ -292,7 +297,7 @@ async function processAndStoreFile(filePath, collection, options = {}) {
     if (metadataOnly && isProblematic) result.metadataOnly = true;
     return result;
   } catch (e) {
-    console.error(`Error processing ${filePath}:`, e);
+    Logger.error(`Error processing ${filePath}:`, e);
     return null;
   }
 }
@@ -334,7 +339,7 @@ async function loadFileToCollection(targetPath, collection, options = {}) {
     directoriesCount: uniqueDirs.size,
     directoryLevels: maxDepth
   };
-  console.log(`About to process ${files.length} files`);
+  Logger.info(`About to process ${files.length} files`);
   for (const file of files) {
     const result = await processAndStoreFile(file, collection, {
       allowProblematic: includeProblematic,

package/dist/chunk-RB35Z35T.js

@@ -0,0 +1,44 @@
+// src/ptr/node/NetworkConfig.ts
+var HTTP_DEFAULT_MAX_ATTEMPTS = 1;
+var HTTP_DEFAULT_BACKOFF = "exponential";
+var HTTP_DEFAULT_BASE_DELAY_MS = 1e3;
+var HTTP_DEFAULT_MAX_DELAY_MS = 3e4;
+var HTTP_DEFAULT_TIMEOUT_MS = 3e4;
+var HTTP_DEFAULT_CACHE_TTL_SECONDS = 300;
+var RATE_LIMIT_DEFAULT_TOKENS_PER_SECOND = 10;
+var RATE_LIMIT_DEFAULT_MAX_BURST = 20;
+var RATE_LIMIT_WAIT_INTERVAL_MS = 100;
+var NETWORK_DEFAULT_LISTEN_PORT = 3e3;
+var NETWORK_DEFAULT_SIGNALING_MAX_PORT_TRIES = 10;
+var NETWORK_SIGNALING_PORT_RELEASE_WAIT_MS = 500;
+var NETWORK_DEFAULT_HOST = "localhost";
+var NETWORK_DEFAULT_ORCHESTRATOR_SLEEP_MS = 1e3;
+var WEBSOCKET_SERVER_START_WAIT_MS = 3e3;
+var STATIC_SERVER_START_WAIT_MS = 1500;
+var PROCESS_TERMINATE_WAIT_MS = 500;
+var SESSION_RECORD_DEFAULT_MAX_BUFFER_SIZE = 5;
+var WEBRTC_DEFAULT_TIMEOUT_MS = 3e4;
+var WEBRTC_DEFAULT_MOCK_DELAY_MS = 100;
+
+export {
+  HTTP_DEFAULT_MAX_ATTEMPTS,
+  HTTP_DEFAULT_BACKOFF,
+  HTTP_DEFAULT_BASE_DELAY_MS,
+  HTTP_DEFAULT_MAX_DELAY_MS,
+  HTTP_DEFAULT_TIMEOUT_MS,
+  HTTP_DEFAULT_CACHE_TTL_SECONDS,
+  RATE_LIMIT_DEFAULT_TOKENS_PER_SECOND,
+  RATE_LIMIT_DEFAULT_MAX_BURST,
+  RATE_LIMIT_WAIT_INTERVAL_MS,
+  NETWORK_DEFAULT_LISTEN_PORT,
+  NETWORK_DEFAULT_SIGNALING_MAX_PORT_TRIES,
+  NETWORK_SIGNALING_PORT_RELEASE_WAIT_MS,
+  NETWORK_DEFAULT_HOST,
+  NETWORK_DEFAULT_ORCHESTRATOR_SLEEP_MS,
+  WEBSOCKET_SERVER_START_WAIT_MS,
+  STATIC_SERVER_START_WAIT_MS,
+  PROCESS_TERMINATE_WAIT_MS,
+  SESSION_RECORD_DEFAULT_MAX_BUFFER_SIZE,
+  WEBRTC_DEFAULT_TIMEOUT_MS,
+  WEBRTC_DEFAULT_MOCK_DELAY_MS
+};