dirac-lang 0.1.24 → 0.1.26

package/src/tags/assign.ts

@@ -1,37 +0,0 @@
-/**
- * <assign> tag - assign value to existing variable
- * Maps to mask_tag_assign in MASK
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { getVariable, setVariable, substituteVariables } from '../runtime/session.js';
-
-export function executeAssign(session: DiracSession, element: DiracElement): void {
-  const name = element.attributes.name;
-  const valueAttr = element.attributes.value;
-  
-  if (!name) {
-    throw new Error('<assign> requires name attribute');
-  }
-  
-  // Get value
-  let value: any;
-  if (valueAttr !== undefined) {
-    value = substituteVariables(session, valueAttr);
-  } else if (element.text) {
-    value = substituteVariables(session, element.text);
-  } else {
-    value = '';
-  }
-  
-  // Find existing variable and update it
-  for (let i = session.variables.length - 1; i >= 0; i--) {
-    if (session.variables[i].name === name) {
-      session.variables[i].value = value;
-      return;
-    }
-  }
-  
-  // Variable not found - create it (same as MASK behavior)
-  setVariable(session, name, value, false);
-}

package/src/tags/attr.ts

@@ -1,64 +0,0 @@
-/**
- * <attr> tag - extract attribute value from XML item
- * Usage: <attr name="description" from="$sub" />
- * or: <attr name="param-format" from="$sub" />
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { getVariable, substituteVariables } from '../runtime/session.js';
-
-export async function executeAttr(session: DiracSession, element: DiracElement): Promise<void> {
-  const nameAttr = element.attributes.name;
-  const fromAttr = element.attributes.from;
-  
-  if (!nameAttr) {
-    throw new Error('<attr> requires "name" attribute');
-  }
-  
-  if (!fromAttr) {
-    throw new Error('<attr> requires "from" attribute');
-  }
-  
-  // Get the XML item from variable
-  let item: any;
-  
-  if (fromAttr.startsWith('$')) {
-    const varName = fromAttr.substring(1);
-    item = getVariable(session, varName);
-  } else {
-    // Try substitution
-    const substituted = substituteVariables(session, fromAttr);
-    item = getVariable(session, substituted);
-  }
-  
-  if (!item) {
-    // No output if item not found
-    return;
-  }
-  
-  // Extract the attribute value
-  let value = '';
-  
-  if (typeof item === 'object') {
-    // If it's a structured XML item (from foreach)
-    if (item.attributes && typeof item.attributes === 'object') {
-      value = item.attributes[nameAttr] || '';
-    }
-    // If it's a direct object with the attribute
-    else if (item[nameAttr] !== undefined) {
-      value = String(item[nameAttr]);
-    }
-  } else if (typeof item === 'string') {
-    // If it's a string, try to parse as XML and extract
-    value = extractAttrFromXml(item, nameAttr);
-  }
-  
-  session.output.push(value);
-}
-
-function extractAttrFromXml(xml: string, attrName: string): string {
-  // Simple regex-based extraction for single-element XML
-  const regex = new RegExp(`${attrName}="([^"]*)"`, 'i');
-  const match = xml.match(regex);
-  return match ? match[1] : '';
-}

package/src/tags/available-subroutines.ts

@@ -1,70 +0,0 @@
-/**
- * <available-subroutines> tag - list available nested subroutines
- * Returns all subroutines within current call boundary with their metadata
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-
-export async function executeAvailableSubroutines(
-  session: DiracSession,
-  element: DiracElement
-): Promise<void> {
-  // Get all subroutines from current boundary to top of stack
-  const availableSubroutines = new Map<string, DiracElement>();
-  
-  // Get the name of the currently executing subroutine from the boundary
-  const currentSubroutineName = session.subBoundary < session.subroutines.length
-    ? session.subroutines[session.subBoundary].name
-    : null;
-  
-  // Read from top of stack (most recent) backwards to boundary
-  // This ensures we get the latest definition (handles extends override)
-  for (let i = session.subroutines.length - 1; i >= session.subBoundary; i--) {
-    const sub = session.subroutines[i];
-    
-    // Skip the currently executing subroutine itself
-    if (sub.name === currentSubroutineName) {
-      continue;
-    }
-    
-    // Only add if not already seen (first occurrence wins)
-    if (!availableSubroutines.has(sub.name)) {
-      availableSubroutines.set(sub.name, sub.element);
-    }
-  }
-  
-  // Generate structured output with container
-  session.output.push('<subroutines>');
-  
-  for (const [name, subElement] of availableSubroutines) {
-    const attrs: string[] = [`name="${escapeXml(name)}"`];
-    
-    // Add description if available
-    const description = subElement.attributes.description;
-    if (description) {
-      attrs.push(`description="${escapeXml(description)}"`);
-    }
-    
-    // Add all param-* attributes with their definitions
-    for (const [attrName, attrValue] of Object.entries(subElement.attributes)) {
-      if (attrName.startsWith('param-')) {
-        attrs.push(`${attrName}="${escapeXml(attrValue)}"`);
-      }
-    }
-    
-    // Build the output tag
-    const attrString = attrs.join(' ');
-    session.output.push(`  <subroutine ${attrString} />`);
-  }
-  
-  session.output.push('</subroutines>');
-}
-
-function escapeXml(text: string): string {
-  return text
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&apos;');
-}

package/src/tags/call.ts

@@ -1,259 +0,0 @@
-// Utility: Substitute both $var and ${var} in a string using session variables
-import { substituteAttribute } from '../runtime/session.js';
-
-/**
- * <call> tag - invoke subroutine
- * Maps to mask_call_integrate in MASK
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { 
-  getSubroutine, 
-  getParentSubroutine,
-  setBoundary, 
-  popToBoundary,
-  cleanToBoundary,
-  pushParameters,
-  popParameters,
-  substituteVariables,
-  setVariable,
-  getVariable,
-} from '../runtime/session.js';
-import { integrateChildren } from '../runtime/interpreter.js';
-
-export async function executeCall(session: DiracSession, element: DiracElement): Promise<void> {
-  // Support both <call name="FOO" /> and direct <FOO /> syntax
-  // For <call> tag, use name/subroutine attribute
-  // For direct syntax, use element.tag
-  let name: string;
-  
-  if (element.tag === 'call') {
-    // Explicit <call> tag - use name or subroutine attribute
-    name = element.attributes.name || element.attributes.subroutine || '';
-  } else {
-    // Direct tag syntax - use tag name itself, ignore name attribute
-    name = element.tag;
-  }
-  
-  if (!name) {
-    throw new Error('<call> requires name or subroutine attribute');
-  }
-  
-  const subroutine = getSubroutine(session, name);
-  if (!subroutine) {
-    throw new Error(`Subroutine '${name}' not found`);
-  }
-  
-  // Handle extension (parent subroutine) using recursive descent
-  const extendAttr = subroutine.attributes.extend;
-  const extendsAttr = subroutine.attributes.extends;
-  
-  if (extendAttr !== undefined || extendsAttr !== undefined) {
-    // This subroutine extends another - use recursive descent to build stack
-    const baseSubroutine = await registerExtendChain(session, subroutine, name);
-    // Execute the ultimate base subroutine with extend flag set
-    await executeCallInternal(session, baseSubroutine, element, true);
-  } else {
-    // No extension - normal subroutine call
-    await executeCallInternal(session, subroutine, element, false);
-  }
-}
-
-/**
- * Recursive descent for extend mechanism:
- * 1. Recursively descend to ultimate parent (no extend)
- * 2. Register base's nested subroutines
- * 3. As recursion unwinds, register each level's subroutines (latest on top of stack)
- * 4. Return the ultimate base to be executed
- */
-async function registerExtendChain(
-  session: DiracSession,
-  subroutine: DiracElement,
-  currentName: string
-): Promise<DiracElement> {
-  const { executeSubroutine } = await import('./subroutine.js');
-  
-  // Determine parent name
-  const extendsAttr = subroutine.attributes.extends;
-  let parentName: string;
-  
-  if (extendsAttr) {
-    // extends="parentName" - use explicit parent name
-    parentName = extendsAttr;
-  } else {
-    // extend (no value) - use same name, search for earlier definition
-    parentName = currentName;
-  }
-  
-  // Get parent, passing current subroutine if using same name
-  const parent = getParentSubroutine(session, parentName, parentName === currentName ? subroutine : undefined);
-  
-  if (!parent) {
-    // No parent found - shouldn't happen, but handle gracefully
-    return subroutine;
-  }
-  
-  // Check if parent also extends
-  const parentExtendAttr = parent.attributes.extend;
-  const parentExtendsAttr = parent.attributes.extends;
-  
-  let baseSubroutine: DiracElement;
-  
-  if (parentExtendAttr !== undefined || parentExtendsAttr !== undefined) {
-    // Parent extends - recursively process parent first
-    baseSubroutine = await registerExtendChain(session, parent, parentName);
-  } else {
-    // Parent doesn't extend - this is the ultimate base
-    // Register base's nested subroutines (bottom of stack)
-    for (const child of parent.children) {
-      if (child.tag === 'subroutine') {
-        executeSubroutine(session, child);
-      }
-    }
-    baseSubroutine = parent;
-  }
-  
-  // After parent chain is processed, register current level's nested subroutines
-  // These go on top and override parent's definitions
-  for (const child of subroutine.children) {
-    if (child.tag === 'subroutine') {
-      executeSubroutine(session, child);
-    }
-  }
-  
-  return baseSubroutine;
-}
-
-async function executeCallInternal(
-  session: DiracSession, 
-  subroutine: DiracElement,
-  callElement: DiracElement,
-  isExtendExecution: boolean = false
-): Promise<void> {
-  // Set boundary for local scope
-  const oldBoundary = setBoundary(session);
-  const wasReturn = session.isReturn;
-  session.isReturn = false;
-  
-  // Track current subroutine name for available-subroutines
-  const oldSubroutineName = session.currentSubroutineName;
-  session.currentSubroutineName = callElement.tag;
-  
-  // For extend execution, skip subroutine registration during body execution
-  const oldSkipFlag = session.skipSubroutineRegistration;
-  if (isExtendExecution) {
-    session.skipSubroutineRegistration = true;
-  }
-  
-  // Substitute variables in call element attributes before pushing to parameter stack
-  const substitutedElement: DiracElement = {
-    tag: callElement.tag,
-    attributes: {},
-    children: callElement.children
-  };
-  
-// Utility: Substitute both $var and ${var} in a string using session variables
-  for (const [key, value] of Object.entries(callElement.attributes)) {
-    substitutedElement.attributes[key] = substituteAttribute(session, value);
-  }
-  
-  // Push caller element onto parameter stack for <parameters select="*|@*|@attr"/> access
-  pushParameters(session, [substitutedElement]);
-  
-  try {
-    // 1. Set variables from <param-*> attributes if not already set in this boundary
-    for (const [attrName, attrValue] of Object.entries(subroutine.attributes)) {
-      if (attrName.startsWith('param-')) {
-        const paramName = attrName.substring(6);
-        // Check if variable exists in current boundary
-        const alreadySet = session.variables.slice(session.varBoundary).some(v => v.name === paramName);
-        if (!alreadySet) {
-          // Priority: call attribute > param-* default > empty string
-          let value = '';
-          if (callElement.attributes && callElement.attributes[paramName] !== undefined) {
-            value = substituteAttribute(session, callElement.attributes[paramName]);
-          } else {
-            // Always treat last colon-separated part as default value (if >3 fields)
-            const parts = attrValue.split(':');
-            if (parts.length > 3) {
-              value = parts[parts.length - 1];
-            }
-          }
-          setVariable(session, paramName, value, false);
-        }
-      }
-    }
-
-    // 2. Bind parameters from <parameters> if present
-    const paramElements = callElement.children.filter(c => c.tag === 'parameters');
-    if (paramElements.length > 0) {
-      await bindParameters(session, subroutine, paramElements[0]);
-    }
-
-    // 3. Execute subroutine body
-    await integrateChildren(session, subroutine);
-
-  } finally {
-    // Restore skip flag
-    session.skipSubroutineRegistration = oldSkipFlag;
-    
-    // Pop parameter stack
-    popParameters(session);
-
-    // Clean up scope (keep visible variables) BEFORE restoring boundary
-    cleanToBoundary(session);
-    session.varBoundary = oldBoundary;
-    session.isReturn = wasReturn;
-  }
-}
-
-async function bindParameters(
-  session: DiracSession,
-  subroutine: DiracElement, 
-  callParams: DiracElement
-): Promise<void> {
-  // Find <parameters> definition in subroutine
-  const paramDef = subroutine.children.find(c => c.tag === 'parameters');
-  if (!paramDef) {
-    return; // No parameters defined
-  }
-  
-  // Get variable definitions from parameter declaration
-  const paramVars = paramDef.children.filter(c => c.tag === 'variable');
-  const callVars = callParams.children.filter(c => c.tag === 'variable');
-  
-  // Bind each parameter
-  for (let i = 0; i < paramVars.length; i++) {
-    const paramVar = paramVars[i];
-    const callVar = callVars[i];
-    
-    const paramName = paramVar.attributes.name;
-    const passby = paramVar.attributes.passby || 'value';
-    
-    if (!paramName) continue;
-    
-    let value: any;
-    
-    if (callVar) {
-      // Get value from call site
-      const callValue = callVar.attributes.value;
-      if (callValue) {
-        if (passby === 'ref') {
-          // Pass by reference - store variable name
-          setVariable(session, paramName, getVariable(session, callValue), false);
-          session.variables[session.variables.length - 1].passby = 'ref';
-          session.variables[session.variables.length - 1].refName = callValue;
-        } else {
-          // Pass by value
-          value = substituteVariables(session, callValue);
-          setVariable(session, paramName, value, false);
-        }
-      }
-    } else {
-      // No value provided - use default if available
-      const defaultValue = paramVar.attributes.default || '';
-      value = substituteVariables(session, defaultValue);
-      setVariable(session, paramName, value, false);
-    }
-  }
-}

