@lango-project/lango-js 0.1.2 → 0.1.3

package/NOTICE

@@ -1,2 +1,7 @@
 Lango
 Copyright 2026 Savas Alparslan
+
+This product includes @xmldom/xmldom 0.9.12.
+Copyright 2019-present Christopher J. Brody and other contributors.
+Copyright 2012-2017 @jindw <jindw@xidea.org> and other contributors.
+Licensed under the MIT License; see src/vendor/xmldom.LICENSE.md.

package/README.md

@@ -77,7 +77,9 @@ test:lango -- input.lango` when Lango test blocks need host services.
 
 `buildFile()` writes a matched private runtime next to the generated module.
 Before calling exported Lango entry points, import that runtime and configure
-it. `configure()` accepts an object with optional `output`, `catalog`, and
+it. Runtimes generated into separate packages share dynamic Lango contexts
+within one JavaScript process, so an application host can provide a context to
+an exported function in a compiled dependency. `configure()` accepts an object with optional `output`, `catalog`, and
 `database_adapter` values; it returns `null`, resets dynamic context and
 transaction-failure state, and rejects an invalid configuration with
 `RuntimeConfigurationError`. `output` is a function (or `null`), `catalog` is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lango-project/lango-js",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"

package/src/cli.mjs

@@ -15,8 +15,13 @@ const displayError = (error) => error instanceof LangoError
 const buildOptions = (arguments_) => {
     if (arguments_[0] !== "--out" || !arguments_[1]) return null;
     const profile = {};
-    for (let index = 2; index < arguments_.length; index += 2) {
+    for (let index = 2; index < arguments_.length;) {
         const option = arguments_[index];
+        if (option === "--executable") {
+            profile.executable = true;
+            index += 1;
+            continue;
+        }
         const value = arguments_[index + 1];
         if (!value) return null;
         if (option === "--decimal-division-scale")
@@ -24,6 +29,7 @@ const buildOptions = (arguments_) => {
         else if (option === "--decimal-division-rounding")
             profile.decimal_division_rounding = Decimal.Rounding[value] ?? value;
         else return null;
+        index += 2;
     }
     return { outputPath: arguments_[1], profile };
 };
@@ -167,6 +173,6 @@ if (command === "init" && inputPath && rest.length === 0) {
         process.exitCode = error instanceof LangoError ? 1 : 2;
     }
 } else {
-    console.error("Usage: node src/cli.mjs init <directory>\n       node src/cli.mjs build <input.lango> --out <output.mjs> [--decimal-division-scale <n>] [--decimal-division-rounding <EnumName>]\n       node src/cli.mjs run <input.lango> [--database <sqlite-file>] [--catalog <catalog.json>] [-- args...]\n       node src/cli.mjs test <input.lango> [--database <sqlite-file>] [--catalog <catalog.json>]\n       node src/cli.mjs format <input.lango>");
+    console.error("Usage: node src/cli.mjs init <directory>\n       node src/cli.mjs build <input.lango> --out <output.mjs> [--executable] [--decimal-division-scale <n>] [--decimal-division-rounding <EnumName>]\n       node src/cli.mjs run <input.lango> [--database <sqlite-file>] [--catalog <catalog.json>] [-- args...]\n       node src/cli.mjs test <input.lango> [--database <sqlite-file>] [--catalog <catalog.json>]\n       node src/cli.mjs format <input.lango>");
     process.exitCode = 2;
 }

package/src/compiler.mjs

@@ -32,7 +32,8 @@ export function formatDiagnostics(error) {
 
 export async function buildFile(inputPath, outputPath, seen = new Set(), includeTests = false, profile = {}) {
   const decimalProfile = validateDecimalProfile(profile);
-  if (seen.size === 0)
+  const isEntryPoint = seen.size === 0;
+  if (isEntryPoint)
     await validateModuleInitializerCycles(inputPath, outputPath);
   if (seen.has(inputPath)) return;
   seen.add(inputPath);
@@ -86,10 +87,19 @@ export async function buildFile(inputPath, outputPath, seen = new Set(), include
   }
 
   const compiled = compile(source, inputPath, imports, includeTests, decimalProfile);
-  const output = compiled.javascript.replace(
+  let output = compiled.javascript.replace(
     "//# sourceMappingURL=main.mjs.map",
     `//# sourceMappingURL=${path.basename(outputPath)}.map`,
   );
