cvm-server 0.1.0

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "cvm-server",
+  "version": "0.1.0",
+  "description": "Cognitive Virtual Machine (CVM) - A deterministic bytecode VM with AI cognitive operations",
+  "keywords": ["mcp", "ai", "vm", "cognitive", "bytecode", "virtual-machine", "claude"],
+  "author": "Ladislav Sopko",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/LadislavSopko/cvm#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LadislavSopko/cvm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LadislavSopko/cvm/issues"
+  },
+  "bin": {
+    "cvm-server": "./bin/cvm-server.js"
+  },
+  "files": [
+    "bin",
+    "main.js",
+    "apps",
+    "packages",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "targets": {
+      "build": {
+        "executor": "@nx/esbuild:esbuild",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "defaultConfiguration": "production",
+        "options": {
+          "platform": "node",
+          "outputPath": "apps/cvm-server/dist",
+          "format": [
+            "cjs"
+          ],
+          "bundle": false,
+          "main": "apps/cvm-server/src/main.ts",
+          "tsConfig": "apps/cvm-server/tsconfig.app.json",
+          "assets": [
+            "apps/cvm-server/src/assets"
+          ],
+          "esbuildOptions": {
+            "sourcemap": true,
+            "outExtension": {
+              ".js": ".js"
+            }
+          }
+        },
+        "configurations": {
+          "development": {},
+          "production": {
+            "esbuildOptions": {
+              "sourcemap": false,
+              "outExtension": {
+                ".js": ".js"
+              }
+            }
+          }
+        }
+      },
+      "serve": {
+        "continuous": true,
+        "executor": "@nx/js:node",
+        "defaultConfiguration": "development",
+        "dependsOn": [
+          "build"
+        ],
+        "options": {
+          "buildTarget": "@cvm/cvm-server:build",
+          "runBuildTargetDependencies": false
+        },
+        "configurations": {
+          "development": {
+            "buildTarget": "@cvm/cvm-server:build:development"
+          },
+          "production": {
+            "buildTarget": "@cvm/cvm-server:build:production"
+          }
+        }
+      }
+    }
+  }
+}

package/packages/mcp-server/src/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  CVMMcpServer: () => import_mcp_server.CVMMcpServer
+});
+module.exports = __toCommonJS(src_exports);
+var import_mcp_server = require("./lib/mcp-server.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CVMMcpServer
+});

package/packages/mcp-server/src/lib/mcp-server.js

