@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/embeddings-7QXTXUMC.js

@@ -0,0 +1,15 @@
+import {
+  DEFAULT_EMBEDDING_DIM,
+  DEFAULT_EMBEDDING_MODEL,
+  embedText,
+  getEmbeddingDimension,
+  prewarmEmbeddingsWorker
+} from "./chunk-ZVO47SQV.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  DEFAULT_EMBEDDING_DIM,
+  DEFAULT_EMBEDDING_MODEL,
+  embedText,
+  getEmbeddingDimension,
+  prewarmEmbeddingsWorker
+};

package/dist/embeddings-MAEWWUHW.js

@@ -0,0 +1,9 @@
+import {
+  encodePoints,
+  encodeTextBatch
+} from "./chunk-XPJ63Y6T.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  encodePoints,
+  encodeTextBatch
+};

package/dist/graph-RKMNE2X5.js

@@ -0,0 +1,36 @@
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/adapters/graph.ts
+async function graphLib() {
+  return await import("./dist-VYGJXGUS.js");
+}
+function entityGraph() {
+  const nodes = /* @__PURE__ */ new Set();
+  const edges = [];
+  return {
+    async handle(input) {
+      const g = await graphLib().catch(() => null);
+      if (Array.isArray(input?.upsert)) {
+        for (const e of input.upsert) {
+          nodes.add(String(e.from));
+          nodes.add(String(e.to));
+          edges.push({ ...e, t: e.t || Date.now() });
+        }
+      }
+      if (input?.query) {
+        const { sinceMs, type } = input.query;
+        let res = edges;
+        if (sinceMs) {
+          const since = Date.now() - Number(sinceMs);
+          res = res.filter((e) => (e.t || 0) >= since);
+        }
+        if (type) res = res.filter((e) => e.type === type);
+        return { nodes: Array.from(nodes), edges: res };
+      }
+      return { nodeCount: nodes.size, edgeCount: edges.length };
+    }
+  };
+}
+export {
+  entityGraph
+};

package/dist/hvm-CBEP3M4F.js

@@ -0,0 +1,126 @@
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/runners/hvm-simulator.ts
+function runFibonacciLogic(n) {
+  if (n < 0) return 0;
+  if (n === 0) return 0;
+  if (n === 1) return 1;
+  return runFibonacciLogic(n - 1) + runFibonacciLogic(n - 2);
+}
+async function runInHVMSimulator(programName, input) {
+  console.log(`[HVM-Sim] Running ${programName} in simulator mode...`);
+  if (programName.includes("agent-logic")) {
+    const n = typeof input.n === "number" ? input.n : 15;
+    const startTime = performance.now();
+    const result = runFibonacciLogic(n);
+    const endTime = performance.now();
+    console.log(`[HVM-Sim] Completed in ${(endTime - startTime).toFixed(2)}ms. Result: ${result}`);
+    return result;
+  }
+  throw new Error(`[HVM-Sim] Unknown program: ${programName}`);
+}
+
+// ../../lib/terminals-tech/machines/core/runners/hvm.ts
+async function runInHVM(manifest, input, ctx) {
+  const entry = manifest.entrypoints["wasm-hvm"];
+  if (!entry) {
+    return {
+      error: "No wasm-hvm entrypoint defined",
+      input
+    };
+  }
+  try {
+    const startTime = performance.now();
+    let result;
+    let strategy = "unknown";
+    if (entry.module.endsWith(".wasm")) {
+      try {
+        result = await runViaWasm(entry.module, input);
+        strategy = "wasm";
+      } catch (wasmError) {
+        console.warn(`[HVM] WASM execution failed, trying fallback:`, wasmError);
+        result = await runInHVMSimulator(entry.module, input);
+        strategy = "simulator-fallback";
+      }
+    } else if (entry.module.endsWith(".hvm")) {
+      try {
+        result = await runViaHVMCore(entry.module, input);
+        strategy = "hvm-core";
+      } catch (hvmError) {
+        console.warn(
+          `[HVM] CLI execution failed (likely missing binary), falling back to Simulator:`,
+          hvmError
+        );
+        result = await runInHVMSimulator(entry.module, input);
+        strategy = "simulator-fallback";
+      }
+    } else {
+      throw new Error(`Unsupported HVM module format: ${entry.module}`);
+    }
+    const endTime = performance.now();
+    return {
+      ...input,
+      result,
+      _hvm: {
+        reduced: true,
+        durationMs: endTime - startTime,
+        tier: "wasm-hvm",
+        strategy
+      }
+    };
+  } catch (error) {
+    return {
+      error: error.message,
+      input,
+      _hvm: {
+        reduced: false,
+        tier: "wasm-hvm"
+      }
+    };
+  }
+}
+async function runViaHVMCore(hvmPath, input) {
+  if (typeof window !== "undefined") {
+    const { WebContainerManager } = await import("./WebContainerManager-4LIOGRVM.js");
+    const wcm = WebContainerManager.getExistingInstance();
+    if (!wcm) {
+      throw new Error("WebContainer not available for HVM execution");
+    }
+    try {
+      const process = await wcm.spawn("hvm", ["run", hvmPath], {
+        cwd: "/home/project"
+      });
+      let output = "";
+      const reader = process.output.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        output += value;
+      }
+      const exitCode = await process.exit;
+      if (exitCode !== 0) {
+        throw new Error(`HVM execution failed with exit code ${exitCode}: ${output}`);
+      }
+      const match = output.match(/Result:\s*(\d+)/);
+      return match ? parseInt(match[1]) : output;
+    } catch (e) {
+      throw e;
+    }
+  }
+  throw new Error("Server-side HVM execution not implemented");
+}
+async function runViaWasm(wasmPath, input) {
+  const response = await fetch(wasmPath);
+  const wasmBytes = await response.arrayBuffer();
+  const wasmModule = await WebAssembly.instantiate(wasmBytes);
+  const instance = wasmModule.instance;
+  const main = instance.exports.main;
+  if (!main) {
+    throw new Error('WASM module does not export "main" function');
+  }
+  const result = main();
+  return result;
+}
+export {
+  runInHVM
+};