dirac-lang 0.1.9 → 0.1.10

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/dist/{chunk-VHP3G4BF.js → chunk-3LRJLSZC.js}

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

package/dist/{chunk-X3LQ626H.js → chunk-UDA4H3GU.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-BYQIE2MI.js");
       await integrateChildren2(session, thenElement);
     }
   } else {
     if (elseElement) {
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-46CAOCAZ.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-BYQIE2MI.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-BYQIE2MI.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-BYQIE2MI.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-BYQIE2MI.js");
       await integrateChildren2(session, child);
       const newChunks = session.output.slice(argOutputStart);
       const argValue = newChunks.join("");
@@ -724,10 +724,16 @@ 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);
       if (session.debug) {
         console.error(`[LLM] Executing response as Dirac code:
 ${result}
 `);
+        if (validateTags) {
+          console.error(`[LLM] Tag validation enabled (autocorrect: ${autocorrect}, max-retries: ${maxRetries})`);
+        }
       }
       const replaceTick = element.attributes["replace-tick"] === "true";
       let diracCode = result.trim();
@@ -743,7 +749,81 @@ ${result}
       }
       try {
         const parser = new DiracParser();
-        const dynamicAST = parser.parse(diracCode);
+        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);
       } catch (parseError) {
         if (session.debug) {
@@ -1162,7 +1242,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-BYQIE2MI.js");
       await integrate2(session, elementToExecute);
     }
   }
@@ -1171,7 +1251,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-BYQIE2MI.js");
   const exceptionDom = {
     tag: "exception-content",
     attributes: { name: exceptionName },
@@ -1184,7 +1264,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-BYQIE2MI.js");
   await integrateChildren2(session, element);
   unsetExceptionBoundary(session);
 }
@@ -1194,7 +1274,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-BYQIE2MI.js");
     await integrateChildren2(session, element);
   }
   flushCurrentException(session);
@@ -1203,7 +1283,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-BYQIE2MI.js");
   for (const exceptionDom of exceptions) {
     await integrateChildren2(session, exceptionDom);
   }

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   execute
-} from "./chunk-VHP3G4BF.js";
-import "./chunk-X3LQ626H.js";
+} from "./chunk-3LRJLSZC.js";
+import "./chunk-UDA4H3GU.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.10",
   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-3LRJLSZC.js";
 import {
   DiracParser,
   integrate
-} from "./chunk-X3LQ626H.js";
+} from "./chunk-UDA4H3GU.js";
 import {
   createSession,
   getAvailableSubroutines,

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

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

package/dist/tag-validator-I3GLCBVD.js

@@ -0,0 +1,152 @@
+// src/utils/tag-validator.ts
+import fs from "fs";
+import yaml from "js-yaml";
+var SIMILARITY_CUTOFF = 0.75;
+function getEmbeddingServerConfig() {
+  try {
+    const config = yaml.load(fs.readFileSync("config.yml", "utf8"));
+    const host = config.embeddingServer?.host || "localhost";
+    const port = config.embeddingServer?.port || 11435;
+    return { host, port };
+  } catch {
+    return { host: "localhost", port: 11435 };
+  }
+}
+async function getEmbeddings(tags) {
+  const { host, port } = getEmbeddingServerConfig();
+  return await Promise.all(tags.map(async (tag) => {
+    const response = await fetch(`http://${host}:${port}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "embeddinggemma", prompt: tag })
+    });
+    const data = await response.json();
+    return data.embedding;
+  }));
+}
+function cosine(a, b) {
+  const dot = a.reduce((sum, v, i) => sum + v * b[i], 0);
+  const normA = Math.sqrt(a.reduce((sum, v) => sum + v * v, 0));
+  const normB = Math.sqrt(b.reduce((sum, v) => sum + v * v, 0));
+  return dot / (normA * normB);
+}
+async function getBestTagMatch(candidate, allowed) {
+  const tags = [candidate, ...allowed];
+  const embeddings = await getEmbeddings(tags);
+  const candidateVec = embeddings[0];
+  const allowedVecs = embeddings.slice(1);
+  let bestIdx = 0, bestScore = -1;
+  allowedVecs.forEach((vec, i) => {
+    const score = cosine(candidateVec, vec);
+    if (score > bestScore) {
+      bestScore = score;
+      bestIdx = i;
+    }
+  });
+  return { tag: allowed[bestIdx], score: bestScore };
+}
+async function validateTag(session, element, options = {}) {
+  const { autocorrect = false, similarityCutoff = SIMILARITY_CUTOFF } = options;
+  const { getAvailableSubroutines } = await import("./session-Z37PNJOE.js");
+  const subroutines = getAvailableSubroutines(session);
+  const allowed = new Set(subroutines.map((s) => s.name));
+  const tagName = element.tag;
+  const result = {
+    valid: false,
+    tagName,
+    originalTag: tagName,
+    corrected: false,
+    errors: [],
+    warnings: []
+  };
+  if (allowed.has(tagName)) {
+    const sub = subroutines.find((s) => s.name === tagName);
+    if (sub && Array.isArray(sub.parameters)) {
+      const paramNames = sub.parameters.map((p) => p.name);
+      for (const param of sub.parameters) {
+        if (param.required && !(param.name in element.attributes)) {
+          result.errors.push(`Missing required parameter: ${param.name}`);
+        }
+      }
+      for (const attr in element.attributes) {
+        if (!paramNames.includes(attr)) {
+          result.warnings.push(`Unknown attribute: ${attr}`);
+        }
+      }
+    }
+    result.valid = result.errors.length === 0;
+  } else {
+    const best = await getBestTagMatch(tagName, Array.from(allowed));
+    if (best.score >= similarityCutoff) {
+      result.similarity = best.score;
+      if (autocorrect) {
+        result.tagName = best.tag;
+        result.corrected = true;
+        result.warnings.push(`Auto-corrected from <${tagName}> to <${best.tag}> (similarity: ${best.score.toFixed(2)})`);
+        const sub = subroutines.find((s) => s.name === best.tag);
+        if (sub && Array.isArray(sub.parameters)) {
+          const paramNames = sub.parameters.map((p) => p.name);
+          for (const param of sub.parameters) {
+            if (param.required && !(param.name in element.attributes)) {
+              result.errors.push(`Missing required parameter: ${param.name}`);
+            }
+          }
+          for (const attr in element.attributes) {
+            if (!paramNames.includes(attr)) {
+              result.warnings.push(`Unknown attribute: ${attr}`);
+            }
+          }
+        }
+        result.valid = result.errors.length === 0;
+      } else {
+        result.errors.push(`Tag <${tagName}> does not exist. Did you mean <${best.tag}>? (similarity: ${best.score.toFixed(2)})`);
+      }
+    } else {
+      result.errors.push(`Tag <${tagName}> does not exist and no similar tag was found.`);
+    }
+  }
+  return result;
+}
+async function validateDiracCode(session, ast, options = {}) {
+  const results = [];
+  const errorMessages = [];
+  async function validateElement(element) {
+    if (element.tag && element.tag !== "dirac" && element.tag !== "") {
+      const result = await validateTag(session, element, options);
+      results.push(result);
+      if (!result.valid) {
+        errorMessages.push(`<${result.originalTag}>: ${result.errors.join(", ")}`);
+      }
+    }
+    for (const child of element.children) {
+      await validateElement(child);
+    }
+  }
+  await validateElement(ast);
+  return {
+    valid: errorMessages.length === 0,
+    results,
+    errorMessages
+  };
+}
+function applyCorrectedTags(ast, results) {
+  let resultIndex = 0;
+  function correctElement(element) {
+    if (element.tag && element.tag !== "dirac" && element.tag !== "") {
+      const result = results[resultIndex++];
+      if (result && result.corrected) {
+        element = { ...element, tag: result.tagName };
+      }
+    }
+    return {
+      ...element,
+      children: element.children.map((child) => correctElement(child))
+    };
+  }
+  return correctElement(ast);
+}
+export {
+  applyCorrectedTags,
+  validateDiracCode,
+  validateTag
+};