@@ -0,0 +1,233 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mcp_server_exports = {};
+__export(mcp_server_exports, {
+  CVMMcpServer: () => CVMMcpServer
+});
+module.exports = __toCommonJS(mcp_server_exports);
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_zod = require("zod");
+var import_vm = require("@cvm/vm");
+class CVMMcpServer {
+  server;
+  transport = null;
+  vmManager;
+  constructor() {
+    this.vmManager = new import_vm.VMManager();
+    this.server = new import_mcp.McpServer({
+      name: "cvm-server",
+      version: "1.0.0"
+    });
+    this.setupTools();
+  }
+  getName() {
+    return "cvm-server";
+  }
+  getVersion() {
+    return "1.0.0";
+  }
+  setupTools() {
+    this.server.tool(
+      "loadProgram",
+      {
+        programId: import_zod.z.string(),
+        source: import_zod.z.string()
+      },
+      async ({ programId, source }) => {
+        try {
+          await this.vmManager.loadProgram(programId, source);
+          return {
+            content: [{ type: "text", text: `Program loaded successfully: ${programId}` }]
+          };
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.tool(
+      "startExecution",
+      {
+        programId: import_zod.z.string(),
+        executionId: import_zod.z.string()
+      },
+      async ({ programId, executionId }) => {
+        try {
+          await this.vmManager.startExecution(programId, executionId);
+          return {
+            content: [{ type: "text", text: `Execution started: ${executionId}` }]
+          };
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.tool(
+      "getNext",
+      {
+        executionId: import_zod.z.string()
+      },
+      async ({ executionId }) => {
+        try {
+          const result = await this.vmManager.getNext(executionId);
+          if (result.type === "completed") {
+            return {
+              content: [{ type: "text", text: "Execution completed" }]
+            };
+          } else if (result.type === "waiting") {
+            return {
+              content: [{ type: "text", text: result.message || "Waiting for input" }]
+            };
+          } else if (result.type === "error") {
+            return {
+              content: [{ type: "text", text: `Error: ${result.error}` }],
+              isError: true
+            };
+          }
+          return {
+            content: [{ type: "text", text: "Unexpected state" }],
+            isError: true
+          };
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.tool(
+      "reportCCResult",
+      {
+        executionId: import_zod.z.string(),
+        result: import_zod.z.string()
+      },
+      async ({ executionId, result }) => {
+        try {
+          await this.vmManager.reportCCResult(executionId, result);
+          return {
+            content: [{ type: "text", text: "Execution resumed" }]
+          };
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.tool(
+      "getExecutionState",
+      {
+        executionId: import_zod.z.string()
+      },
+      async ({ executionId }) => {
+        try {
+          const status = await this.vmManager.getExecutionStatus(executionId);
+          return {
+            content: [{ type: "text", text: JSON.stringify(status, null, 2) }]
+          };
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  async start() {
+    await this.vmManager.initialize();
+    this.transport = new import_stdio.StdioServerTransport();
+    await this.server.connect(this.transport);
+  }
+  async stop() {
+    if (this.transport) {
+      await this.transport.close();
+      this.transport = null;
+    }
+    await this.vmManager.dispose();
+  }
+  // For testing - direct tool invocation
+  async handleTool(toolName, args) {
+    const handlers = {
+      loadProgram: async ({ programId, source }) => {
+        try {
+          await this.vmManager.loadProgram(programId, source);
+          return { content: [{ type: "text", text: `Program loaded successfully: ${programId}` }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: error instanceof Error ? error.message : "Unknown error" }], isError: true };
+        }
+      },
+      startExecution: async ({ programId, executionId }) => {
+        try {
+          await this.vmManager.startExecution(programId, executionId);
+          return { content: [{ type: "text", text: `Execution started: ${executionId}` }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: error instanceof Error ? error.message : "Unknown error" }], isError: true };
+        }
+      },
+      getNext: async ({ executionId }) => {
+        try {
+          const result = await this.vmManager.getNext(executionId);
+          if (result.type === "completed") {
+            return { content: [{ type: "text", text: "Execution completed" }] };
+          } else if (result.type === "waiting") {
+            return { content: [{ type: "text", text: result.message || "Waiting for input" }] };
+          } else {
+            return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
+          }
+        } catch (error) {
+          return { content: [{ type: "text", text: error instanceof Error ? error.message : "Unknown error" }], isError: true };
+        }
+      },
+      reportCCResult: async ({ executionId, result }) => {
+        try {
+          await this.vmManager.reportCCResult(executionId, result);
+          return { content: [{ type: "text", text: "Execution resumed" }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: error instanceof Error ? error.message : "Unknown error" }], isError: true };
+        }
+      },
+      getExecutionState: async ({ executionId }) => {
+        try {
+          const status = await this.vmManager.getExecutionStatus(executionId);
+          return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+        } catch (error) {
+          return { content: [{ type: "text", text: error instanceof Error ? error.message : "Unknown error" }], isError: true };
+        }
+      }
+    };
+    const handler = handlers[toolName];
+    if (!handler) {
+      throw new Error(`Tool not found: ${toolName}`);
+    }
+    return await handler(args);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CVMMcpServer
+});

package/packages/mongodb/src/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  MongoDBAdapter: () => import_mongodb.MongoDBAdapter
+});
+module.exports = __toCommonJS(src_exports);
+var import_mongodb = require("./lib/mongodb.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MongoDBAdapter
+});

package/packages/mongodb/src/lib/mongodb.js

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mongodb_exports = {};
+__export(mongodb_exports, {
+  MongoDBAdapter: () => MongoDBAdapter
+});
+module.exports = __toCommonJS(mongodb_exports);
+var import_mongodb = require("mongodb");
+class MongoDBAdapter {
+  constructor(connectionString) {
+    this.connectionString = connectionString;
+    this.client = new import_mongodb.MongoClient(connectionString);
+  }
+  client;
+  db = null;
+  connected = false;
+  async connect() {
+    await this.client.connect();
+    const dbName = this.connectionString.split("/").pop()?.split("?")[0] || "cvm";
+    this.db = this.client.db(dbName);
+    this.connected = true;
+    const collections = await this.db.listCollections().toArray();
+    const collectionNames = collections.map((c) => c.name);
+    if (!collectionNames.includes("programs")) {
+      await this.db.createCollection("programs");
+    }
+    if (!collectionNames.includes("executions")) {
+      await this.db.createCollection("executions");
+    }
+  }
+  async disconnect() {
+    await this.client.close();
+    this.connected = false;
+    this.db = null;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async getCollections() {
+    if (!this.db)
+      throw new Error("Not connected to database");
+    const collections = await this.db.listCollections().toArray();
+    return collections.map((c) => c.name);
+  }
+  getCollection(name) {
+    if (!this.db)
+      throw new Error("Not connected to database");
+    return this.db.collection(name);
+  }
+  async saveProgram(program) {
+    const collection = this.getCollection("programs");
+    await collection.replaceOne(
+      { id: program.id },
+      program,
+      { upsert: true }
+    );
+  }
+  async getProgram(id) {
+    const collection = this.getCollection("programs");
+    return await collection.findOne({ id });
+  }
+  async saveExecution(execution) {
+    const collection = this.getCollection("executions");
+    await collection.replaceOne(
+      { id: execution.id },
+      execution,
+      { upsert: true }
+    );
+  }
+  async getExecution(id) {
+    const collection = this.getCollection("executions");
+    return await collection.findOne({ id });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MongoDBAdapter
+});

package/packages/mongodb/src/lib/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/packages/parser/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./lib/parser.js"), module.exports);
+__reExport(src_exports, require("./lib/bytecode.js"), module.exports);
+__reExport(src_exports, require("./lib/compiler.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./lib/parser.js"),
+  ...require("./lib/bytecode.js"),
+  ...require("./lib/compiler.js")
+});

package/packages/parser/src/lib/bytecode.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bytecode_exports = {};
+__export(bytecode_exports, {
+  OpCode: () => OpCode
+});
+module.exports = __toCommonJS(bytecode_exports);
+var OpCode = /* @__PURE__ */ ((OpCode2) => {
+  OpCode2["PUSH"] = "PUSH";
+  OpCode2["POP"] = "POP";
+  OpCode2["LOAD"] = "LOAD";
+  OpCode2["STORE"] = "STORE";
+  OpCode2["CONCAT"] = "CONCAT";
+  OpCode2["JUMP"] = "JUMP";
+  OpCode2["JUMP_IF"] = "JUMP_IF";
+  OpCode2["CALL"] = "CALL";
+  OpCode2["RETURN"] = "RETURN";
+  OpCode2["CC"] = "CC";
+  OpCode2["PRINT"] = "PRINT";
+  OpCode2["HALT"] = "HALT";
+  return OpCode2;
+})(OpCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpCode
+});

package/packages/parser/src/lib/compiler.js

@@ -0,0 +1,104 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compiler_exports = {};
+__export(compiler_exports, {
+  compile: () => compile
+});
+module.exports = __toCommonJS(compiler_exports);
+var ts = __toESM(require("typescript"), 1);
+var import_bytecode = require("./bytecode.js");
+var import_parser = require("./parser.js");
+function compile(source) {
+  const parseResult = (0, import_parser.parseProgram)(source);
+  if (parseResult.errors.length > 0) {
+    return {
+      success: false,
+      bytecode: [],
+      errors: parseResult.errors
+    };
+  }
+  const bytecode = [];
+  const sourceFile = ts.createSourceFile("program.ts", source, ts.ScriptTarget.Latest, true);
+  function compileStatement(node) {
+    if (ts.isExpressionStatement(node)) {
+      const expr = node.expression;
+      if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression) && expr.expression.expression.getText() === "console" && expr.expression.name.getText() === "log") {
+        expr.arguments.forEach((arg) => {
+          compileExpression(arg);
+        });
+        bytecode.push({ op: import_bytecode.OpCode.PRINT });
+      } else if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "CC") {
+        if (expr.arguments.length > 0) {
+          compileExpression(expr.arguments[0]);
+        }
+        bytecode.push({ op: import_bytecode.OpCode.CC });
+        bytecode.push({ op: import_bytecode.OpCode.POP });
+      }
+    } else if (ts.isVariableStatement(node)) {
+      const decl = node.declarationList.declarations[0];
+      if (decl.initializer) {
+        compileExpression(decl.initializer);
+        bytecode.push({ op: import_bytecode.OpCode.STORE, arg: decl.name.getText() });
+      }
+    }
+  }
+  function compileExpression(node) {
+    if (ts.isStringLiteral(node)) {
+      bytecode.push({ op: import_bytecode.OpCode.PUSH, arg: node.text });
+    } else if (ts.isIdentifier(node)) {
+      bytecode.push({ op: import_bytecode.OpCode.LOAD, arg: node.text });
+    } else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "CC") {
+      if (node.arguments.length > 0) {
+        compileExpression(node.arguments[0]);
+      }
+      bytecode.push({ op: import_bytecode.OpCode.CC });
+    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      compileExpression(node.left);
+      compileExpression(node.right);
+      bytecode.push({ op: import_bytecode.OpCode.CONCAT });
+    }
+  }
+  sourceFile.forEachChild((node) => {
+    if (ts.isFunctionDeclaration(node) && node.name?.text === "main" && node.body) {
+      node.body.statements.forEach((stmt) => {
+        compileStatement(stmt);
+      });
+    }
+  });
+  bytecode.push({ op: import_bytecode.OpCode.HALT });
+  return {
+    success: true,
+    bytecode,
+    errors: []
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compile
+});