package/src/tags/catch.ts

@@ -1,24 +0,0 @@
-/**
- * <catch> tag - catches exceptions by name
- * Maps to mask_catch_integrate in MASK
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { lookupException, flushCurrentException } from '../runtime/session.js';
-
-export async function executeCatch(session: DiracSession, element: DiracElement): Promise<void> {
-  // Get exception name from 'name' attribute (default to "exception")
-  const exceptionName = element.attributes?.name || 'exception';
-  
-  // Look up matching exceptions between current position and last boundary
-  const caughtCount = lookupException(session, exceptionName);
-  
-  // If exceptions were caught, execute the catch block
-  if (caughtCount > 0) {
-    const { integrateChildren } = await import('../runtime/interpreter.js');
-    await integrateChildren(session, element);
-  }
-  
-  // Flush current exceptions after processing
-  flushCurrentException(session);
-}

package/src/tags/defvar.ts

@@ -1,115 +0,0 @@
-/**
- * <defvar> tag - define variable
- * Maps to mask_tag_defvar in MASK
- */
-
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { setVariable, substituteVariables } from '../runtime/session.js';
-import { integrate } from '../runtime/interpreter.js';
-import { executeParameters } from './parameters.js';
-
-export async function executeDefvar(session: DiracSession, element: DiracElement): Promise<void> {
-  const name = element.attributes.name;
-  const valueAttr = element.attributes.value;
-  const visibleAttr = element.attributes.visible || 'false';
-  const literal = 'literal' in element.attributes;
-  const trimAttr = element.attributes.trim;
-  const trim = trimAttr !== 'false'; // Trim by default unless explicitly set to false
-
-  if (!name) {
-    throw new Error('<defvar> requires name attribute');
-  }
-
-  // Determine visibility
-  const visible = visibleAttr === 'true' || visibleAttr === 'variable' || visibleAttr === 'both';
-
-  let value: any;
-  if (valueAttr !== undefined) {
-    value = substituteVariables(session, valueAttr);
-  } else if (literal) {
-    // Literal mode: serialize children to XML text without executing
-    if (element.children && element.children.length > 0) {
-      value = serializeToXml(element.children);
-    } else if (element.text) {
-      value = substituteVariables(session, element.text);
-    } else {
-      value = '';
-    }
-  } else if (element.children && element.children.length > 0) {
-    // If the first child is a <parameters> tag, call and assign its return value
-    if (element.children.length === 1 && element.children[0].tag && element.children[0].tag.toLowerCase() === 'parameters') {
-      value = await executeParameters(session, element.children[0]);
-    } else {
-      // Otherwise, execute all children and capture output
-      const prevOutput = session.output;
-      session.output = [];
-      for (const child of element.children) {
-        await integrate(session, child);
-      }
-      value = session.output.join('');
-      session.output = prevOutput;
-    }
-  } else if (element.text) {
-    value = substituteVariables(session, element.text);
-  } else {
-    value = '';
-  }
-
-  // Apply trim if requested
-  if (trim && typeof value === 'string') {
-    value = value.trim();
-  }
-
-  setVariable(session, name, value, visible);
-}
-
-function serializeToXml(children: DiracElement[]): string {
-  let xml = '';
-  
-  for (const child of children) {
-    if (!child.tag || child.tag === '') {
-      // Text node
-      xml += child.text || '';
-    } else {
-      // Element node
-      xml += `<${child.tag}`;
-      
-      // Add attributes
-      for (const [attrName, attrValue] of Object.entries(child.attributes)) {
-        xml += ` ${attrName}="${escapeXml(attrValue)}"`;
-      }
-      
-      // Self-closing or with children
-      if (child.children.length === 0 && !child.text) {
-        xml += ' />';
-      } else {
-        xml += '>';
-        
-        // Only add text content if there are no children
-        // (if there are children, text is stored in text node children)
-        if (child.text && child.children.length === 0) {
-          xml += escapeXml(child.text);
-        }
-        
-        // Add children (which may include text nodes)
-        if (child.children.length > 0) {
-          xml += serializeToXml(child.children);
-        }
-        
-        xml += `</${child.tag}>`;
-      }
-    }
-  }
-  
-  return xml;
-}
-
-function escapeXml(text: string): string {
-  return text
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&apos;');
-}