+  if (isEntryPoint && profile.executable) {
+    const main = compiled.program.functions.find((item) => item.name === "main" && item.exported);
+    if (!main)
+      throw new LangoError("LNG1265", 1, "an executable build requires export main(args)", inputPath);
+    output = output.replace(
+      `//# sourceMappingURL=${path.basename(outputPath)}.map`,
+      `const { configure } = await import("./.lango/runtime.mjs");\nconfigure({ output: (value) => console.log(value) });\nawait main(process.argv.slice(2));\n//# sourceMappingURL=${path.basename(outputPath)}.map`,
+    );
+  }
   const directory = path.dirname(outputPath);
 
   await mkdir(path.join(directory, ".lango"), { recursive: true });
@@ -111,6 +121,19 @@ export async function buildFile(inputPath, outputPath, seen = new Set(), include
     await readFile(new URL("./vendor/bignumber.mjs", import.meta.url), "utf8"),
     "utf8",
   );
+  const xmlVendor = new URL("./vendor/xmldom/", import.meta.url);
+  await mkdir(path.join(directory, ".lango/xmldom"), { recursive: true });
+  for (const name of ["conventions.js", "dom-parser.js", "dom.js", "entities.js", "errors.js", "grammar.js", "index.js", "sax.js"])
+    await writeFile(
+      path.join(directory, ".lango/xmldom", name),
+      await readFile(new URL(name, xmlVendor), "utf8"),
+      "utf8",
+    );
+  await writeFile(
+    path.join(directory, ".lango/xmldom.LICENSE.md"),
+    await readFile(new URL("./vendor/xmldom.LICENSE.md", import.meta.url), "utf8"),
+    "utf8",
+  );
 }
 
 export function compile(source, sourceName = "<source>", imports = [], includeTests = false, profile = {}) {
@@ -243,7 +266,6 @@ class Parser {
     const tests = [];
     const jsImports = [];
     let declarationSeen = false;
-    let exportedClassSeen = false;
     this.blank();
     while (this.i < this.lines.length) {
       const line = this.line();
@@ -293,9 +315,6 @@ class Parser {
         );
       if (classHeader) {
         declarationSeen = true;
-        if (classHeader[1] && exportedClassSeen)
-          this.fail(line, "LNG1114", "a file may export one class");
-        exportedClassSeen ||= Boolean(classHeader[1]);
         const classNode = {
           name: classHeader[2],
           ancestor: classHeader[3] ?? null,
@@ -777,7 +796,7 @@ class Parser {
           value: { type: "new", name: constructor, arguments: [closure], line: line.number },
         });
       }
-      else if (/^(.+)\.([A-Za-z_]\w*)\((.*), \(([^)]*)\)$/.test(text)) {
+      else if (!text.includes(" = ") && /^(.+)\.([A-Za-z_]\w*)\((.*), \(([^)]*)\)$/.test(text)) {
         const [, receiver, name, argumentsText, parameters] =
           /^(.+)\.([A-Za-z_]\w*)\((.*), \(([^)]*)\)$/.exec(text);
         const closure = {
@@ -803,7 +822,34 @@ class Parser {
           },
         });
       }
-      else if (/^(.+)\.([A-Za-z_]\w*)\(\(([^)]*)\)$/.test(text)) {
+      else if (/^(\$?[A-Za-z_]\w*) = (.+)\.([A-Za-z_]\w*)\((?:(.*), )?\(([^)]*)\)$/.test(text)) {
+        const [, name, receiver, method, argumentsText, parameters] =
+          /^(\$?[A-Za-z_]\w*) = (.+)\.([A-Za-z_]\w*)\((?:(.*), )?\(([^)]*)\)$/.exec(text);
+        const closure = {
+          type: "closure",
+          parameters: this.parameters(parameters, line),
+          captures: this.captures(),
+          line: line.number,
+          body: this.block(indent + 4),
+        };
+        this.blank();
+        if (this.peek() !== `${" ".repeat(indent)})`)
+          this.fail(line, "LNG1266", "assigned method callback requires a closing parenthesis");
+        this.i += 1;
+        body.push({
+          type: "assign",
+          name,
+          value: {
+            type: "methodCall",
+            receiver,
+            optional: false,
+            name: method,
+            arguments: [...(argumentsText ? splitTopLevel(argumentsText).map((item) => expr(item, line, this)) : []), closure],
+            line: line.number,
+          },
+        });
+      }
+      else if (!text.includes(" = ") && /^(.+)\.([A-Za-z_]\w*)\(\(([^)]*)\)$/.test(text)) {
         const [, first, name, parameters] = /^(.+)\.([A-Za-z_]\w*)\(\(([^)]*)\)$/.exec(text);
         const steps = [];
         let step = { name, parameters: this.parameters(parameters, line), captures: this.captures(), line: line.number, body: this.block(indent + 4) };
@@ -959,7 +1005,7 @@ class Parser {
           operator: suffix === "++" ? "+" : "-",
         });
       } else {
-        const assignment = /^(\$[A-Za-z_]\w*|@{0,2}\$?[A-Za-z_]\w*|[A-Za-z_]\w*\.\$?[A-Za-z_]\w*) = (.+)$/.exec(text);
+        const assignment = /^(\$[A-Za-z_]\w*|@{0,2}\$?[A-Za-z_]\w*|[A-Za-z_]\w*(?:\.\$?[A-Za-z_]\w*)+) = (.+)$/.exec(text);
         if (!assignment)
           this.fail(line, "LNG1106", `unsupported Faz 2 statement: ${text}`);
         body.push({
@@ -1288,10 +1334,18 @@ function expr(source, line, parser) {
       }),
     };
   }
+  if (text.startsWith("not "))
+    return {
+      type: "unary",
+      operator: "not",
+      value: expr(text.slice(4), line, parser),
+    };
   for (const operators of [
     ["??"],
-    ["or", "||"],
-    ["and", "&&"],
+    ["or"],
+    ["and"],
+    ["||"],
+    ["&&"],
     ["==", "!="],
     [">=", "<=", ">", "<", "not in", "in"],
     ["+", "-"],
@@ -1314,12 +1368,6 @@ function expr(source, line, parser) {
       left: expr(text.slice(0, exponent.index), line, parser),
       right: expr(text.slice(exponent.index + exponent.operator.length + 2), line, parser),
     };
-  if (text.startsWith("not "))
-    return {
-      type: "unary",
-      operator: "not",
-      value: expr(text.slice(4), line, parser),
-    };
   if (/^-[^\s]/.test(text))
     return {
       type: "unary",
@@ -1455,6 +1503,17 @@ function expr(source, line, parser) {
         : [],
       line: line.number,
     };
+  const indexedCall = /^(.+)\[(.+)\]\((.*)\)$/.exec(text);
+  if (indexedCall)
+    return {
+      type: "indexedCall",
+      receiver: expr(indexedCall[1], line, parser),
+      index: expr(indexedCall[2], line, parser),
+      arguments: indexedCall[3]
+        ? splitTopLevel(indexedCall[3]).map((item) => expr(item, line, parser))
+        : [],
+      line: line.number,
+    };
   const methodCall =
     /^([A-Za-z_]\w*(?:(?:\.|\?\.)[A-Za-z_]\w*)*?)(\?\.|\.)([A-Za-z_]\w*)\((.*)\)$/.exec(
       text,
@@ -1760,6 +1819,8 @@ function validate(program, imports = []) {
     ["is_array", 1],
     ["range", [1, 2, 3]],
     ["to_js_number", 1],
+    ["import_module", 1],
+    ["xml2obj", 1],
     ["start_trans", 0], ["commit_trans", 0], ["rollback_trans", 0], ["trans_state", 0],
   ]);
   const hostFunctions = new Set(["fetch"]);
@@ -2508,6 +2569,15 @@ function validate(program, imports = []) {
     return names;
   };
 
+  const contextBindings = (body, names = new Set()) => {
+    for (const node of body) {
+      if (node.type === "contextDeclare" || node.type === "contextSet") names.add(node.name);
+      if (node.type !== "closureAssign")
+        nestedBodies(node).forEach((child) => contextBindings(child, names));
+    }
+    return names;
+  };
+
   const globalDeclarations = (body, names = new Set()) => {
     for (const node of body) {
       if (node.type === "globalDeclare") names.add(node.name);
@@ -2563,9 +2633,14 @@ function validate(program, imports = []) {
     outerBindings,
     classScope = null,
     inheritedExpiredCatchBindings = new Set(),
+    outerContextBindings = new Set(),
   ) => {
     const available = new Set(outerBindings);
     const expiredCatchBindings = new Set(inheritedExpiredCatchBindings);
+    const availableContexts = new Set([
+      ...outerContextBindings,
+      ...contextBindings(body),
+    ]);
     for (const node of body) {
       const references = new Set();
       [node.value, node.condition, node.collection, node.arguments, node.tests].forEach((value) => {
@@ -2585,6 +2660,7 @@ function validate(program, imports = []) {
           new Set(available),
           classScope,
           expiredCatchBindings,
+          availableContexts,
         );
         const right = node.elseBody
           ? validateClosures(
@@ -2592,6 +2668,7 @@ function validate(program, imports = []) {
               new Set(available),
               classScope,
               expiredCatchBindings,
+              availableContexts,
             )
           : available;
         const exits = [];
@@ -2610,6 +2687,7 @@ function validate(program, imports = []) {
             new Set(available),
             classScope,
             expiredCatchBindings,
+            availableContexts,
             ),
           );
         if (!node.elseBody || reachesEnd(node.elseBody))
@@ -2620,6 +2698,7 @@ function validate(program, imports = []) {
                 new Set(available),
                 classScope,
                 expiredCatchBindings,
+                availableContexts,
                 )
               : new Set(available),
           );
@@ -2635,6 +2714,7 @@ function validate(program, imports = []) {
           new Set(available),
           classScope,
           expiredCatchBindings,
+          availableContexts,
         );
         if (reachesEnd(node.tryBody)) exits.push(tryExit);
         if (node.catchBody) {
@@ -2645,6 +2725,7 @@ function validate(program, imports = []) {
               new Set(
                 [...expiredCatchBindings].filter((name) => name !== node.catchName),
               ),
+              availableContexts,
           );
           if (reachesEnd(node.catchBody)) exits.push(catchExit);
         }
@@ -2658,6 +2739,7 @@ function validate(program, imports = []) {
               certain,
               classScope,
               new Set([...expiredCatchBindings, node.catchName].filter(Boolean)),
+              availableContexts,
             )
           : certain;
         if (!node.finallyBody || reachesEnd(node.finallyBody))
@@ -2671,6 +2753,7 @@ function validate(program, imports = []) {
           new Set([...available, node.item]),
           classScope,
           expiredCatchBindings,
+          availableContexts,
         );
         continue;
       }
@@ -2680,6 +2763,7 @@ function validate(program, imports = []) {
           new Set([...available, node.key, node.value]),
           classScope,
           expiredCatchBindings,
+          availableContexts,
         );
         continue;
       }
@@ -2695,6 +2779,7 @@ function validate(program, imports = []) {
             new Set(available),
             classScope,
             expiredCatchBindings,
+            availableContexts,
           );
         continue;
       }
@@ -2726,9 +2811,14 @@ function validate(program, imports = []) {
           (name) =>
             !localBindings.has(name) &&
             !contextNames.has(name) &&
-            !globalNames.has(name),
+            !globalNames.has(name) &&
+            !standardFunctions.has(name) &&
+            !hostFunctions.has(name),
         );
         const captures = new Set(closure.captures);
+        const contextCaptures = new Set(
+          closure.captures.filter((name) => availableContexts.has(name)),
+        );
         for (const name of needed)
           if (!captures.has(name))
             throw new LangoError(
@@ -2737,7 +2827,7 @@ function validate(program, imports = []) {
               `MissingCapture: ${name}; add capture ${name}`,
             );
         for (const name of captures) {
-          if (!needed.includes(name))
+          if (!needed.includes(name) && !contextCaptures.has(name))
             throw new LangoError(
               "LNG1211",
               closure.line,
@@ -2745,7 +2835,7 @@ function validate(program, imports = []) {
             );
           const protectedMember = Boolean(classScope && name.startsWith("_"));
           const propertyCapture = name.startsWith("@") || protectedMember;
-          if (!propertyCapture && !available.has(name))
+          if (!propertyCapture && !contextCaptures.has(name) && !available.has(name))
             throw new LangoError(
               "LNG1212",
               closure.line,
@@ -2778,6 +2868,7 @@ function validate(program, imports = []) {
           new Set([...available, ...localBindings]),
           classScope,
           expiredCatchBindings,
+          new Set([...availableContexts, ...contextCaptures]),
         );
       if (node.type === "closureAssign" || node.type === "assign") available.add(node.name);
         continue;
@@ -3327,6 +3418,7 @@ function emit(program, moduleImports = [], includeTests = false) {
     flags.print && "println as __println",
     flags.translate && "translate as __translate",
     flags.xml && "xmlEscape as __xmlEscape",
+    flags.xmlObject && "xml2obj as __xml2obj",
     flags.context && "contextGet as __contextGet",
     flags.context && "contextSet as __contextSet",
     flags.context && "contextRestore as __contextRestore",
@@ -3356,6 +3448,7 @@ function emit(program, moduleImports = [], includeTests = false) {
     flags.finite && "finite as __finite",
     flags.number && "requireNumber as __requireNumber",
     flags.call && "call as __call",
+    flags.callMethod && "callMethod as __callMethod",
     flags.boundary && "boundary as __boundary",
     flags.database && "startTrans as __startTrans",
     flags.database && "commitTrans as __commitTrans",
@@ -3662,7 +3755,7 @@ function emitStatement(node, depth, declared, flags) {
   if (node.type === "assign") {
     const decimalBinding = node.name.startsWith("$") || /^@{1,2}\$/.test(node.name);
     const property = node.name.slice(node.name.startsWith("@@") ? 2 : 1);
-    const target = /^[A-Za-z_]\w*\.\$?[A-Za-z_]\w*$/.test(node.name)
+    const target = /^[A-Za-z_]\w*(?:\.\$?[A-Za-z_]\w*)+$/.test(node.name)
       ? node.name
       : node.name.startsWith("@@")
       ? `${flags.className}.${property}`
@@ -3674,7 +3767,7 @@ function emitStatement(node, depth, declared, flags) {
           ? `this.${node.name}`
           : node.name;
     const prefix =
-      /^[A-Za-z_]\w*\.\$?[A-Za-z_]\w*$/.test(node.name)
+      /^[A-Za-z_]\w*(?:\.\$?[A-Za-z_]\w*)+$/.test(node.name)
         ? ""
         : node.name.startsWith("@") ||
       (flags.className && node.name.startsWith("_")) ||
@@ -3808,7 +3901,11 @@ function emitClosure(node, depth, flags) {
   const priorContextNames = flags.contextNames;
   const priorGlobalNames = flags.globalNames;
   const priorArrayBindings = flags.arrayBindings;
-  const contextNames = collectContextNames(node.body);
+  const contextCaptures = node.captures.filter((name) => priorContextNames?.has(name));
+  const contextNames = new Set([
+    ...collectContextNames(node.body),
+    ...contextCaptures,
+  ]);
   flags.contextNames = contextNames;
   flags.globalNames = collectGlobalNames(node.body);
   flags.arrayBindings = new Set();
@@ -3836,7 +3933,16 @@ function emitClosure(node, depth, flags) {
   if (!contextNames.size)
     return wrap(`(${parameters}) => {\n${boundary}${body}${pad}    return null;\n${pad}}`);
   flags.context = true;
-  return wrap(`(${parameters}) => {\n${pad}    const __contextScope = [];\n${pad}    try {\n${boundary}${body}${pad}        return null;\n${pad}    } finally {\n${pad}        __contextRestore(__contextScope);\n${pad}    }\n${pad}}`);
+  const capturedParameters = contextCaptures.map((_, index) => `__capturedContext${index}`);
+  const capturedValues = contextCaptures.map((name) => `__contextGet(${JSON.stringify(name)})`);
+  const capturedSetup = contextCaptures
+    .map((name, index) => `${pad}        __contextScope.push(__contextSet(${JSON.stringify(name)}, __capturedContext${index}));\n`)
+    .join("");
+  const callback = `(${parameters}) => {\n${pad}    const __contextScope = [];\n${pad}    try {\n${capturedSetup}${boundary}${body}${pad}        return null;\n${pad}    } finally {\n${pad}        __contextRestore(__contextScope);\n${pad}    }\n${pad}}`;
+  const wrappedCallback = contextCaptures.length
+    ? `((${capturedParameters.join(", ")}) => ${callback})(${capturedValues.join(", ")})`
+    : callback;
+  return wrap(wrappedCallback);
 }
 function emitArityGuard(parameters, actual, name, depth, flags) {
   const positions = parameters
@@ -3860,6 +3966,12 @@ function emitBoundaryChecks(parameters, depth, flags) {
     })
     .join("");
 }
+function emitReceiverName(name, flags) {
+  if (!flags.contextNames?.has(name)) return name;
+  flags.context = true;
+  return `__contextGet(${JSON.stringify(name)})`;
+}
+
 function emitExpr(node, flags) {
   const decimalRaw = (value) =>
     value?.type === "raw" &&
@@ -3935,7 +4047,7 @@ function emitExpr(node, flags) {
     return `super.${node.name}(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
   if (node.type === "index")
     return normalize(
-      `${typeof node.receiver === "string" ? node.receiver : emitExpr(node.receiver, flags)}${node.optional ? "?." : ""}[${emitExpr(node.index, flags)}]`,
+      `${typeof node.receiver === "string" ? emitReceiverName(node.receiver, flags) : emitExpr(node.receiver, flags)}${node.optional ? "?." : ""}[${emitExpr(node.index, flags)}]`,
     );
   if (node.type === "property")
     return normalize(
@@ -3946,7 +4058,7 @@ function emitExpr(node, flags) {
     const sourceReceiver = namespace
       ? node.receiver.replaceAll("/", ".")
       : typeof node.receiver === "string"
-        ? node.receiver
+        ? emitReceiverName(node.receiver, flags)
         : emitExpr(node.receiver, flags);
     const type =
       sourceReceiver === flags.className ||
@@ -4089,6 +4201,14 @@ function emitExpr(node, flags) {
       flags.toJsNumber = true;
       return `__toJsNumber(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
     }
+  if (node.type === "call")
+    if (node.name === "import_module")
+      return `import(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+  if (node.type === "call")
+    if (node.name === "xml2obj") {
+      flags.xmlObject = true;
+      return `__xml2obj(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+    }
   if (node.type === "call")
     if (node.name === "from_json" || node.name === "to_json") {
       flags.json = true;
@@ -4128,6 +4248,10 @@ function emitExpr(node, flags) {
       return `__call(${node.name}, ${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
     } else
       return `${node.name}(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+  if (node.type === "indexedCall") {
+    flags.callMethod = true;
+    return `__callMethod(${emitExpr(node.receiver, flags)}, ${emitExpr(node.index, flags)}, ${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+  }
   if (node.type === "string") return emitString(node.literal, flags);
   if (node.type === "xml") {
     flags.xml = true;

package/src/runtime.mjs

@@ -22,6 +22,9 @@ export function runtimeSource(profile = {}) {
     if (!(rounding in ROUNDING_MODES))
         throw new Error(`unknown decimal_division_rounding ${rounding}`);
     return `import BigNumber from "./bignumber.mjs";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const { DOMParser } = require("./xmldom/index.js");
 
 const Decimal = BigNumber.clone({
     DECIMAL_PLACES: ${scale},
@@ -56,7 +59,9 @@ let output = null;
 let database = null;
 let failedTransaction = false;
 export const DB = Object.freeze({ Active: "active", RollbackOnly: "rollback_only", Failed: "failed" });
-const contexts = new Map();
+const contextStore = Symbol.for("lango.contexts");
+const contexts = globalThis[contextStore] ?? new Map();
+globalThis[contextStore] = contexts;
 
 export class RuntimeConfigurationError extends Error {
     constructor(message) {
@@ -188,6 +193,73 @@ export function xmlEscape(value) {
         .replaceAll("'", "'");
 }
 
+export function xml2obj(xml) {
+    if (typeof xml !== "string") throw new Error("XmlParseError: XML input must be a string");
+    const errors = [];
+    let document;
+    try {
+        document = new DOMParser({
+            onError(level, message) {
+                if (level !== "warning") errors.push(message);
+            },
+        }).parseFromString(xml, "application/xml");
+    } catch (error) {
+        throw new Error(\`XmlParseError: \${error.message}\`);
+    }
+    if (errors.length) throw new Error(\`XmlParseError: \${errors[0]}\`);
+    if (!document.documentElement)
+        throw new Error("XmlParseError: XML must contain one root tag");
+    return new Tag(document.documentElement);
+}
+
+export class Tag {
+    constructor(element) {
+        this.element = element;
+        return new Proxy(this, {
+            get: (target, name, receiver) => target.#property(name, receiver),
+        });
+    }
+
+    tag() {
+        return this.element.tagName;
+    }
+
+    innerText() {
+        let text = "";
+        for (const child of this.element.childNodes) {
+            if (child.nodeType === 3 || child.nodeType === 4) text += child.data;
+        }
+        return text;
+    }
+
+    children() {
+        return Array.from(this.element.childNodes)
+            .filter((child) => child.nodeType === 1)
+            .map((child) => new Tag(child));
+    }
+
+    attribute(name) {
+        const value = this.element.getAttribute(String(name));
+        return value === null ? null : value;
+    }
+
+    attributes() {
+        const values = {};
+        for (const attribute of Array.from(this.element.attributes)) values[attribute.name] = attribute.value;
+        return values;
+    }
+
+    #property(name, receiver) {
+        if (typeof name !== "string") return Reflect.get(this, name, receiver);
+        if (name === "tag" || name === "innerText" || name === "children" || name === "attribute" || name === "attributes" || name === "element")
+            return Reflect.get(this, name, receiver);
+        if (this.element.hasAttribute(name)) return this.element.getAttribute(name);
+        const matching = Array.from(this.element.childNodes)
+            .filter((child) => child.nodeType === 1 && child.tagName === name);
+        return matching.length === 1 ? new Tag(matching[0]) : undefined;
+    }
+}
+
 export function println(value) {
     if (output === null) {
         throw new Error("Lango runtime output is not configured");
@@ -197,6 +269,18 @@ export function println(value) {
     return null;
 }
 
+const defaultLog = Object.freeze({
+    debug(value) { return writeLog(process.stdout, "DEBUG", value); },
+    info(value) { return writeLog(process.stdout, "INFO", value); },
+    warn(value) { return writeLog(process.stderr, "WARN", value); },
+    err(value) { return writeLog(process.stderr, "ERROR", value); },
+});
+
+function writeLog(stream, level, value) {
+    stream.write(\`[\${level}] \${String(value)}\\n\`);
+    return null;
+}
+
 export function fromJson(text) {
     try {
         return decimalJson(JSON.parse(text));
@@ -448,6 +532,12 @@ export function call(value, ...arguments_) {
     return normalize(value(...arguments_));
 }
 
+export function callMethod(receiver, name, ...arguments_) {
+    const value = receiver?.[name];
+    if (typeof value !== "function") throw new Error("NotCallable");
+    return normalize(value.call(receiver, ...arguments_));
+}
+
 export function boundary(value) {
     return finite(normalize(value));
 }
@@ -469,6 +559,7 @@ export function withArity(callback, requiredPositions, name) {
 
 export function contextGet(name) {
     const stack = contexts.get(name);
+    if ((!stack || stack.length === 0) && name === "log") return defaultLog;
     if (!stack || stack.length === 0) {
         throw new Error(\`Lango context is unavailable: \${name}\`);
     }

package/src/template/package.json

@@ -9,6 +9,10 @@
     "test": "lango test test/main.lango",
     "format": "lango format src/main.lango"
   },
+  "lango": {
+    "source": "src/main.lango",
+    "output": "dist/main.mjs"
+  },
   "devDependencies": {
     "@lango-project/lango-js": "{{LANGO_VERSION}}"
   },