dirac-lang 0.1.9 → 0.1.11

package/LLM-VALIDATION.md

@@ -0,0 +1,128 @@
+# LLM Tag Validation
+
+The `<llm>` tag now supports automatic validation and correction of generated Dirac code when using `execute="true"`.
+
+## Attributes
+
+### Execution Mode
+- `execute="true"` - Parse and execute the LLM response as Dirac code (existing feature)
+
+### Tag Validation (New)
+- `validate="true"` - Enable tag validation for LLM-generated code
+- `autocorrect="true"` - Automatically correct similar tag names using semantic matching
+- `max-retries="N"` - Maximum number of retry attempts if validation fails (default: 0)
+
+## How It Works
+
+When `validate="true"` is enabled:
+
+1. **Parse**: LLM response is parsed as Dirac XML
+2. **Validate**: Each tag is checked against available subroutines
+   - Verifies tag names exist
+   - Checks required parameters are present
+   - Warns about unknown attributes
+3. **Semantic Matching**: If a tag doesn't exist, finds the closest match using embeddings
+4. **Auto-correct**: If `autocorrect="true"` and similarity >= 0.75, replaces tag with best match
+5. **Retry**: If validation fails and `max-retries > 0`, sends error feedback to LLM and retries
+6. **Execute**: Once validation passes, executes the (possibly corrected) code
+
+## Examples
+
+### Basic Validation
+
+```xml
+<dirac>
+  <subroutine name="greet" param-name="string:required">
+    <output>Hello, <variable name="name" />!</output>
+  </subroutine>
+  
+  <llm execute="true" validate="true">
+    Greet Alice
+  </llm>
+</dirac>
+```
+
+If the LLM generates `<greeting name="Alice" />` instead of `<greet name="Alice" />`, validation will fail with an error.
+
+### With Auto-correction
+
+```xml
+<dirac>
+  <subroutine name="greet" param-name="string:required">
+    <output>Hello, <variable name="name" />!</output>
+  </subroutine>
+  
+  <llm execute="true" validate="true" autocorrect="true">
+    Greet Alice
+  </llm>
+</dirac>
+```
+
+If the LLM generates `<greeting name="Alice" />`, and `greeting` is semantically similar to `greet` (similarity >= 0.75), it will be auto-corrected to `<greet name="Alice" />`.
+
+### With Retry
+
+```xml
+<dirac>
+  <subroutine name="calculate" param-expression="string:required">
+    <eval><variable name="expression" /></eval>
+  </subroutine>
+  
+  <llm execute="true" validate="true" max-retries="3">
+    Calculate 2 + 2
+  </llm>
+</dirac>
+```
+
+If validation fails:
+1. LLM receives feedback: "Your previous response had the following errors: <compute>: Missing required parameter: expression"
+2. LLM generates a new response
+3. Process repeats up to 3 times until validation passes
+
+### Combined Approach
+
+```xml
+<llm execute="true" validate="true" autocorrect="true" max-retries="2">
+  Generate a greeting for Bob
+</llm>
+```
+
+This combines auto-correction with retry:
+- First tries to auto-correct similar tag names
+- If that doesn't fix all errors, retries with LLM feedback
+- Maximum 2 retry attempts
+
+## Error Messages
+
+Validation can detect:
+
+- **Missing tags**: `Tag <xyz> does not exist and no similar tag was found.`
+- **Similar tags**: `Tag <greeting> does not exist. Did you mean <greet>? (similarity: 0.85)`
+- **Missing parameters**: `<greet>: Missing required parameter: name`
+- **Unknown attributes**: `<greet>: Unknown attribute: person`
+
+## Requirements
+
+- Requires embedding server for semantic matching (Ollama with embeddinggemma model)
+- Configure in `config.yml`:
+  ```yaml
+  embeddingServer:
+    host: localhost
+    port: 11435
+  ```
+
+## Performance Notes
+
+- Validation adds latency due to embedding calls
+- Each tag requires an embedding API call
+- Consider using `validate="true"` only when necessary
+- Auto-correction is faster than retries
+
+## Best Practices
+
+1. **Start without validation** for simple prompts
+2. **Add validation** when LLM frequently generates incorrect tags
+3. **Use autocorrect** for typos and similar names
+4. **Use retry** for more complex validation errors
+5. **Limit retries** to 2-3 to avoid excessive API calls
+6. **Monitor debug output** with `DIRAC_DEBUG=1` to see validation details

package/TESTING.md

@@ -0,0 +1,162 @@
+# Dirac Testing System
+
+A simple, lightweight testing framework for Dirac language files.
+
+## Running Tests
+
+```bash
+npm test
+```
+
+This will:
+1. Build the project
+2. Run all `*.test.di` files in the `tests/` directory
+3. Report results
+
+## Writing Tests
+
+Tests are standard Dirac `.di` files with special comments that define expectations.
+
+### Test File Format
+
+```xml
+<!-- TEST: test_name -->
+<!-- EXPECT: expected output -->
+<dirac>
+  <!-- your test code here -->
+</dirac>
+```
+
+### Test Metadata Comments
+
+- `<!-- TEST: name -->` - Name of the test (optional, defaults to filename)
+- `<!-- EXPECT: output -->` - Expected output (optional)
+- `<!-- EXPECT_ERROR: error message -->` - Expected error message (optional)
+
+### Example Tests
+
+#### Basic Output Test
+
+```xml
+<!-- TEST: hello_world -->
+<!-- EXPECT: Hello, World! -->
+<dirac>
+  <output>Hello, World!</output>
+</dirac>
+```
+
+#### Variable Test
+
+```xml
+<!-- TEST: variables -->
+<!-- EXPECT: Value is: test123 -->
+<dirac>
+  <defvar name="myvar" value="test123" />
+  <output>Value is: <variable name="myvar" /></output>
+</dirac>
+```
+
+#### Error Test
+
+```xml
+<!-- TEST: missing_variable -->
+<!-- EXPECT_ERROR: Variable 'missing' not found -->
+<dirac>
+  <variable name="missing" />
+</dirac>
+```
+
+#### No Expectation (Just Run)
+
+```xml
+<!-- TEST: runs_without_error -->
+<dirac>
+  <defvar name="x" value="10" />
+  <!-- Test passes if it runs without throwing an error -->
+</dirac>
+```
+
+## Test Organization
+
+Tests should be placed in the `tests/` directory with the `.test.di` extension:
+
+```
+tests/
+  ├── basic-output.test.di
+  ├── variable-basic.test.di
+  ├── subroutine-basic.test.di
+  ├── if-conditional.test.di
+  └── ...
+```
+
+You can organize tests into subdirectories:
+
+```
+tests/
+  ├── core/
+  │   ├── output.test.di
+  │   └── variables.test.di
+  ├── control-flow/
+  │   ├── if.test.di
+  │   └── loop.test.di
+  └── llm/
+      └── basic.test.di
+```
+
+## Output Matching
+
+The test runner normalizes whitespace when comparing output:
+- Multiple spaces/newlines are collapsed to single spaces
+- Leading/trailing whitespace is trimmed
+- This allows tests to ignore XML formatting whitespace
+
+For example, these are equivalent:
+- Expected: `Hello World`
+- Actual: `  Hello   World  ` → matches ✓
+- Actual: `Hello\n  World` → matches ✓
+
+## Exit Codes
+
+- `0` - All tests passed
+- `1` - One or more tests failed
+
+## Continuous Integration
+
+Add to your CI pipeline:
+
+```yaml
+# .github/workflows/test.yml
+- name: Run tests
+  run: npm test
+```
+
+## Best Practices
+
+1. **One concept per test** - Each test should verify one specific behavior
+2. **Descriptive names** - Use clear test names that describe what's being tested
+3. **Test edge cases** - Include tests for error conditions and boundary cases
+4. **Keep tests fast** - Avoid LLM calls in unit tests (use mocks or separate integration tests)
+5. **Test regressions** - When fixing bugs, add a test to prevent regression
+
+## Example Test Suite
+
+```
+tests/
+  ├── basic-output.test.di          # Basic output functionality
+  ├── variable-basic.test.di        # Variable definition and output
+  ├── subroutine-basic.test.di      # Subroutine calls
+  ├── if-conditional.test.di        # Conditional execution
+  ├── loop-basic.test.di            # Loop functionality
+  ├── exception-basic.test.di       # Exception handling
+  └── test-if-basic.test.di         # test-if conditional
+```
+
+## Future Enhancements
+
+Potential improvements:
+- Watch mode for TDD workflow
+- Code coverage reporting
+- Performance benchmarks
+- Parallel test execution
+- Test fixtures/setup/teardown
+- Snapshot testing for complex outputs

package/config.yml

@@ -1,6 +1,6 @@
 # Dirac server configuration
 llmProvider: ollama 
-llmModel: llama2
+llmModel: llama2 
 
 embeddingServer:
  host: "localhost"

package/dist/{chunk-X3LQ626H.js → chunk-AMNIKIQX.js}

@@ -370,12 +370,12 @@ async function executeIf(session, element) {
   const condition = await evaluatePredicate(session, conditionElement);
   if (condition) {
     if (thenElement) {
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-46CAOCAZ.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-RURSTR65.js");
       await integrateChildren2(session, thenElement);
     }
   } else {
     if (elseElement) {
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-46CAOCAZ.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-RURSTR65.js");
       await integrateChildren2(session, elseElement);
     }
   }
@@ -388,7 +388,7 @@ async function evaluatePredicate(session, predicateElement) {
     return await evaluateCondition(session, predicateElement);
   }
   const outputLengthBefore = session.output.length;
-  const { integrate: integrate2 } = await import("./interpreter-46CAOCAZ.js");
+  const { integrate: integrate2 } = await import("./interpreter-RURSTR65.js");
   await integrate2(session, predicateElement);
   const newOutputChunks = session.output.slice(outputLengthBefore);
   const result = newOutputChunks.join("").trim();
@@ -411,11 +411,11 @@ async function evaluateCondition(session, condElement) {
   }
   const outputLengthBefore = session.output.length;
   const args = [];
-  const { integrate: integrate2 } = await import("./interpreter-46CAOCAZ.js");
+  const { integrate: integrate2 } = await import("./interpreter-RURSTR65.js");
   for (const child of condElement.children) {
     if (child.tag.toLowerCase() === "arg") {
       const argOutputStart = session.output.length;
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-46CAOCAZ.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-RURSTR65.js");
       await integrateChildren2(session, child);
       const newChunks = session.output.slice(argOutputStart);
       const argValue = newChunks.join("");
@@ -675,8 +675,13 @@ then you call it like
       example = example.replace(/"/g, '"').replace(/:/g, ":");
       systemPrompt += ">" + example + "</" + sub.name + ">";
     }
-    systemPrompt += "\nDo NOT invent or use any tags not listed above. For example, do NOT use <changeBackground> or <set-background>. Only use the allowed tags.\nInstructions: Output only valid Dirac XML tags from the list above. Do not include explanations or extra text.";
-    systemPrompt += "\nAfter generating your answer, check the command/tag list again and ensure every tag you use is in the list above. If any tag is not in the list, do not output it\u2014regenerate your answer using only allowed tags.";
+    systemPrompt += "\n\nIMPORTANT INSTRUCTIONS:";
+    systemPrompt += "\n1. Output ONLY valid XML tags from the list above";
+    systemPrompt += "\n2. Do NOT include any explanations, descriptions, or extra text";
+    systemPrompt += "\n3. Do NOT use bullet points or formatting - just pure XML";
+    systemPrompt += "\n4. Do NOT invent tags - only use tags from the list above";
+    systemPrompt += "\n5. Start your response directly with the XML tag (e.g., <add ...>)";
+    systemPrompt += "\n\nDouble-check: Does your response contain ONLY XML tags? If not, remove all non-XML text.";
     prompt = systemPrompt + "\nUser: " + userPrompt + "\nOutput:";
     if (session.debug || process.env.DIRAC_LOG_PROMPT === "1") {
       console.error("[LLM] Full prompt sent to LLM:\n" + prompt + "\n");
@@ -724,32 +729,191 @@ then you call it like
     if (outputVar) {
       setVariable(session, outputVar, result, false);
     } else if (executeMode) {
+      const validateTags = element.attributes["validate"] === "true";
+      const autocorrect = element.attributes["autocorrect"] === "true";
+      const maxRetries = parseInt(element.attributes["max-retries"] || "0", 10);
+      const feedbackMode = element.attributes["feedback"] === "true";
+      const maxIterations = parseInt(element.attributes["max-iterations"] || "3", 10);
+      const replaceTick = element.attributes["replace-tick"] === "true";
       if (session.debug) {
         console.error(`[LLM] Executing response as Dirac code:
 ${result}
 `);
-      }
-      const replaceTick = element.attributes["replace-tick"] === "true";
-      let diracCode = result.trim();
-      if (replaceTick && diracCode.startsWith("```")) {
-        const match = diracCode.match(/^```(\w+)?\n?/m);
-        if (match && match[1] === "bash") {
-          const endIdx = diracCode.indexOf("```", 3);
-          let bashContent = diracCode.slice(match[0].length, endIdx).trim();
-          diracCode = `<system>${bashContent}</system>`;
-        } else {
-          diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, "").replace(/\n?```$/m, "").trim();
+        if (validateTags) {
+          console.error(`[LLM] Tag validation enabled (autocorrect: ${autocorrect}, max-retries: ${maxRetries})`);
+        }
+        if (feedbackMode) {
+          console.error(`[LLM] Feedback mode enabled (max iterations: ${maxIterations})`);
         }
       }
-      try {
-        const parser = new DiracParser();
-        const dynamicAST = parser.parse(diracCode);
-        await integrate(session, dynamicAST);
-      } catch (parseError) {
-        if (session.debug) {
-          console.error(`[LLM] Failed to parse as Dirac, treating as text: ${parseError}`);
+      let iteration = 0;
+      while (iteration < maxIterations && (iteration === 0 || feedbackMode)) {
+        iteration++;
+        if (session.debug && feedbackMode) {
+          console.error(`[LLM] Feedback iteration ${iteration}/${maxIterations}`);
+        }
+        let diracCode = result.trim();
+        if (replaceTick && diracCode.startsWith("```")) {
+          const match = diracCode.match(/^```(\w+)?\n?/m);
+          if (match && match[1] === "bash") {
+            const endIdx = diracCode.indexOf("```", 3);
+            let bashContent = diracCode.slice(match[0].length, endIdx).trim();
+            diracCode = `<system>${bashContent}</system>`;
+          } else {
+            diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, "").replace(/\n?```$/m, "").trim();
+          }
+        }
+        const outputBefore = feedbackMode ? session.output.slice() : [];
+        try {
+          const parser = new DiracParser();
+          let dynamicAST = parser.parse(diracCode);
+          if (validateTags) {
+            const { validateDiracCode, applyCorrectedTags } = await import("./tag-validator-I3GLCBVD.js");
+            let validation = await validateDiracCode(session, dynamicAST, { autocorrect });
+            let retryCount = 0;
+            while (!validation.valid && retryCount < maxRetries) {
+              retryCount++;
+              if (session.debug) {
+                console.error(`[LLM] Validation failed (attempt ${retryCount}/${maxRetries}):`, validation.errorMessages);
+              }
+              const errorFeedback = validation.errorMessages.join("\n");
+              const retryPrompt = `Your previous response had the following errors:
+${errorFeedback}
+
+Please fix these errors and generate valid Dirac XML again. Remember to only use the allowed tags.`;
+              dialogHistory.push({ role: "user", content: retryPrompt });
+              if (isOpenAI) {
+                const response = await session.llmClient.chat.completions.create({
+                  model,
+                  max_tokens: maxTokens,
+                  temperature,
+                  messages: dialogHistory
+                });
+                result = response.choices[0]?.message?.content || "";
+              } else if (isOllama) {
+                const ollamaPrompt = dialogHistory.map((m) => `${m.role.charAt(0).toUpperCase() + m.role.slice(1)}: ${m.content}`).join("\n");
+                result = await session.llmClient.complete(ollamaPrompt, {
+                  model,
+                  temperature,
+                  max_tokens: maxTokens
+                });
+              } else {
+                const response = await session.llmClient.messages.create({
+                  model,
+                  max_tokens: maxTokens,
+                  temperature,
+                  messages: dialogHistory
+                });
+                const content = response.content[0];
+                result = content.type === "text" ? content.text : "";
+              }
+              dialogHistory.push({ role: "assistant", content: result });
+              if (contextVar) {
+                setVariable(session, contextVar, dialogHistory, true);
+              }
+              if (session.debug) {
+                console.error(`[LLM] Retry ${retryCount} response:
+${result}
+`);
+              }
+              diracCode = result.trim();
+              if (replaceTick && diracCode.startsWith("```")) {
+                const match = diracCode.match(/^```(\w+)?\n?/m);
+                if (match && match[1] === "bash") {
+                  const endIdx = diracCode.indexOf("```", 3);
+                  let bashContent = diracCode.slice(match[0].length, endIdx).trim();
+                  diracCode = `<system>${bashContent}</system>`;
+                } else {
+                  diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, "").replace(/\n?```$/m, "").trim();
+                }
+              }
+              dynamicAST = parser.parse(diracCode);
+              validation = await validateDiracCode(session, dynamicAST, { autocorrect });
+            }
+            if (!validation.valid) {
+              throw new Error(`Tag validation failed after ${maxRetries} retries:
+${validation.errorMessages.join("\n")}`);
+            }
+            if (autocorrect) {
+              dynamicAST = applyCorrectedTags(dynamicAST, validation.results);
+              if (session.debug) {
+                console.error("[LLM] Applied auto-corrections to tags");
+              }
+            }
+          }
+          await integrate(session, dynamicAST);
+          if (feedbackMode) {
+            const outputAfter = session.output.slice();
+            const executionOutput = outputAfter.slice(outputBefore.length).join("");
+            if (session.debug) {
+              console.error(`[LLM] Execution output (${executionOutput.length} chars):
+${executionOutput}
+`);
+            }
+            const feedbackPrompt = `The code executed successfully. Here is the output:
+\`\`\`
+${executionOutput}
+\`\`\`
+
+Please review the output carefully. If the output is correct and complete, respond with ONLY the word "DONE" and nothing else. If the output is incorrect or incomplete, generate corrected Dirac XML code.`;
+            if (session.debug) {
+              console.error(`[LLM] Feedback prompt:
+${feedbackPrompt}
+`);
+            }
+            dialogHistory.push({ role: "user", content: feedbackPrompt });
+            if (isOpenAI) {
+              const response = await session.llmClient.chat.completions.create({
+                model,
+                max_tokens: maxTokens,
+                temperature,
+                messages: dialogHistory
+              });
+              result = response.choices[0]?.message?.content || "";
+            } else if (isOllama) {
+              const ollamaPrompt = dialogHistory.map((m) => `${m.role.charAt(0).toUpperCase() + m.role.slice(1)}: ${m.content}`).join("\n");
+              result = await session.llmClient.complete(ollamaPrompt, {
+                model,
+                temperature,
+                max_tokens: maxTokens
+              });
+            } else {
+              const response = await session.llmClient.messages.create({
+                model,
+                max_tokens: maxTokens,
+                temperature,
+                messages: dialogHistory
+              });
+              const content = response.content[0];
+              result = content.type === "text" ? content.text : "";
+            }
+            dialogHistory.push({ role: "assistant", content: result });
+            if (contextVar) {
+              setVariable(session, contextVar, dialogHistory, true);
+            }
+            if (session.debug) {
+              console.error(`[LLM] Feedback response:
+${result}
+`);
+            }
+            const responseStart = result.trim().substring(0, 100).toUpperCase();
+            if (responseStart.startsWith("DONE") || result.trim().toLowerCase().includes("looks correct") || result.trim().toLowerCase().includes("looks good")) {
+              if (session.debug) {
+                console.error(`[LLM] Feedback loop terminating - LLM indicated completion
+`);
+              }
+              break;
+            }
+          } else {
+            break;
+          }
+        } catch (parseError) {
+          if (session.debug) {
+            console.error(`[LLM] Failed to parse as Dirac, treating as text: ${parseError}`);
+          }
+          emit(session, result);
+          break;
         }
-        emit(session, result);
       }
     } else {
       emit(session, result);
@@ -1162,7 +1326,7 @@ async function executeTagCheck(session, element) {
       const executeTag = correctedTag || tagName;
       console.error(`[tag-check] Executing <${executeTag}/> as all checks passed and execute=true.`);
       const elementToExecute = correctedTag ? { ...child, tag: correctedTag } : child;
-      const { integrate: integrate2 } = await import("./interpreter-46CAOCAZ.js");
+      const { integrate: integrate2 } = await import("./interpreter-RURSTR65.js");
       await integrate2(session, elementToExecute);
     }
   }
@@ -1171,7 +1335,7 @@ async function executeTagCheck(session, element) {
 // src/tags/throw.ts
 async function executeThrow(session, element) {
   const exceptionName = element.attributes?.name || "exception";
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-46CAOCAZ.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-RURSTR65.js");
   const exceptionDom = {
     tag: "exception-content",
     attributes: { name: exceptionName },
@@ -1184,7 +1348,7 @@ async function executeThrow(session, element) {
 // src/tags/try.ts
 async function executeTry(session, element) {
   setExceptionBoundary(session);
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-46CAOCAZ.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-RURSTR65.js");
   await integrateChildren2(session, element);
   unsetExceptionBoundary(session);
 }
@@ -1194,7 +1358,7 @@ async function executeCatch(session, element) {
   const exceptionName = element.attributes?.name || "exception";
   const caughtCount = lookupException(session, exceptionName);
   if (caughtCount > 0) {
-    const { integrateChildren: integrateChildren2 } = await import("./interpreter-46CAOCAZ.js");
+    const { integrateChildren: integrateChildren2 } = await import("./interpreter-RURSTR65.js");
     await integrateChildren2(session, element);
   }
   flushCurrentException(session);
@@ -1203,7 +1367,7 @@ async function executeCatch(session, element) {
 // src/tags/exception.ts
 async function executeException(session, element) {
   const exceptions = getCurrentExceptions(session);
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-46CAOCAZ.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-RURSTR65.js");
   for (const exceptionDom of exceptions) {
     await integrateChildren2(session, exceptionDom);
   }

package/dist/{chunk-VHP3G4BF.js → chunk-KRLCG4G4.js}

@@ -1,7 +1,7 @@
 import {
   DiracParser,
   integrate
-} from "./chunk-X3LQ626H.js";
+} from "./chunk-AMNIKIQX.js";
 import {
   createSession,
   getAvailableSubroutines,

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   execute
-} from "./chunk-VHP3G4BF.js";
-import "./chunk-X3LQ626H.js";
+} from "./chunk-KRLCG4G4.js";
+import "./chunk-AMNIKIQX.js";
 import "./chunk-E7IWGUE6.js";
 
 // src/cli.ts
@@ -11,7 +11,7 @@ import "dotenv/config";
 // package.json
 var package_default = {
   name: "dirac-lang",
-  version: "0.1.9",
+  version: "0.1.11",
   description: "LLM-Augmented Declarative Execution",
   type: "module",
   main: "dist/index.js",
@@ -21,8 +21,9 @@ var package_default = {
   },
   scripts: {
     dev: "tsx src/cli.ts",
-    build: "tsup src/index.ts src/cli.ts --format esm --dts --clean",
-    test: "vitest",
+    build: "tsup src/index.ts src/cli.ts src/test-runner.ts --format esm --dts --clean",
+    test: "npm run build && node dist/test-runner.js tests",
+    "test:watch": "npm run build && node dist/test-runner.js tests --watch",
     typecheck: "tsc --noEmit"
   },
   keywords: [

package/dist/index.js

@@ -2,11 +2,11 @@ import {
   createLLMAdapter,
   execute,
   executeUserCommand
-} from "./chunk-VHP3G4BF.js";
+} from "./chunk-KRLCG4G4.js";
 import {
   DiracParser,
   integrate
-} from "./chunk-X3LQ626H.js";
+} from "./chunk-AMNIKIQX.js";
 import {
   createSession,
   getAvailableSubroutines,

package/dist/{interpreter-46CAOCAZ.js → interpreter-RURSTR65.js}

@@ -1,7 +1,7 @@
 import {
   integrate,
   integrateChildren
-} from "./chunk-X3LQ626H.js";
+} from "./chunk-AMNIKIQX.js";
 import "./chunk-E7IWGUE6.js";
 export {
   integrate,