package/src/tags/environment.ts

@@ -1,21 +0,0 @@
-/**
- * <environment> tag - read environment variables
- * Usage: <environment name="VAR_NAME" />
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { emit } from '../runtime/session.js';
-
-export async function executeEnvironment(session: DiracSession, element: DiracElement): Promise<void> {
-  const name = element.attributes.name;
-
-  if (!name) {
-    throw new Error('<environment> requires name attribute');
-  }
-
-  // Get environment variable value
-  const value = process.env[name] || '';
-
-  // Emit the value to output
-  emit(session, value);
-}

package/src/tags/eval.ts

@@ -1,71 +0,0 @@
-/**
- * <eval> tag - evaluate JavaScript expression
- * Maps to mask_tag_eval in MASK (but for JS, not C)
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { setVariable, getVariable, substituteVariables } from '../runtime/session.js';
-
-// AsyncFunction constructor
-const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
-
-export async function executeEval(session: DiracSession, element: DiracElement): Promise<void> {
-  const name = element.attributes.name;
-  const exprAttr = element.attributes.expr;
-  
-  // Get expression as-is (do not replace ${var})
-  let expr: string;
-  if (exprAttr) {
-    expr = exprAttr;
-  } else if (element.text) {
-    expr = element.text;
-  } else {
-    throw new Error('<eval> requires expr attribute or text content');
-  }
-  
-  if (session.debug) {
-    console.error(`[EVAL] Code after substitution:\n${expr}\n`);
-  }
-  
-  try {
-    // Build context object with all variables
-    const context: Record<string, any> = {};
-    for (const v of session.variables) {
-      context[v.name] = v.value;
-    }
-    
-    // Add Node.js modules to context
-    const { default: fs } = await import('fs');
-    const { default: path } = await import('path');
-    const { fileURLToPath } = await import('url');
-    context.fs = fs;
-    context.path = path;
-    context.__dirname = process.cwd();  // ESM doesn't have __dirname, use cwd
-    
-    // Add helper to get current parameters from stack
-    context.getParams = () => {
-      const params = session.parameterStack[session.parameterStack.length - 1];
-      return params && params[0] ? params[0] : null;
-    };
-    
-    // Add session object for orchestration (reserved identifier in eval context)
-    context.session = session;
-    
-    let result: any;
-    // Execute as async function to support top-level await
-    const func = new AsyncFunction(...Object.keys(context), expr);
-    result = await func(...Object.values(context));
-    
-    if (session.debug) {
-      console.error(`[EVAL] Result: ${JSON.stringify(result)}`);
-    }
-    
-    // Store result if name provided
-    if (name) {
-      setVariable(session, name, result, false);
-    }
-    
-  } catch (error) {
-    throw new Error(`Eval error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}

package/src/tags/exception.ts

@@ -1,20 +0,0 @@
-/**
- * <exception> tag - outputs currently caught exceptions
- * Maps to mask_exception_integrate in MASK
- * Used inside <catch> blocks to access exception content
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { getCurrentExceptions } from '../runtime/session.js';
-
-export async function executeException(session: DiracSession, element: DiracElement): Promise<void> {
-  // Get the currently caught exceptions
-  const exceptions = getCurrentExceptions(session);
-  
-  // Process each exception DOM element's children
-  const { integrateChildren } = await import('../runtime/interpreter.js');
-  for (const exceptionDom of exceptions) {
-    // Execute the children of the exception (the exception content)
-    await integrateChildren(session, exceptionDom);
-  }
-}