mcard-js 2.1.41 → 2.1.43

package/dist/{NetworkRuntime-CXPKIAOQ.js → NetworkRuntime-XZR733M5.js}

@@ -1,8 +1,8 @@
 import {
   MCard
-} from "./chunk-WVFWNVT2.js";
+} from "./chunk-2NFGZ6PA.js";
 import "./chunk-7NKII2JA.js";
-import "./chunk-MLKGABMK.js";
+import "./chunk-PNKVD2UK.js";
 
 // src/ptr/node/NetworkRuntime.ts
 import * as http from "http";
@@ -136,13 +136,18 @@ var P2PChatSession = class {
 // src/ptr/node/SignalingServer.ts
 import { createServer } from "http";
 import { exec } from "child_process";
+var Logger = {
+  info: (...args) => console.log("[Signal]", ...args),
+  warn: (...args) => console.warn("[Signal]", ...args),
+  error: (...args) => console.error("[Signal]", ...args)
+};
 function killProcessOnPort(port) {
   return new Promise((resolve) => {
     exec(`lsof -ti:${port} | xargs kill -9 2>/dev/null`, (error) => {
       if (error) {
-        console.log(`[Signal] No existing process on port ${port} to kill`);
+        Logger.info(`No existing process on port ${port} to kill`);
       } else {
-        console.log(`[Signal] Killed existing process on port ${port}`);
+        Logger.info(`Killed existing process on port ${port}`);
       }
       setTimeout(resolve, 500);
     });
@@ -181,7 +186,7 @@ async function createSignalingServer(config = {}) {
         res.end("Missing peer_id");
         return;
       }
-      console.log(`[Signal] Client connected: ${peerId}`);
+      Logger.info(`Client connected: ${peerId}`);
       res.writeHead(200, {
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
@@ -201,7 +206,7 @@ async function createSignalingServer(config = {}) {
         messageBuffer.delete(peerId);
       }
       req.on("close", () => {
-        console.log(`[Signal] Client disconnected: ${peerId}`);
+        Logger.info(`Client disconnected: ${peerId}`);
         clearInterval(keepAlive);
         clients.delete(peerId);
       });
@@ -219,7 +224,7 @@ async function createSignalingServer(config = {}) {
             res.end("Missing target");
             return;
           }
-          console.log(`[Signal] Relaying ${msg.type} to ${target}`);
+          Logger.info(`Relaying ${msg.type} to ${target}`);
           if (clients.has(target)) {
             clients.get(target).write(`data: ${JSON.stringify(msg)}
 
@@ -234,7 +239,7 @@ async function createSignalingServer(config = {}) {
           res.writeHead(200);
           res.end("Sent");
         } catch (e) {
-          console.error(e);
+          Logger.error(`Failed to handle generic post-signal error`, e);
           res.writeHead(500);
           res.end(String(e));
         }
@@ -260,7 +265,7 @@ async function createSignalingServer(config = {}) {
           resolve();
         });
       });
-      console.log(`[Signal] Server running on port ${port}`);
+      Logger.info(`Server running on port ${port}`);
       return {
         success: true,
         port,
@@ -270,7 +275,7 @@ async function createSignalingServer(config = {}) {
     } catch (err) {
       server.removeAllListeners("error");
       if (attempt === 0 && autoFindPort) {
-        console.log(`[Signal] Port ${port} in use, trying to kill existing process...`);
+        Logger.info(`Port ${port} in use, trying to kill existing process...`);
         await killProcessOnPort(port);
         try {
           await new Promise((resolve, reject) => {
@@ -280,7 +285,7 @@ async function createSignalingServer(config = {}) {
               resolve();
             });
           });
-          console.log(`[Signal] Server running on port ${port} (after kill)`);
+          Logger.info(`Server running on port ${port} (after kill)`);
           return {
             success: true,
             port,
@@ -297,7 +302,7 @@ async function createSignalingServer(config = {}) {
           error: `Port ${port} is already in use`
         };
       }
-      console.log(`[Signal] Port ${port} still in use, trying next...`);
+      Logger.info(`Port ${port} still in use, trying next...`);
     }
   }
   return {

package/dist/{OllamaProvider-QPX2JXL2.js → OllamaProvider-FBZ5WW72.js}

@@ -1,6 +1,6 @@
 import {
   OllamaProvider
-} from "./chunk-DOC55MPG.js";
+} from "./chunk-WR6ISHCS.js";
 import "./chunk-2KADE3SE.js";
 import "./chunk-PNKVD2UK.js";
 export {

package/dist/OllamaProvider-W6TPZNHD.js

@@ -0,0 +1,9 @@
+import {
+  OllamaProvider
+} from "./chunk-GNF4WAPV.js";
+import "./chunk-2KADE3SE.js";
+import "./chunk-A5S2PI37.js";
+import "./chunk-PNKVD2UK.js";
+export {
+  OllamaProvider
+};

package/dist/chunk-2NFGZ6PA.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-VXV35I5J.js → chunk-4TYRTQ4V.js}

@@ -6,14 +6,14 @@ import {
 } from "./chunk-2KADE3SE.js";
 import {
   SqliteNodeEngine
-} from "./chunk-FIE4LAJG.js";
+} from "./chunk-OX3K6UZJ.js";
 import {
   CardCollection,
   Maybe
-} from "./chunk-4PDYHPR6.js";
+} from "./chunk-WNKP66IR.js";
 import {
   MCard
-} from "./chunk-3MMMJ7NH.js";
+} from "./chunk-OKWBHCKC.js";
 
 // src/ptr/node/runtimes/base.ts
 import * as util from "util";
@@ -192,7 +192,9 @@ var JavaScriptRuntime = class {
     const contextStr = JSON.stringify(context);
     const projectRoot = findProjectRoot();
     const wrapper = `
-const process = require('process');
+import process from 'process';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
 const context = JSON.parse(process.argv[2]);
 global.context = context;
 let result;
@@ -277,6 +279,35 @@ Stdout: ${execError.stdout.toString()}` : "";
    * Create Python wrapper script with entry point invocation.
    */
   createWrapper(code, entryPoint) {
+    let userLogic = code;
+    let actualEntryPoint = entryPoint;
+    if (code.startsWith("module://")) {
+      const withoutPrefix = code.substring(9);
+      const colonIndex = withoutPrefix.indexOf(":");
+      let modulePath = withoutPrefix;
+      let moduleFunc = "";
+      if (colonIndex !== -1) {
+        modulePath = withoutPrefix.substring(0, colonIndex);
+        moduleFunc = withoutPrefix.substring(colonIndex + 1);
+      }
+      if (modulePath) {
+        if (moduleFunc) {
+          actualEntryPoint = moduleFunc;
+        }
+        userLogic = `
+import importlib
+try:
+    _mod = importlib.import_module('${modulePath}')
+    for _k in dir(_mod):
+        if not _k.startswith('_'):
+            globals()[_k] = getattr(_mod, _k)
+except Exception as e:
+    import sys, json
+    print(json.dumps({"error": f"Failed to import module ${modulePath}: {e}"}))
+    sys.exit(1)
+`;
+      }
+    }
     return `
 import sys
 import json
@@ -293,7 +324,7 @@ except:
     pass
 
 # User logic
-${code}
+${userLogic}
 
 # Entry point invocation
 def _is_arg_error(e):
@@ -302,10 +333,10 @@ def _is_arg_error(e):
 
 try:
     fn = None
-    if '${entryPoint}' in dir():
-        fn = ${entryPoint}
-    elif '${entryPoint}' in globals():
-        fn = globals()['${entryPoint}']
+    if '${actualEntryPoint}' in dir():
+        fn = locals()['${actualEntryPoint}']
+    elif '${actualEntryPoint}' in globals():
+        fn = globals()['${actualEntryPoint}']
 
     if fn is not None:
         try:
@@ -454,7 +485,7 @@ var LoaderRuntime = class {
    * Returns unified metrics and results matching Python's loader builtin.
    */
   async execute(_code, context, config) {
-    const { loadFileToCollection } = await import("./Loader-3LSJXJQG.js");
+    const { loadFileToCollection } = await import("./Loader-7HQVYDPA.js");
     const ctx = context;
     const loaderParams = extractLoaderParams(ctx, { sourceDir: "test_data", dbPath: ":memory:" });
     const { sourceDir, recursive, dbPath } = loaderParams;
@@ -597,7 +628,7 @@ var RuntimeFactory = class {
         } else if (r === "wasm") {
           status[r] = typeof WebAssembly !== "undefined";
         } else if (r === "llm") {
-          const { OllamaProvider } = await import("./OllamaProvider-QPX2JXL2.js");
+          const { OllamaProvider } = await import("./OllamaProvider-FBZ5WW72.js");
           const provider = new OllamaProvider(null, 5);
           status[r] = await provider.validate_connection();
         } else {
@@ -636,7 +667,7 @@ var RuntimeFactory = class {
         return {
           async execute(code, context, config) {
             if (!_LLMRuntime) {
-              const mod = await import("./LLMRuntime-LBWUJ7ON.js");
+              const mod = await import("./LLMRuntime-UPSEDSIK.js");
               _LLMRuntime = mod.LLMRuntime;
             }
             const runtime = new _LLMRuntime();
@@ -651,7 +682,7 @@ var RuntimeFactory = class {
         return {
           async execute(code, context, config) {
             if (!_LambdaRuntime) {
-              const mod = await import("./LambdaRuntime-B6D6IQKZ.js");
+              const mod = await import("./LambdaRuntime-WBEK37AF.js");
               _LambdaRuntime = mod.LambdaRuntime;
             }
             const runtime = new _LambdaRuntime(collection);
@@ -663,7 +694,7 @@ var RuntimeFactory = class {
         return {
           async execute(code, context, config, chapterDir) {
             if (!_NetworkRuntime) {
-              const mod = await import("./NetworkRuntime-IAFHPQSX.js");
+              const mod = await import("./NetworkRuntime-VYCC5HSY.js");
               _NetworkRuntime = mod.NetworkRuntime;
             }
             const runtime = new _NetworkRuntime(netCollection);
@@ -680,18 +711,18 @@ var RuntimeFactory = class {
   static async getRuntimeAsync(runtimeName, options) {
     switch (runtimeName) {
       case "llm": {
-        const { LLMRuntime } = await import("./LLMRuntime-LBWUJ7ON.js");
+        const { LLMRuntime } = await import("./LLMRuntime-UPSEDSIK.js");
         return new LLMRuntime();
       }
       case "lambda": {
         if (!options?.collection) {
           throw new Error("Lambda runtime requires a CardCollection in options");
         }
-        const { LambdaRuntime: LambdaRuntime2 } = await import("./LambdaRuntime-B6D6IQKZ.js");
+        const { LambdaRuntime: LambdaRuntime2 } = await import("./LambdaRuntime-WBEK37AF.js");
         return new LambdaRuntime2(options.collection);
       }
       case "network": {
-        const { NetworkRuntime } = await import("./NetworkRuntime-IAFHPQSX.js");
+        const { NetworkRuntime } = await import("./NetworkRuntime-VYCC5HSY.js");
         return new NetworkRuntime(options?.collection);
       }
       default: