cvm-server
Version:
Cognitive Virtual Machine (CVM) - A deterministic bytecode VM with AI cognitive operations
1,305 lines (1,304 loc) • 131 kB
JavaScript
"use strict";
const mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
const stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
const zod = require("zod");
const r$1 = require("typescript");
const N$1 = require("fs");
const r$2 = require("path");
const mongodb = require("mongodb");
const promises = require("fs/promises");
const dotenv = require("dotenv");
const url = require("url");
var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
function _interopNamespaceDefault(e) {
const n2 = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
if (e) {
for (const k2 in e) {
if (k2 !== "default") {
const d2 = Object.getOwnPropertyDescriptor(e, k2);
Object.defineProperty(n2, k2, d2.get ? d2 : {
enumerable: true,
get: () => e[k2]
});
}
}
}
n2.default = e;
return Object.freeze(n2);
}
const r__namespace = /* @__PURE__ */ _interopNamespaceDefault(r$1);
const N__namespace = /* @__PURE__ */ _interopNamespaceDefault(N$1);
const r__namespace$1 = /* @__PURE__ */ _interopNamespaceDefault(r$2);
const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
var P$1 = /* @__PURE__ */ ((T) => (T.PUSH = "PUSH", T.PUSH_UNDEFINED = "PUSH_UNDEFINED", T.POP = "POP", T.DUP = "DUP", T.DUP2 = "DUP2", T.SWAP = "SWAP", T.LOAD = "LOAD", T.STORE = "STORE", T.CONCAT = "CONCAT", T.ARRAY_NEW = "ARRAY_NEW", T.ARRAY_PUSH = "ARRAY_PUSH", T.ARRAY_GET = "ARRAY_GET", T.ARRAY_SET = "ARRAY_SET", T.ARRAY_LEN = "ARRAY_LEN", T.ARRAY_MAP_PROP = "ARRAY_MAP_PROP", T.ARRAY_FILTER_PROP = "ARRAY_FILTER_PROP", T.ARRAY_SLICE = "ARRAY_SLICE", T.ARRAY_JOIN = "ARRAY_JOIN", T.ARRAY_INDEX_OF = "ARRAY_INDEX_OF", T.STRING_LEN = "STRING_LEN", T.STRING_SUBSTRING = "STRING_SUBSTRING", T.STRING_INDEXOF = "STRING_INDEXOF", T.STRING_SPLIT = "STRING_SPLIT", T.STRING_SLICE = "STRING_SLICE", T.STRING_CHARAT = "STRING_CHARAT", T.STRING_TOUPPERCASE = "STRING_TOUPPERCASE", T.STRING_TOLOWERCASE = "STRING_TOLOWERCASE", T.STRING_INCLUDES = "STRING_INCLUDES", T.STRING_ENDS_WITH = "STRING_ENDS_WITH", T.STRING_STARTS_WITH = "STRING_STARTS_WITH", T.STRING_TRIM = "STRING_TRIM", T.STRING_TRIM_START = "STRING_TRIM_START", T.STRING_TRIM_END = "STRING_TRIM_END", T.STRING_REPLACE = "STRING_REPLACE", T.STRING_REPLACE_ALL = "STRING_REPLACE_ALL", T.STRING_LAST_INDEX_OF = "STRING_LAST_INDEX_OF", T.STRING_REPEAT = "STRING_REPEAT", T.STRING_PAD_START = "STRING_PAD_START", T.STRING_PAD_END = "STRING_PAD_END", T.LOAD_REGEX = "LOAD_REGEX", T.REGEX_TEST = "REGEX_TEST", T.STRING_MATCH = "STRING_MATCH", T.STRING_REPLACE_REGEX = "STRING_REPLACE_REGEX", T.LENGTH = "LENGTH", T.TO_STRING = "TO_STRING", T.JSON_PARSE = "JSON_PARSE", T.TYPEOF = "TYPEOF", T.ADD = "ADD", T.SUB = "SUB", T.MUL = "MUL", T.DIV = "DIV", T.MOD = "MOD", T.UNARY_MINUS = "UNARY_MINUS", T.UNARY_PLUS = "UNARY_PLUS", T.INC = "INC", T.DEC = "DEC", T.EQ = "EQ", T.NEQ = "NEQ", T.LT = "LT", T.GT = "GT", T.LTE = "LTE", T.GTE = "GTE", T.EQ_STRICT = "EQ_STRICT", T.NEQ_STRICT = "NEQ_STRICT", T.JUMP = "JUMP", T.JUMP_IF = "JUMP_IF", T.JUMP_IF_FALSE = "JUMP_IF_FALSE", T.JUMP_IF_TRUE = "JUMP_IF_TRUE", T.CALL = "CALL", T.RETURN = "RETURN", T.AND = "AND", T.OR = "OR", T.NOT = "NOT", T.BREAK = "BREAK", T.CONTINUE = "CONTINUE", T.ITER_START = "ITER_START", T.ITER_NEXT = "ITER_NEXT", T.ITER_END = "ITER_END", T.OBJECT_ITER_START = "OBJECT_ITER_START", T.OBJECT_ITER_NEXT = "OBJECT_ITER_NEXT", T.FS_LIST_FILES = "FS_LIST_FILES", T.FS_READ_FILE = "FS_READ_FILE", T.FS_WRITE_FILE = "FS_WRITE_FILE", T.OBJECT_CREATE = "OBJECT_CREATE", T.PROPERTY_GET = "PROPERTY_GET", T.PROPERTY_SET = "PROPERTY_SET", T.OBJECT_KEYS = "OBJECT_KEYS", T.JSON_STRINGIFY = "JSON_STRINGIFY", T.GET = "GET", T.SET = "SET", T.CC = "CC", T.PRINT = "PRINT", T.HALT = "HALT", T))(P$1 || {});
function _$1(T) {
return typeof T == "string";
}
function E$2(T) {
return typeof T == "number";
}
function n(T) {
return typeof T == "boolean";
}
function t(T) {
return T === null;
}
function S(T) {
return T !== null && typeof T == "object" && "type" in T && T.type === "array";
}
function I$1(T) {
return T !== null && typeof T == "object" && "type" in T && T.type === "undefined";
}
function i$1(T) {
return T !== null && typeof T == "object" && "type" in T && T.type === "object";
}
function L$1(T) {
return T !== null && typeof T == "object" && "type" in T && T.type === "array-ref";
}
function c(T) {
return T !== null && typeof T == "object" && "type" in T && T.type === "object-ref";
}
function u$1(T) {
return _$1(T) ? T : E$2(T) || n(T) ? T.toString() : t(T) ? "null" : I$1(T) ? "undefined" : S(T) ? `[array:${T.elements.length}]` : i$1(T) ? "[object Object]" : String(T);
}
function M$2(T) {
return n(T) ? T : t(T) || I$1(T) ? false : E$2(T) ? T !== 0 : _$1(T) ? T !== "" : S(T) || i$1(T) ? true : !!T;
}
function y$1(T) {
return _$1(T) ? "string" : E$2(T) ? "number" : n(T) ? "boolean" : t(T) ? "null" : I$1(T) ? "undefined" : S(T) || L$1(T) ? "array" : i$1(T) || c(T) ? "object" : "unknown";
}
function F$1(T) {
if (E$2(T)) return T;
if (n(T)) return T ? 1 : 0;
if (t(T)) return 0;
if (I$1(T)) return NaN;
if (_$1(T)) {
const R2 = T.trim();
return R2 === "" ? 0 : Number(R2);
}
return S(T) ? NaN : Number(T);
}
function Y$1(T = [], R2) {
return R2 ? { type: "array", elements: T, properties: R2 } : { type: "array", elements: T };
}
function s() {
return { type: "undefined" };
}
function b$2(T = {}) {
return { type: "object", properties: T };
}
const f$2 = require("pino"), G$2 = require("fs"), D$1 = require("path");
let r = null;
function U$1() {
if (!r) {
const T = process.env.CVM_LOG_LEVEL || "info", R2 = process.env.CVM_LOG_FILE || ".cvm/cvm-debug.log";
let N2;
try {
const A2 = D$1.dirname(R2);
G$2.existsSync(A2) || G$2.mkdirSync(A2, { recursive: true }), N2 = f$2.destination(R2);
} catch {
N2 = process.stdout;
}
r = f$2({
level: T
}, N2), r.info("LogLevel: " + T);
}
return r;
}
const g = new Proxy({}, {
get(T, R2) {
return U$1()[R2];
}
});
var d$2 = Object.defineProperty;
var y = (t2, e, i2) => e in t2 ? d$2(t2, e, { enumerable: true, configurable: true, writable: true, value: i2 }) : t2[e] = i2;
var h$1 = (t2, e, i2) => y(t2, typeof e != "symbol" ? e + "" : e, i2);
function P(t2) {
const e = [], i2 = [];
let s2 = false;
const a2 = r__namespace.createSourceFile(
"program.ts",
t2,
r__namespace.ScriptTarget.Latest,
true
);
function c2(m) {
if (r__namespace.isFunctionDeclaration(m) && m.name && m.name.text === "main" && (s2 = true, m.parameters.length > 0 && e.push("main() must not have parameters")), r__namespace.isCallExpression(m) && r__namespace.isIdentifier(m.expression)) {
const l = m.expression.text;
["setTimeout", "fetch", "require", "import"].includes(l) && e.push(`Unsupported function: ${l}`);
}
r__namespace.forEachChild(m, c2);
}
return c2(a2), s2 || e.push("Program must have a main() function"), e.length === 0 && i2.push({ op: P$1.HALT }), {
bytecode: i2,
errors: e,
hasMain: s2
};
}
let E$1 = class E {
constructor() {
h$1(this, "bytecode", []);
h$1(this, "contextStack", []);
h$1(this, "tempVarCounter", 0);
}
/**
* Emit an instruction and return its index
*/
emit(e, i2) {
const s2 = this.bytecode.length;
return this.bytecode.push({ op: e, arg: i2 }), s2;
}
/**
* Get the current address (next instruction index)
*/
currentAddress() {
return this.bytecode.length;
}
/**
* Patch a jump instruction with the target address
*/
patchJump(e, i2) {
e >= 0 && e < this.bytecode.length && (this.bytecode[e].arg = i2);
}
/**
* Patch multiple jump instructions with the same target
*/
patchJumps(e, i2) {
e.forEach((s2) => this.patchJump(s2, i2));
}
/**
* Push a new jump context onto the stack
*/
pushContext(e) {
g.trace(`CONTEXT: Pushing context type=${e.type}`), this.contextStack.push(e);
}
/**
* Pop the current jump context from the stack
*/
popContext() {
const e = this.contextStack.pop() || null;
return e && g.trace(`CONTEXT: Popped context type=${e.type}, breakTargets=${JSON.stringify(e.breakTargets)}`), e;
}
/**
* Get the current context without removing it
*/
getCurrentContext() {
return this.contextStack.length > 0 ? this.contextStack[this.contextStack.length - 1] : null;
}
/**
* Find the nearest loop context (for break/continue)
*/
findLoopContext() {
for (let e = this.contextStack.length - 1; e >= 0; e--) {
const i2 = this.contextStack[e];
if (i2.type === "loop" || i2.type === "foreach")
return i2;
}
return null;
}
/**
* Get the final bytecode array
*/
getBytecode() {
return this.bytecode;
}
/**
* Check if compilation is in a valid state
*/
isValid() {
return this.contextStack.length === 0;
}
/**
* Get any unclosed contexts (for error reporting)
*/
getUnclosedContexts() {
return [...this.contextStack];
}
/**
* Generate a unique temporary variable name
*/
generateTempVar() {
return `__temp${this.tempVarCounter++}`;
}
};
const k = (t2, e, { compileExpression: i2, compileStatement: s2 }) => {
i2(t2.expression);
const a2 = e.emit(P$1.JUMP_IF_FALSE, -1), c2 = {
type: "if",
endTargets: []
};
if (t2.elseStatement ? c2.elseTarget = a2 : c2.endTargets.push(a2), e.pushContext(c2), s2(t2.thenStatement), t2.elseStatement) {
const l = e.emit(P$1.JUMP, -1);
c2.endTargets.push(l);
const p2 = e.currentAddress();
e.patchJump(a2, p2), s2(t2.elseStatement);
}
const m = e.popContext();
if (m) {
const l = e.currentAddress();
e.patchJumps(m.endTargets, l);
}
}, A$1 = (t2, e, { compileExpression: i2, compileStatement: s2 }) => {
const a2 = e.currentAddress();
i2(t2.expression);
const m = {
type: "loop",
breakTargets: [e.emit(P$1.JUMP_IF_FALSE, -1)],
continueTargets: [],
endTargets: [],
startAddress: a2
};
e.pushContext(m), s2(t2.statement), e.emit(P$1.JUMP, a2);
const l = e.popContext();
if (l) {
const p2 = e.currentAddress();
e.patchJumps(l.breakTargets || [], p2), e.patchJumps(l.continueTargets || [], a2);
}
}, I = (t2, e, { compileExpression: i2, compileStatement: s2 }) => {
const a2 = t2.initializer, c2 = t2.expression;
let m;
if (r__namespace.isVariableDeclarationList(a2))
m = a2.declarations[0].name.getText();
else if (r__namespace.isIdentifier(a2))
m = a2.text;
else
throw new Error("Unsupported for-of variable declaration");
i2(c2), e.emit(P$1.ITER_START);
const l = e.currentAddress();
e.emit(P$1.ITER_NEXT);
const p2 = e.emit(P$1.JUMP_IF_FALSE, -1);
g.trace(`FOR-OF: Created JUMP_IF_FALSE at index ${p2} for var ${m}`), e.emit(P$1.STORE, m);
const g$1 = {
type: "foreach",
breakTargets: [p2],
continueTargets: [],
endTargets: [],
startAddress: l,
iterVariable: m
};
e.pushContext(g$1);
let o = null;
try {
s2(t2.statement);
} catch (x2) {
g.trace(`FOR-OF: Error compiling loop body for var ${m}: ${x2}`), o = x2;
}
o || e.emit(P$1.JUMP, l);
const u2 = e.popContext();
if (u2) {
const x2 = e.currentAddress();
g.trace(`FOR-OF: Patching breakTargets ${JSON.stringify(u2.breakTargets)} to ${x2} for var ${m}`), e.emit(P$1.ITER_END), e.patchJumps(u2.breakTargets || [], x2), e.patchJumps(u2.continueTargets || [], l);
} else
g.trace(`FOR-OF: NO CONTEXT TO PATCH for var ${m}!`);
if (o)
throw o;
}, R = (t2, e, { compileExpression: i2, compileStatement: s2 }) => {
const a2 = t2.initializer, c2 = t2.expression;
let m;
if (r__namespace.isVariableDeclarationList(a2))
m = a2.declarations[0].name.getText();
else if (r__namespace.isIdentifier(a2))
m = a2.text;
else
throw new Error("Unsupported for-in variable declaration");
i2(c2), e.emit(P$1.OBJECT_ITER_START);
const l = e.currentAddress();
e.emit(P$1.OBJECT_ITER_NEXT);
const p2 = e.emit(P$1.JUMP_IF_FALSE, -1);
e.emit(P$1.STORE, m);
const g2 = {
type: "foreach",
breakTargets: [p2],
continueTargets: [],
endTargets: [],
startAddress: l,
iterVariable: m
};
e.pushContext(g2), s2(t2.statement), e.emit(P$1.JUMP, l);
const o = e.popContext();
if (o) {
const u2 = e.currentAddress();
e.patchJumps(o.breakTargets || [], u2), e.patchJumps(o.continueTargets || [], l), e.emit(P$1.ITER_END);
}
}, C$1 = (t2, e, { compileExpression: i2, compileStatement: s2 }) => {
if (t2.initializer)
if (r__namespace.isVariableDeclarationList(t2.initializer))
for (const g2 of t2.initializer.declarations)
g2.initializer && (i2(g2.initializer), e.emit(P$1.STORE, g2.name.getText()));
else
i2(t2.initializer), e.emit(P$1.POP);
const a2 = e.currentAddress();
let c2;
t2.condition && (i2(t2.condition), c2 = e.emit(P$1.JUMP_IF_FALSE, -1));
const m = {
type: "loop",
breakTargets: c2 ? [c2] : [],
continueTargets: [],
endTargets: [],
startAddress: a2
};
e.pushContext(m), s2(t2.statement);
const l = e.currentAddress();
t2.incrementor && (i2(t2.incrementor), e.emit(P$1.POP)), e.emit(P$1.JUMP, a2);
const p2 = e.popContext();
if (p2) {
const g2 = e.currentAddress();
e.patchJumps(p2.breakTargets || [], g2), e.patchJumps(p2.continueTargets || [], l);
}
}, U = (t2, e, { compileExpression: i2, compileStatement: s2 }) => {
const a2 = e.generateTempVar();
i2(t2.expression), e.emit(P$1.STORE, a2);
const c2 = [], m = [];
let l = null;
if (t2.caseBlock.clauses.forEach((o, u2) => {
if (r__namespace.isCaseClause(o)) {
e.emit(P$1.LOAD, a2), i2(o.expression), e.emit(P$1.EQ_STRICT);
const x2 = e.emit(P$1.JUMP_IF_TRUE, -1);
m.push(x2);
} else r__namespace.isDefaultClause(o) && (l = e.emit(P$1.JUMP, -1));
}), l === null) {
const o = e.emit(P$1.JUMP, -1);
c2.push(o);
}
let p2 = 0;
t2.caseBlock.clauses.forEach((o, u2) => {
if (r__namespace.isCaseClause(o)) {
const x2 = e.currentAddress();
e.patchJumps([m[p2]], x2), p2++, o.statements.forEach((f3) => {
if (r__namespace.isBreakStatement(f3)) {
const T = e.emit(P$1.JUMP, -1);
c2.push(T);
} else
s2(f3);
});
} else if (r__namespace.isDefaultClause(o)) {
const x2 = e.currentAddress();
l !== null && e.patchJumps([l], x2), o.statements.forEach((f3) => {
if (r__namespace.isBreakStatement(f3)) {
const T = e.emit(P$1.JUMP, -1);
c2.push(T);
} else
s2(f3);
});
}
});
const g2 = e.currentAddress();
e.patchJumps(c2, g2);
}, _ = (t2, e, { compileStatement: i2 }) => {
t2.statements.forEach((s2) => {
i2(s2);
});
}, b$1 = (t2, e, { compileExpression: i2 }) => {
const s2 = t2.declarationList.declarations[0];
s2.initializer && (i2(s2.initializer), e.emit(P$1.STORE, s2.name.getText()));
}, N = (t2, e, { compileExpression: i2 }) => {
const s2 = t2.expression;
if (r__namespace.isBinaryExpression(s2)) {
const a2 = s2.operatorToken.kind;
if (a2 === r__namespace.SyntaxKind.PlusEqualsToken || a2 === r__namespace.SyntaxKind.MinusEqualsToken || a2 === r__namespace.SyntaxKind.AsteriskEqualsToken || a2 === r__namespace.SyntaxKind.SlashEqualsToken || a2 === r__namespace.SyntaxKind.PercentEqualsToken) {
if (r__namespace.isIdentifier(s2.left)) {
switch (e.emit(P$1.LOAD, s2.left.text), i2(s2.right), a2) {
case r__namespace.SyntaxKind.PlusEqualsToken:
e.emit(P$1.ADD);
break;
case r__namespace.SyntaxKind.MinusEqualsToken:
e.emit(P$1.SUB);
break;
case r__namespace.SyntaxKind.AsteriskEqualsToken:
e.emit(P$1.MUL);
break;
case r__namespace.SyntaxKind.SlashEqualsToken:
e.emit(P$1.DIV);
break;
case r__namespace.SyntaxKind.PercentEqualsToken:
e.emit(P$1.MOD);
break;
}
e.emit(P$1.STORE, s2.left.text);
} else if (r__namespace.isElementAccessExpression(s2.left))
throw new Error("Compound assignment to array elements not yet supported");
return;
} else if (a2 === r__namespace.SyntaxKind.EqualsToken) {
if (i2(s2.right), r__namespace.isIdentifier(s2.left))
e.emit(P$1.STORE, s2.left.text);
else if (r__namespace.isElementAccessExpression(s2.left)) {
const c2 = `__temp_${e.getBytecode().length}`;
e.emit(P$1.STORE, c2), i2(s2.left.expression), i2(s2.left.argumentExpression), e.emit(P$1.LOAD, c2), e.emit(P$1.ARRAY_SET), e.emit(P$1.POP);
} else if (r__namespace.isPropertyAccessExpression(s2.left)) {
const c2 = `__temp_${e.getBytecode().length}`;
e.emit(P$1.STORE, c2), i2(s2.left.expression), e.emit(P$1.PUSH, s2.left.name.text), e.emit(P$1.LOAD, c2), e.emit(P$1.PROPERTY_SET), e.emit(P$1.POP);
}
return;
}
}
r__namespace.isCallExpression(s2) && r__namespace.isPropertyAccessExpression(s2.expression) && s2.expression.expression.getText() === "console" && s2.expression.name.getText() === "log" ? (s2.arguments.forEach((a2) => {
i2(a2);
}), e.emit(P$1.PRINT)) : r__namespace.isCallExpression(s2) && r__namespace.isIdentifier(s2.expression) && s2.expression.text === "CC" ? (s2.arguments.length > 0 && i2(s2.arguments[0]), e.emit(P$1.CC), e.emit(P$1.POP)) : r__namespace.isCallExpression(s2) && r__namespace.isPropertyAccessExpression(s2.expression) && s2.expression.name.getText() === "push" ? (i2(s2.expression.expression), s2.arguments.length > 0 && i2(s2.arguments[0]), e.emit(P$1.ARRAY_PUSH)) : r__namespace.isPostfixUnaryExpression(s2) || r__namespace.isPrefixUnaryExpression(s2) ? (i2(s2), e.emit(P$1.POP)) : (i2(s2), e.emit(P$1.POP));
}, O = (t2, e, { compileExpression: i2 }) => {
t2.expression ? i2(t2.expression) : e.emit(P$1.PUSH, null), e.emit(P$1.RETURN);
}, K = (t2, e, i2) => {
const s2 = e.findLoopContext();
if (s2) {
s2.type === "foreach" && e.emit(P$1.ITER_END);
const a2 = e.emit(P$1.BREAK, -1);
s2.breakTargets = s2.breakTargets || [], s2.breakTargets.push(a2);
} else
i2.reportError(t2, "break statement not in loop");
}, F = (t2, e, i2) => {
const s2 = e.findLoopContext();
if (s2 && s2.startAddress !== void 0) {
const a2 = e.emit(P$1.CONTINUE, -1);
s2.continueTargets = s2.continueTargets || [], s2.continueTargets.push(a2);
} else
i2.reportError(t2, "continue statement not in loop");
}, L = {
[r__namespace.SyntaxKind.IfStatement]: k,
[r__namespace.SyntaxKind.WhileStatement]: A$1,
[r__namespace.SyntaxKind.ForOfStatement]: I,
[r__namespace.SyntaxKind.ForInStatement]: R,
[r__namespace.SyntaxKind.ForStatement]: C$1,
[r__namespace.SyntaxKind.SwitchStatement]: U,
[r__namespace.SyntaxKind.Block]: _,
[r__namespace.SyntaxKind.VariableStatement]: b$1,
[r__namespace.SyntaxKind.ExpressionStatement]: N,
[r__namespace.SyntaxKind.ReturnStatement]: O,
[r__namespace.SyntaxKind.BreakStatement]: K,
[r__namespace.SyntaxKind.ContinueStatement]: F
}, J = (t2, e, i2) => {
e.emit(P$1.PUSH, t2.text);
}, H = (t2, e, i2) => {
e.emit(P$1.PUSH, Number(t2.text));
}, D = (t2, e, i2) => {
e.emit(P$1.PUSH, true);
}, M$1 = (t2, e, i2) => {
e.emit(P$1.PUSH, false);
}, G$1 = (t2, e, i2) => {
e.emit(P$1.PUSH, null);
}, w = (t2, e, i2) => {
const s2 = t2.text, a2 = s2.lastIndexOf("/"), c2 = s2.substring(1, a2), m = s2.substring(a2 + 1);
e.emit(P$1.LOAD_REGEX, { pattern: c2, flags: m });
}, q$1 = (t2, e, i2) => {
t2.text === "undefined" ? e.emit(P$1.PUSH_UNDEFINED) : e.emit(P$1.LOAD, t2.text);
}, B = (t2, e, { compileExpression: i2 }) => {
e.emit(P$1.ARRAY_NEW), t2.elements.forEach((s2) => {
i2(s2), e.emit(P$1.ARRAY_PUSH);
});
}, V = (t2, e, { compileExpression: i2 }) => {
i2(t2.expression);
}, $$2 = (t2, e, { compileExpression: i2 }) => {
t2.name.text === "length" ? (i2(t2.expression), e.emit(P$1.LENGTH)) : (i2(t2.expression), e.emit(P$1.PUSH, t2.name.text), e.emit(P$1.PROPERTY_GET));
}, j = (t2, e, { compileExpression: i2, reportError: s2 }) => {
i2(t2.expression), t2.argumentExpression ? i2(t2.argumentExpression) : s2(t2, "Element access requires an index expression"), e.emit(P$1.ARRAY_GET);
}, v$1 = (t2, e, { compileExpression: i2 }) => {
switch (t2.operator) {
case r__namespace.SyntaxKind.ExclamationToken:
i2(t2.operand), e.emit(P$1.NOT);
break;
case r__namespace.SyntaxKind.MinusToken:
i2(t2.operand), e.emit(P$1.UNARY_MINUS);
break;
case r__namespace.SyntaxKind.PlusToken:
i2(t2.operand), e.emit(P$1.UNARY_PLUS);
break;
case r__namespace.SyntaxKind.PlusPlusToken:
r__namespace.isIdentifier(t2.operand) && (e.emit(P$1.PUSH, t2.operand.text), e.emit(P$1.INC, false));
break;
case r__namespace.SyntaxKind.MinusMinusToken:
r__namespace.isIdentifier(t2.operand) && (e.emit(P$1.PUSH, t2.operand.text), e.emit(P$1.DEC, false));
break;
}
}, Y = (t2, e, { compileExpression: i2 }) => {
switch (t2.operator) {
case r__namespace.SyntaxKind.PlusPlusToken:
r__namespace.isIdentifier(t2.operand) && (e.emit(P$1.PUSH, t2.operand.text), e.emit(P$1.INC, true));
break;
case r__namespace.SyntaxKind.MinusMinusToken:
r__namespace.isIdentifier(t2.operand) && (e.emit(P$1.PUSH, t2.operand.text), e.emit(P$1.DEC, true));
break;
}
}, z = (t2, e, { compileExpression: i2 }) => {
const s2 = t2.operatorToken.kind;
switch (i2(t2.left), i2(t2.right), s2) {
case r__namespace.SyntaxKind.PlusToken:
e.emit(P$1.ADD);
break;
case r__namespace.SyntaxKind.MinusToken:
e.emit(P$1.SUB);
break;
case r__namespace.SyntaxKind.AsteriskToken:
e.emit(P$1.MUL);
break;
case r__namespace.SyntaxKind.SlashToken:
e.emit(P$1.DIV);
break;
case r__namespace.SyntaxKind.PercentToken:
e.emit(P$1.MOD);
break;
case r__namespace.SyntaxKind.EqualsEqualsToken:
e.emit(P$1.EQ);
break;
case r__namespace.SyntaxKind.ExclamationEqualsToken:
e.emit(P$1.NEQ);
break;
case r__namespace.SyntaxKind.LessThanToken:
e.emit(P$1.LT);
break;
case r__namespace.SyntaxKind.GreaterThanToken:
e.emit(P$1.GT);
break;
case r__namespace.SyntaxKind.LessThanEqualsToken:
e.emit(P$1.LTE);
break;
case r__namespace.SyntaxKind.GreaterThanEqualsToken:
e.emit(P$1.GTE);
break;
case r__namespace.SyntaxKind.EqualsEqualsEqualsToken:
e.emit(P$1.EQ_STRICT);
break;
case r__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
e.emit(P$1.NEQ_STRICT);
break;
case r__namespace.SyntaxKind.AmpersandAmpersandToken:
e.emit(P$1.AND);
break;
case r__namespace.SyntaxKind.BarBarToken:
e.emit(P$1.OR);
break;
}
}, X$1 = (t2, e, { compileExpression: i2 }) => {
i2(t2.condition);
const s2 = e.emit(P$1.JUMP_IF_FALSE, -1);
i2(t2.whenTrue);
const a2 = e.emit(P$1.JUMP, -1), c2 = e.currentAddress();
e.patchJump(s2, c2), i2(t2.whenFalse);
const m = e.currentAddress();
e.patchJump(a2, m);
}, W$1 = (t2, e, { compileExpression: i2 }) => {
i2(t2.expression), e.emit(P$1.TYPEOF);
}, Q = (t2, e, { compileExpression: i2, reportError: s2 }) => {
if (r__namespace.isPropertyAccessExpression(t2.expression) && r__namespace.isIdentifier(t2.expression.expression) && t2.expression.expression.text === "fs") {
const a2 = t2.expression.name.text;
if (a2 === "listFiles")
t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, "."), t2.arguments.length > 1 && i2(t2.arguments[1]), e.emit(P$1.FS_LIST_FILES);
else if (a2 === "readFile")
t2.arguments.length > 0 ? (i2(t2.arguments[0]), e.emit(P$1.FS_READ_FILE)) : s2(t2, "fs.readFile() requires a path argument");
else if (a2 === "writeFile") {
if (t2.arguments.length < 2) {
s2(t2, "fs.writeFile() requires path and content arguments");
return;
}
i2(t2.arguments[0]), i2(t2.arguments[1]), e.emit(P$1.FS_WRITE_FILE);
} else
s2(t2, `Unsupported fs method: ${a2}`);
} else if (r__namespace.isPropertyAccessExpression(t2.expression) && r__namespace.isIdentifier(t2.expression.expression) && t2.expression.expression.text === "JSON" && t2.expression.name.text === "parse")
t2.arguments.length > 0 && i2(t2.arguments[0]), e.emit(P$1.JSON_PARSE);
else if (r__namespace.isPropertyAccessExpression(t2.expression) && r__namespace.isIdentifier(t2.expression.expression) && t2.expression.expression.text === "JSON" && t2.expression.name.text === "stringify")
t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH_UNDEFINED), e.emit(P$1.JSON_STRINGIFY);
else if (r__namespace.isPropertyAccessExpression(t2.expression) && r__namespace.isIdentifier(t2.expression.expression) && t2.expression.expression.text === "Object" && t2.expression.name.text === "keys") {
if (t2.arguments.length !== 1) {
s2(t2, "Object.keys() requires exactly one argument");
return;
}
i2(t2.arguments[0]), e.emit(P$1.OBJECT_KEYS);
} else if (r__namespace.isIdentifier(t2.expression) && t2.expression.text === "CC")
t2.arguments.length > 0 && i2(t2.arguments[0]), e.emit(P$1.CC);
else if (r__namespace.isPropertyAccessExpression(t2.expression)) {
const a2 = t2.expression.name.text;
if (a2 === "substring")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, 0), t2.arguments.length > 1 && i2(t2.arguments[1]), e.emit(P$1.STRING_SUBSTRING);
else if (a2 === "indexOf")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), e.emit(P$1.STRING_INDEXOF);
else if (a2 === "split")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), e.emit(P$1.STRING_SPLIT);
else if (a2 === "slice")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, 0), t2.arguments.length > 1 ? i2(t2.arguments[1]) : e.emit(P$1.PUSH_UNDEFINED), e.emit(P$1.STRING_SLICE);
else if (a2 === "join")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ","), e.emit(P$1.ARRAY_JOIN);
else if (a2 === "charAt")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, 0), e.emit(P$1.STRING_CHARAT);
else if (a2 === "toUpperCase")
i2(t2.expression.expression), e.emit(P$1.STRING_TOUPPERCASE);
else if (a2 === "toLowerCase")
i2(t2.expression.expression), e.emit(P$1.STRING_TOLOWERCASE);
else if (a2 === "toString")
i2(t2.expression.expression), e.emit(P$1.TO_STRING);
else if (a2 === "includes")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), e.emit(P$1.STRING_INCLUDES);
else if (a2 === "endsWith")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), e.emit(P$1.STRING_ENDS_WITH);
else if (a2 === "startsWith")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), e.emit(P$1.STRING_STARTS_WITH);
else if (a2 === "trim")
i2(t2.expression.expression), e.emit(P$1.STRING_TRIM);
else if (a2 === "trimStart")
i2(t2.expression.expression), e.emit(P$1.STRING_TRIM_START);
else if (a2 === "trimEnd")
i2(t2.expression.expression), e.emit(P$1.STRING_TRIM_END);
else if (a2 === "test")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), e.emit(P$1.REGEX_TEST);
else if (a2 === "match") {
if (i2(t2.expression.expression), t2.arguments.length > 0)
i2(t2.arguments[0]);
else {
s2(t2, "match() requires a regex argument");
return;
}
e.emit(P$1.STRING_MATCH);
} else if (a2 === "replace")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), t2.arguments.length > 1 ? i2(t2.arguments[1]) : e.emit(P$1.PUSH, ""), e.emit(P$1.STRING_REPLACE_REGEX);
else if (a2 === "replaceAll")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), t2.arguments.length > 1 ? i2(t2.arguments[1]) : e.emit(P$1.PUSH, ""), e.emit(P$1.STRING_REPLACE_ALL);
else if (a2 === "lastIndexOf")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, ""), e.emit(P$1.STRING_LAST_INDEX_OF);
else if (a2 === "repeat")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, 0), e.emit(P$1.STRING_REPEAT);
else if (a2 === "padStart")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, 0), t2.arguments.length > 1 ? i2(t2.arguments[1]) : e.emit(P$1.PUSH, " "), e.emit(P$1.STRING_PAD_START);
else if (a2 === "padEnd")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH, 0), t2.arguments.length > 1 ? i2(t2.arguments[1]) : e.emit(P$1.PUSH, " "), e.emit(P$1.STRING_PAD_END);
else if (a2 === "push")
i2(t2.expression.expression), t2.arguments.length > 0 ? i2(t2.arguments[0]) : e.emit(P$1.PUSH_UNDEFINED), e.emit(P$1.ARRAY_PUSH);
else
throw new Error(`Method call '${a2}' is not supported`);
} else
throw new Error("Unsupported call expression");
}, Z$1 = (t2, e, { compileExpression: i2 }) => {
e.emit(P$1.OBJECT_CREATE);
for (const s2 of t2.properties)
if (r__namespace.isPropertyAssignment(s2)) {
let a2;
if (r__namespace.isIdentifier(s2.name))
a2 = s2.name.text;
else if (r__namespace.isStringLiteral(s2.name))
a2 = s2.name.text;
else
throw new Error("Computed property names are not supported");
e.emit(P$1.PUSH, a2), i2(s2.initializer), e.emit(P$1.PROPERTY_SET);
} else if (r__namespace.isShorthandPropertyAssignment(s2)) {
const a2 = s2.name.text;
e.emit(P$1.PUSH, a2), e.emit(P$1.LOAD, a2), e.emit(P$1.PROPERTY_SET);
} else
throw new Error("Unsupported property type in object literal");
}, ee$1 = {
[r__namespace.SyntaxKind.StringLiteral]: J,
[r__namespace.SyntaxKind.NumericLiteral]: H,
[r__namespace.SyntaxKind.TrueKeyword]: D,
[r__namespace.SyntaxKind.FalseKeyword]: M$1,
[r__namespace.SyntaxKind.NullKeyword]: G$1,
[r__namespace.SyntaxKind.RegularExpressionLiteral]: w,
[r__namespace.SyntaxKind.Identifier]: q$1,
[r__namespace.SyntaxKind.ArrayLiteralExpression]: B,
[r__namespace.SyntaxKind.BinaryExpression]: z,
[r__namespace.SyntaxKind.PrefixUnaryExpression]: v$1,
[r__namespace.SyntaxKind.PostfixUnaryExpression]: Y,
[r__namespace.SyntaxKind.CallExpression]: Q,
[r__namespace.SyntaxKind.PropertyAccessExpression]: $$2,
[r__namespace.SyntaxKind.ElementAccessExpression]: j,
[r__namespace.SyntaxKind.ConditionalExpression]: X$1,
[r__namespace.SyntaxKind.TypeOfExpression]: W$1,
[r__namespace.SyntaxKind.ParenthesizedExpression]: V,
[r__namespace.SyntaxKind.ObjectLiteralExpression]: Z$1
};
function ie$1(t2) {
g.trace("Compilation starting", { sourceLength: t2.length });
const e = [], i2 = P(t2);
if (i2.errors.length > 0)
return {
success: false,
bytecode: [],
errors: i2.errors.map((o) => ({
message: o,
line: 0,
character: 0
}))
};
const s2 = new E$1(), a2 = r__namespace.createSourceFile("program.ts", t2, r__namespace.ScriptTarget.Latest, true), c2 = {
compileStatement: m,
compileExpression: l,
reportError: (o, u2) => {
const { line: x2, character: f3 } = a2.getLineAndCharacterOfPosition(o.getStart());
throw e.push({
message: u2,
line: x2 + 1,
// TypeScript uses 0-based lines
character: f3 + 1
// TypeScript uses 0-based columns
}), new Error(u2);
}
};
function m(o) {
const { line: u2, character: x2 } = a2.getLineAndCharacterOfPosition(o.getStart()), f3 = r__namespace.SyntaxKind[o.kind];
g.debug("Compiling statement", { line: u2 + 1, kind: f3 });
const T = L[o.kind];
T ? (g.trace("Visiting statement", { kind: f3, pc: s2.currentAddress() }), T(o, s2, c2), g.trace("Completed statement", { kind: f3, pc: s2.currentAddress() })) : (e.push({
message: `Unsupported statement: ${r__namespace.SyntaxKind[o.kind]}`,
line: u2 + 1,
character: x2 + 1
}), g.debug("Unsupported statement", { kind: f3, line: u2 + 1 }));
}
function l(o) {
const { line: u2, character: x2 } = a2.getLineAndCharacterOfPosition(o.getStart()), f3 = r__namespace.SyntaxKind[o.kind];
g.debug("Compiling expression", { line: u2 + 1, kind: f3 });
const T = ee$1[o.kind];
T ? (g.trace("Visiting expression", { kind: f3, pc: s2.currentAddress() }), T(o, s2, c2), g.trace("Completed expression", { kind: f3, pc: s2.currentAddress() })) : (e.push({
message: `Unsupported expression: ${r__namespace.SyntaxKind[o.kind]}`,
line: u2 + 1,
character: x2 + 1
}), g.debug("Unsupported expression", { kind: f3, line: u2 + 1 }));
}
a2.forEachChild((o) => {
var u2;
r__namespace.isFunctionDeclaration(o) && ((u2 = o.name) == null ? void 0 : u2.text) === "main" && o.body && (g.debug("Found main function", { statementCount: o.body.statements.length }), o.body.statements.forEach((x2, f3) => {
g.trace("Compiling main statement", {
statementIndex: f3 + 1,
totalStatements: o.body.statements.length
});
try {
m(x2);
} catch (T) {
g.debug("Error in statement", {
statementIndex: f3 + 1,
error: String(T)
});
}
}));
}), s2.emit(P$1.HALT);
const p2 = s2.getBytecode();
g.debug("Compilation completed", {
bytecodeLength: p2.length,
contextStackValid: s2.isValid(),
unclosedContexts: s2.getUnclosedContexts()
});
const g$1 = p2.map((o, u2) => ({ idx: u2, instr: o })).filter(
({ instr: o }) => (o.op === P$1.JUMP_IF_FALSE || o.op === P$1.JUMP || o.op === P$1.CONTINUE || o.op === P$1.BREAK) && o.arg === -1
);
return g$1.length > 0 && g.debug("Found unpatched jump instructions", { unpatchedJumps: g$1 }), {
success: e.length === 0,
bytecode: p2,
errors: e
};
}
var d$1 = Object.defineProperty;
var h = (s2, t2, n2) => t2 in s2 ? d$1(s2, t2, { enumerable: true, configurable: true, writable: true, value: n2 }) : s2[t2] = n2;
var a = (s2, t2, n2) => h(s2, typeof t2 != "symbol" ? t2 + "" : t2, n2);
class p {
constructor(t2) {
a(this, "connected", false);
a(this, "programsDir");
a(this, "executionsDir");
a(this, "outputsDir");
this.dataDir = t2, this.programsDir = r__namespace$1.join(t2, "programs"), this.executionsDir = r__namespace$1.join(t2, "executions"), this.outputsDir = r__namespace$1.join(t2, "outputs");
}
get metadataFile() {
return r__namespace$1.join(this.dataDir, "metadata.json");
}
async connect() {
await N$1.promises.mkdir(this.dataDir, { recursive: true }), await N$1.promises.mkdir(this.programsDir, { recursive: true }), await N$1.promises.mkdir(this.executionsDir, { recursive: true }), await N$1.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
}
async disconnect() {
this.connected = false;
}
isConnected() {
return this.connected;
}
async saveProgram(t2) {
if (!this.connected) throw new Error("Not connected");
const n2 = r__namespace$1.join(this.programsDir, `${t2.id}.json`), e = JSON.stringify(t2, null, 2);
await N$1.promises.writeFile(n2, e, "utf-8");
}
async getProgram(t2) {
if (!this.connected) throw new Error("Not connected");
const n2 = r__namespace$1.join(this.programsDir, `${t2}.json`);
try {
const e = await N$1.promises.readFile(n2, "utf-8"), o = JSON.parse(e);
return o.created = new Date(o.created), o.updated && (o.updated = new Date(o.updated)), o;
} catch (e) {
if (e.code === "ENOENT")
return null;
throw e;
}
}
async saveExecution(t2) {
if (!this.connected) throw new Error("Not connected");
const n2 = r__namespace$1.join(this.executionsDir, `${t2.id}.json`), e = JSON.stringify(t2, null, 2);
await N$1.promises.writeFile(n2, e, "utf-8");
}
async getExecution(t2) {
if (!this.connected) throw new Error("Not connected");
const n2 = r__namespace$1.join(this.executionsDir, `${t2}.json`);
try {
const e = await N$1.promises.readFile(n2, "utf-8"), o = JSON.parse(e);
return o.created = new Date(o.created), o.updated && (o.updated = new Date(o.updated)), o;
} catch (e) {
if (e.code === "ENOENT")
return null;
throw e;
}
}
async appendOutput(t2, n2) {
if (!this.connected) throw new Error("Not connected");
const e = r__namespace$1.join(this.outputsDir, `${t2}.output`), o = n2.join(`
`) + `
`;
await N$1.promises.appendFile(e, o, "utf-8");
}
async getOutput(t2) {
if (!this.connected) throw new Error("Not connected");
const n2 = r__namespace$1.join(this.outputsDir, `${t2}.output`);
try {
return (await N$1.promises.readFile(n2, "utf-8")).split(`
`).filter((o) => o.length > 0);
} catch (e) {
if (e.code === "ENOENT")
return [];
throw e;
}
}
async listExecutions() {
if (!this.connected) throw new Error("Not connected");
const t2 = await N$1.promises.readdir(this.executionsDir), n2 = [];
for (const e of t2)
if (e.endsWith(".json")) {
const o = e.slice(0, -5), i2 = await this.getExecution(o);
i2 && n2.push(i2);
}
return n2;
}
async getCurrentExecutionId() {
if (!this.connected) throw new Error("Not connected");
try {
const t2 = await N$1.promises.readFile(this.metadataFile, "utf-8");
return JSON.parse(t2).currentExecutionId || null;
} catch (t2) {
if (t2.code === "ENOENT")
return null;
throw t2;
}
}
async setCurrentExecutionId(t2) {
if (!this.connected) throw new Error("Not connected");
const n2 = { currentExecutionId: t2 };
await N$1.promises.writeFile(this.metadataFile, JSON.stringify(n2, null, 2), "utf-8");
}
async deleteExecution(t2) {
if (!this.connected) throw new Error("Not connected");
const n2 = r__namespace$1.join(this.executionsDir, `${t2}.json`);
try {
await N$1.promises.unlink(n2);
} catch (i2) {
if (i2.code !== "ENOENT") throw i2;
}
const e = r__namespace$1.join(this.outputsDir, `${t2}.output`);
try {
await N$1.promises.unlink(e);
} catch (i2) {
if (i2.code !== "ENOENT") throw i2;
}
await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null);
}
async listPrograms() {
if (!this.connected) throw new Error("Not connected");
const t2 = await N$1.promises.readdir(this.programsDir), n2 = [];
for (const e of t2)
if (e.endsWith(".json")) {
const o = e.slice(0, -5), i2 = await this.getProgram(o);
i2 && n2.push(i2);
}
return n2;
}
async deleteProgram(t2) {
if (!this.connected) throw new Error("Not connected");
const n2 = r__namespace$1.join(this.programsDir, `${t2}.json`);
try {
await N$1.promises.unlink(n2);
} catch (e) {
if (e.code !== "ENOENT") throw e;
}
}
}
let f$1 = class f {
constructor(t2) {
a(this, "client");
a(this, "db", null);
a(this, "connected", false);
this.connectionString = t2, this.client = new mongodb.MongoClient(t2);
}
async connect() {
var o;
await this.client.connect();
const t2 = ((o = this.connectionString.split("/").pop()) == null ? void 0 : o.split("?")[0]) || "cvm";
this.db = this.client.db(t2), this.connected = true;
const e = (await this.db.listCollections().toArray()).map((i2) => i2.name);
e.includes("programs") || await this.db.createCollection("programs"), e.includes("executions") || await this.db.createCollection("executions"), e.includes("outputs") || await this.db.createCollection("outputs"), e.includes("metadata") || await this.db.createCollection("metadata");
}
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");
return (await this.db.listCollections().toArray()).map((n2) => n2.name);
}
getCollection(t2) {
if (!this.db) throw new Error("Not connected to database");
return this.db.collection(t2);
}
async saveProgram(t2) {
await this.getCollection("programs").replaceOne(
{ id: t2.id },
t2,
{ upsert: true }
);
}
async getProgram(t2) {
return await this.getCollection("programs").findOne({ id: t2 });
}
async saveExecution(t2) {
await this.getCollection("executions").replaceOne(
{ id: t2.id },
t2,
{ upsert: true }
);
}
async getExecution(t2) {
return await this.getCollection("executions").findOne({ id: t2 });
}
async appendOutput(t2, n2) {
const e = this.getCollection("outputs");
await e.findOne({ executionId: t2 }) ? await e.updateOne(
{ executionId: t2 },
{ $push: { lines: { $each: n2 } } }
) : await e.insertOne({ executionId: t2, lines: n2 });
}
async getOutput(t2) {
const e = await this.getCollection("outputs").findOne({ executionId: t2 });
return (e == null ? void 0 : e.lines) || [];
}
async listExecutions() {
return await this.getCollection("executions").find({}).toArray();
}
async getCurrentExecutionId() {
const n2 = await this.getCollection("metadata").findOne({ _id: "current" });
return (n2 == null ? void 0 : n2.currentExecutionId) || null;
}
async setCurrentExecutionId(t2) {
await this.getCollection("metadata").replaceOne(
{ _id: "current" },
{ _id: "current", currentExecutionId: t2 },
{ upsert: true }
);
}
async deleteExecution(t2) {
var o;
let n2 = true;
const e = this.client.startSession();
try {
await e.withTransaction(async () => {
await this.getCollection("executions").deleteOne({ id: t2 }, { session: e }), await this.getCollection("outputs").deleteMany({ executionId: t2 }, { session: e }), await this.getCurrentExecutionId() === t2 && await this.db.collection("system").updateOne(
{ _id: "current" },
{ $set: { executionId: null } },
{ session: e }
);
});
} catch (i2) {
if ((o = i2 == null ? void 0 : i2.message) != null && o.includes("Transaction numbers are only allowed"))
n2 = false;
else
throw i2;
} finally {
await e.endSession();
}
n2 || (await this.getCollection("executions").deleteOne({ id: t2 }), await this.getCollection("outputs").deleteMany({ executionId: t2 }), await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null));
}
async listPrograms() {
return await this.getCollection("programs").find({}).toArray();
}
async deleteProgram(t2) {
await this.getCollection("programs").deleteOne({ id: t2 });
}
};
class E2 {
static create(t2) {
const n2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
switch (n2) {
case "file": {
const e = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
return new p(e);
}
case "mongodb": {
const e = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
return new f$1(e);
}
default:
throw new Error(`Unsupported storage type: ${n2}`);
}
}
}
var W = Object.defineProperty;
var X = (e, t2, r2) => t2 in e ? W(e, t2, { enumerable: true, configurable: true, writable: true, value: r2 }) : e[t2] = r2;
var b = (e, t2, r2) => X(e, typeof t2 != "symbol" ? t2 + "" : t2, r2);
function Z(e) {
return !!(e && typeof e == "object" && "type" in e && "message" in e);
}
function d(e, t2) {
return e.stack.length < 1 ? {
type: "RuntimeError",
message: "Stack underflow",
pc: e.pc,
opcode: t2 || P$1.POP
} : e.stack.pop();
}
const f2 = Z, ee = {
[P$1.ADD]: {
stackIn: 2,
stackOut: 1,
execute: (e, t2) => {
const r2 = d(e, t2.op);
if (f2(r2)) return r2;
const o = d(e, t2.op);
if (f2(o)) return o;
if (_$1(o) || _$1(r2))
e.stack.push(u$1(o) + u$1(r2));
else {
const c2 = F$1(o), s2 = F$1(r2);
e.stack.push(c2 + s2);
}
}
},
[P$1.SUB]: {
stackIn: 2,
stackOut: 1,
execute: (e, t2) => {
const r2 = d(e, t2.op);
if (f2(r2)) return r2;
const o = d(e, t2.op);
if (f2(o)) return o;
const c2 = F$1(o), s2 = F$1(r2);
e.stack.push(c2 - s2);
}
},
[P$1.MUL]: {
stackIn: 2,
stackOut: 1,
execute: (e, t2) => {
const r2 = d(e, t2.op);
if (f2(r2)) return r2;
const o = d(e, t2.op);
if (f2(o)) return o;
const c2 = F$1(o), s2 = F$1(r2);
e.stack.push(c2 * s2);
}
},
[P$1.DIV]: {
stackIn: 2,
stackOut: 1,
execute: (e, t2) => {
const r2 = d(e, t2.op);
if (f2(r2)) return r2;
const o = d(e, t2.op);
if (f2(o)) return o;
const c2 = F$1(o), s2 = F$1(r2);
if (s2 === 0)
return {
type: "DivisionByZero",
message: "Division by zero",
pc: e.pc,
opcode: t2.op
};
e.stack.push(c2 / s2);
}
},
[P$1.MOD]: {
stackIn: 2,
stackOut: 1,
execute: (e, t2) => {
const r2 = d(e, t2.op);
if (f2(r2)) return r2;
const o = d(e, t2.op);
if (f2(o)) return o;
const c2 = F$1(o), s2 = F$1(r2);
e.stack.push(c2 % s2);
}
},
[P$1.UNARY_MINUS]: {
stackIn: 1,
stackOut: 1,
execute: (e, t2) => {
const r2 = d(e, t2.op);
if (f2(r2)) return r2;
const o = F$1(r2);
e.stack.push(-o);
}
},
[P$1.UNARY_PLUS]: {
stackIn: 1,
stackOut: 1,
execute: (e, t2) => {
const r2 = d(e, t2.op);
if (f2(r2)) return r2;
const o = F$1(r2);
e.stack.push(o);
}
}
}, re = {
[P$1.PUSH]: {
stackIn: 0,
stackOut: 1,
execute: (e, t2) => {
e.stack.push(t2.arg);
}
},
[P$1.PUSH_UNDEFINED]: {
stackIn: 0,
stackOut: 1,
execute: (e) => {
e.stack.push(s());
}
},
[P$1.POP]: {
stackIn: 1,
stackOut: 0,
execute: (e) => {
e.stack.pop();
}
},
[P$1.DUP]: {
stackIn: 1,
stackOut: 2,
execute: (e, t2) => {
const r2 = e.stack.pop();
e.stack.push(r2), e.stack.push(r2);
}
},
[P$1.SWAP]: {
stackIn: 2,
stackOut: 2,
execute: (e, t2) => {
const r2 = e.stack.pop(), o = e.stack.pop();
e.stack.push(r2), e.stack.push(o);
}
},
[P$1.DUP2]: {
stackIn: 2,
stackOut: 4,
execute: (e, t2) => {
const r2 = e.stack.pop(), o = e.stack.pop();
e.stack.push(o), e.stack.push(r2), e.stack.push(o), e.stack.push(r2);
}
}
}, te = {
[P$1.PRINT]: {
stackIn: 1,
stackOut: 0,
execute: (e) => {
const t2 = e.stack.pop();
t2 !== void 0 && e.output.push(u$1(t2));
}
},
[P$1.CC]: {
stackIn: 1,
stackOut: 0,
controlsPC: true,
// CC pauses execution
execute: (e, t2) => {
const r2 = e.stack.pop();
e.ccPrompt = u$1(r2), e.status = "waiting_cc";
}
}
}, oe = {
[P$1.HALT]: {
stackIn: 0,
stackOut: 0,
controlsPC: true,
execute: (e) => {
e.status = "complete";
}
},
[P$1.JUMP]: {
stackIn: 0,
stackOut: 0,
controlsPC: true,
execute: (e, t2) => {
if (t2.arg === void 0)
return {
type: "RuntimeError",
message: "JUMP requires a target address",
pc: e.pc,
opcode: t2.op
};
const r2 = t2.arg;
if (r2 < 0)
return {
type: "RuntimeError",
message: `Invalid jump target: ${r2}`,
pc: e.pc,
opcode: t2.op
};
e.pc = r2;
}
},
[P$1.JUMP_IF_FALSE]: {
stackIn: 1,
stackOut: 0,
controlsPC: true,
execute: (e, t2) => {
const r2 = e.stack.pop();
if (t2.arg === void 0)
return {
type: "RuntimeError",
message: "JUMP_IF_FALSE requires a target address",
pc: e.pc,
opcode: t2.op
};
const o = t2.arg;
if (o < 0)
return {
type: "RuntimeError",
message: `Invalid jump target: ${o}`,
pc: e.pc,
opcode: t2.op
};
M$2(r2) ? e.pc++ : e.pc = o;
}
},
[P$1.JUMP_IF]: {
stackIn: 1,
stackOut: 0,
controlsPC: true,
execute: (e, t2) => {
const r2 = e.stack.pop();
if (t2.arg === void 0)
return {
type: "RuntimeError",
message: "JUMP_IF requires a target address",
pc: e.pc,
opcode: t2.op
};
const o = t2.arg;
if (o < 0)
return {
type: "RuntimeError",
message: `Invalid jump target: ${o}`,
pc: e.pc,
opcode: t2.op
};
M$2(r2) ? e.pc = o : e.pc++;
}
},
[P$1.JUMP_IF_TRUE]: {
stackIn: 1,
stackOut: 0,
controlsPC: true,
execute: (e, t2) => {
const r2 = e.stack.pop();
if (t2.arg === void 0)
return {
type: "RuntimeError",
message: "JUMP_IF_TRUE requires a target address",
pc: e.pc,
opcode: t2.op
};
const o = t2.arg;
if (o < 0)