@rune-kit/rune 2.2.1 → 2.2.3

package/hooks/post-session-reflect/index.cjs

@@ -0,0 +1,153 @@
+// Rune Post-Session Reflect Hook
+// 1. Flushes session metrics from tmpdir to .rune/metrics/ (H3 Intelligence)
+// 2. Displays structured self-review checklist at session end (Stop event)
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const cwd = process.cwd();
+const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
+
+// === H3: Flush Session Metrics ===
+
+const metricsJsonl = path.join(os.tmpdir(), `rune-metrics-${hash}.jsonl`);
+const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+const runeMetricsDir = path.join(cwd, '.rune', 'metrics');
+
+try {
+  flushMetrics();
+} catch (e) {
+  // Metrics flush is best-effort — never block session end
+  // Silently ignore errors
+}
+
+function flushMetrics() {
+  // Read session skill invocations from tmpdir JSONL
+  let skillEvents = [];
+  if (fs.existsSync(metricsJsonl)) {
+    const lines = fs.readFileSync(metricsJsonl, 'utf-8').trim().split('\n').filter(Boolean);
+    for (const line of lines) {
+      try { skillEvents.push(JSON.parse(line)); } catch { /* skip malformed */ }
+    }
+  }
+
+  // Read context-watch state for tool counts and session timing
+  let watchState = { count: 0, sessionStart: null, toolCounts: {} };
+  if (fs.existsSync(counterFile)) {
+    try {
+      watchState = JSON.parse(fs.readFileSync(counterFile, 'utf-8'));
+    } catch { /* use defaults */ }
+  }
+
+  // Nothing to flush if no data
+  if (skillEvents.length === 0 && watchState.count === 0) return;
+
+  // Ensure .rune/metrics/ exists
+  fs.mkdirSync(runeMetricsDir, { recursive: true });
+
+  const now = new Date().toISOString();
+  const sessionStart = watchState.sessionStart || now;
+  const durationMin = Math.round((new Date(now) - new Date(sessionStart)) / 60000);
+
+  // Build skill usage map
+  const skillCounts = {};
+  const skillChain = [];
+  for (const evt of skillEvents) {
+    skillCounts[evt.skill] = (skillCounts[evt.skill] || 0) + 1;
+    skillChain.push(evt.skill);
+  }
+
+  // Determine primary skill (most invoked)
+  const primarySkill = Object.entries(skillCounts)
+    .sort((a, b) => b[1] - a[1])[0]?.[0] || 'none';
+
+  // Generate session ID
+  const sessionId = `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
+
+  // 1. Append to sessions.jsonl
+  const sessionEntry = {
+    id: sessionId,
+    date: now.slice(0, 10),
+    duration_min: durationMin,
+    tool_calls: watchState.count,
+    tool_distribution: watchState.toolCounts,
+    skill_invocations: skillEvents.length,
+    skills_used: Object.keys(skillCounts),
+    primary_skill: primarySkill
+  };
+
+  const sessionsFile = path.join(runeMetricsDir, 'sessions.jsonl');
+  fs.appendFileSync(sessionsFile, JSON.stringify(sessionEntry) + '\n');
+
+  // Cap at 100 sessions (rotate oldest)
+  try {
+    const allLines = fs.readFileSync(sessionsFile, 'utf-8').trim().split('\n').filter(Boolean);
+    if (allLines.length > 100) {
+      fs.writeFileSync(sessionsFile, allLines.slice(-100).join('\n') + '\n');
+    }
+  } catch { /* cap is best-effort */ }
+
+  // 2. Merge into skills.json (running totals)
+  const skillsFile = path.join(runeMetricsDir, 'skills.json');
+  let skillsData = { version: 1, updated: now, skills: {} };
+  if (fs.existsSync(skillsFile)) {
+    try {
+      skillsData = JSON.parse(fs.readFileSync(skillsFile, 'utf-8'));
+    } catch { /* start fresh */ }
+  }
+
+  for (const [skill, count] of Object.entries(skillCounts)) {
+    if (!skillsData.skills[skill]) {
+      skillsData.skills[skill] = { total_invocations: 0, last_used: now.slice(0, 10) };
+    }
+    skillsData.skills[skill].total_invocations += count;
+    skillsData.skills[skill].last_used = now.slice(0, 10);
+  }
+  skillsData.updated = now;
+
+  fs.writeFileSync(skillsFile, JSON.stringify(skillsData, null, 2) + '\n');
+
+  // 3. Append to chains.jsonl
+  if (skillChain.length > 0) {
+    const chainsFile = path.join(runeMetricsDir, 'chains.jsonl');
+    const chainEntry = {
+      session: sessionId,
+      chain: skillChain,
+      depth: skillChain.length
+    };
+    fs.appendFileSync(chainsFile, JSON.stringify(chainEntry) + '\n');
+  }
+
+  // 4. Cleanup tmpdir files
+  try { fs.unlinkSync(metricsJsonl); } catch { /* already gone */ }
+  // Note: counterFile is cleaned by session-start hook on next session
+
+  // Report metrics flush
+  const skillList = Object.entries(skillCounts)
+    .sort((a, b) => b[1] - a[1])
+    .map(([s, c]) => `${s}(${c})`)
+    .join(', ');
+
+  console.log(`\n📊 [Rune metrics] Session ${sessionId} — ${durationMin}min, ${watchState.count} tool calls, ${skillEvents.length} skill invocations`);
+  if (skillList) console.log(`   Skills: ${skillList}`);
+  console.log(`   Saved to .rune/metrics/\n`);
+}
+
+// === Original: Verification Checklist ===
+
+console.log(`
+┌─────────────────────────────────────────────────────┐
+│  Rune Session End — Verification Checklist          │
+├─────────────────────────────────────────────────────┤
+│  Before closing this session, confirm:              │
+│                                                     │
+│  □ All TodoWrite tasks marked complete?             │
+│  □ Tests ran and passing?                           │
+│  □ No hardcoded secrets introduced?                 │
+│  □ If schema changed: migration + rollback exist?   │
+│  □ Verification ran (lint + types + build)?         │
+│                                                     │
+│  If any item is unclear → address it now.           │
+└─────────────────────────────────────────────────────┘
+`);

package/hooks/pre-compact/index.cjs

@@ -0,0 +1,95 @@
+// Rune Pre-Compact Hook
+// Saves critical state BEFORE Claude auto-compacts context window.
+// Prevents data loss from losing decisions, progress, and metrics mid-session.
+//
+// Captures: context-watch state, active task summary, decisions made this session.
+// Writes snapshot to .rune/pre-compact-snapshot.md for post-compact recovery.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const cwd = process.cwd();
+const runeDir = path.join(cwd, '.rune');
+
+// Read context-watch state (tool counts, session timing)
+const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
+const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+
+let watchState = null;
+try {
+  const raw = fs.readFileSync(counterFile, 'utf-8');
+  watchState = JSON.parse(raw);
+} catch {
+  // No counter file — session may be fresh
+}
+
+// Collect .rune/ state summaries
+const stateFiles = ['progress.md', 'decisions.md', 'conventions.md'];
+const summaries = [];
+
+if (fs.existsSync(runeDir)) {
+  for (const file of stateFiles) {
+    const filePath = path.join(runeDir, file);
+    if (fs.existsSync(filePath)) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8').trim();
+        if (content.length > 0) {
+          // Take first 50 lines to keep snapshot compact
+          const lines = content.split('\n').slice(0, 50);
+          summaries.push({ file, preview: lines.join('\n') });
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+  }
+}
+
+// Build snapshot
+const snapshot = [];
+snapshot.push('# Pre-Compact Snapshot');
+snapshot.push(`Generated: ${new Date().toISOString()}`);
+snapshot.push('');
+
+if (watchState) {
+  snapshot.push('## Session Metrics');
+  snapshot.push(`- Tool calls: ${watchState.count || 0}`);
+  snapshot.push(`- Session start: ${watchState.sessionStart || 'unknown'}`);
+  if (watchState.toolCounts) {
+    const top5 = Object.entries(watchState.toolCounts)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5);
+    snapshot.push(`- Top tools: ${top5.map(([k, v]) => `${k}(${v})`).join(', ')}`);
+  }
+  snapshot.push('');
+}
+
+if (summaries.length > 0) {
+  snapshot.push('## State Files (preview)');
+  for (const { file, preview } of summaries) {
+    snapshot.push(`### .rune/${file}`);
+    snapshot.push(preview);
+    snapshot.push('');
+  }
+}
+
+// Write snapshot if we have anything worth saving
+if (watchState || summaries.length > 0) {
+  try {
+    if (!fs.existsSync(runeDir)) {
+      fs.mkdirSync(runeDir, { recursive: true });
+    }
+    fs.writeFileSync(
+      path.join(runeDir, 'pre-compact-snapshot.md'),
+      snapshot.join('\n')
+    );
+    console.log(`[Rune pre-compact] State snapshot saved (${watchState ? watchState.count : 0} tool calls, ${summaries.length} state files).`);
+  } catch (e) {
+    console.error(`[Rune pre-compact] Failed to save snapshot: ${e.message}`);
+  }
+} else {
+  console.log('[Rune pre-compact] No state to snapshot — fresh session.');
+}
+
+process.exit(0);

package/hooks/pre-tool-guard/index.cjs

@@ -0,0 +1,68 @@
+// Rune Pre-Tool Guard Hook
+// Preventive security gate — warns before AI reads/edits sensitive files
+// Runs as PreToolUse hook for Read, Write, Edit tools
+
+const path = require('path');
+
+// Read tool_input from Claude Code hook stdin
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  let toolInput = {};
+  try {
+    const parsed = JSON.parse(input);
+    toolInput = parsed.tool_input || parsed;
+  } catch {
+    // If no stdin or parse fails, exit cleanly (non-blocking)
+    process.exit(0);
+  }
+
+  const filePath = toolInput.file_path || toolInput.path || '';
+  if (!filePath) process.exit(0);
+
+  const basename = path.basename(filePath);
+  const normalized = filePath.replace(/\\/g, '/');
+
+  // Sensitive file patterns
+  const sensitivePatterns = [
+    /^\.env$/,                         // .env exactly
+    /^\.env\.[^e]/,                    // .env.* but NOT .env.example
+    /\.pem$/,
+    /\.key$/,
+    /\.p12$/,
+    /\.pfx$/,
+    /^credentials\.json$/,
+    /\.secret$/,
+    /^\.netrc$/,
+    /^id_rsa$/,
+    /^id_ed25519$/,
+    /^id_ecdsa$/,
+    /^\.ssh\//,
+    /private.*key/i,
+    /secret.*key/i,
+  ];
+
+  // Exclude safe exceptions
+  const safeExceptions = [
+    /\.env\.example$/,
+    /\.env\.sample$/,
+    /\.env\.template$/,
+    /\.env\.test$/,
+    /test.*credential/i,
+    /fixture/i,
+    /mock/i,
+  ];
+
+  const isSensitive = sensitivePatterns.some((p) => p.test(basename) || p.test(normalized));
+  const isSafe = safeExceptions.some((p) => p.test(basename) || p.test(normalized));
+
+  if (isSensitive && !isSafe) {
+    // Output warning to user — does NOT hard-block (developer may legitimately need access)
+    console.log(`\n⚠ [Rune pre-tool-guard] Sensitive file detected: ${filePath}`);
+    console.log('  This file may contain secrets. Confirm this access is intentional.');
+    console.log('  If scanning for secrets, use /rune sentinel instead.\n');
+  }
+
+  process.exit(0);
+});

package/hooks/run-hook

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// Rune hook runner — loads and executes named hook modules
+const path = require('path');
+
+const hookName = process.argv[2];
+if (!hookName) {
+  console.error('Usage: run-hook <hook-name>');
+  process.exit(1);
+}
+
+const hookPath = path.join(__dirname, hookName, 'index.js');
+try {
+  require(hookPath);
+} catch (e) {
+  console.error(`Rune hook "${hookName}" failed: ${e.message}`);
+  process.exit(1);
+}

package/hooks/run-hook.cjs

@@ -0,0 +1,16 @@
+// Rune hook runner — loads and executes named hook modules
+const path = require('path');
+
+const hookName = process.argv[2];
+if (!hookName) {
+  console.error('Usage: run-hook <hook-name>');
+  process.exit(1);
+}
+
+const hookPath = path.join(__dirname, hookName, 'index.cjs');
+try {
+  require(hookPath);
+} catch (e) {
+  console.error(`Rune hook "${hookName}" failed: ${e.message}`);
+  process.exit(1);
+}

package/hooks/run-hook.cmd

@@ -0,0 +1 @@
+@node "%~dp0run-hook.js" %*

package/hooks/secrets-scan/index.cjs

@@ -0,0 +1,100 @@
+// Rune Secrets Scan Hook
+// PreToolUse hook on Bash — intercepts git commit commands
+// Scans staged files for hardcoded secrets before allowing commit
+//
+// Patterns based on gitleaks + common AI-generated secret leaks.
+// Zero false-positive tolerance on BLOCK patterns.
+
+const { execSync } = require('child_process');
+
+// Only intercept git commit commands
+const input = JSON.parse(process.env.CLAUDE_TOOL_INPUT || '{}');
+const command = (input.command || '').trim();
+
+// Check if this is a git commit command
+if (!/^git\s+commit\b/.test(command)) {
+  // Not a commit — pass through
+  process.exit(0);
+}
+
+// Get staged files
+let stagedFiles;
+try {
+  stagedFiles = execSync('git diff --cached --name-only', { encoding: 'utf-8' })
+    .trim()
+    .split('\n')
+    .filter(f => f.length > 0);
+} catch {
+  // Not in a git repo or no staged files — pass through
+  process.exit(0);
+}
+
+if (stagedFiles.length === 0) {
+  process.exit(0);
+}
+
+// Secret patterns (high-confidence, low false-positive)
+const BLOCK_PATTERNS = [
+  { name: 'AWS Access Key', regex: /AKIA[0-9A-Z]{16}/ },
+  { name: 'GitHub Token', regex: /gh[ps]_[A-Za-z0-9_]{36,}/ },
+  { name: 'Slack Token', regex: /xox[bpors]-[0-9a-zA-Z-]{10,}/ },
+  { name: 'Stripe Key', regex: /[sr]k_(live|test)_[0-9a-zA-Z]{24,}/ },
+  { name: 'SendGrid Key', regex: /SG\.[a-zA-Z0-9_-]{22}\.[a-zA-Z0-9_-]{43}/ },
+  { name: 'Twilio Key', regex: /SK[0-9a-fA-F]{32}/ },
+  { name: 'Firebase Key', regex: /AIza[0-9A-Za-z_-]{35}/ },
+  { name: 'Private Key', regex: /-----BEGIN (RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/ },
+  { name: 'OpenAI Key', regex: /sk-[A-Za-z0-9]{32,}/ },
+  { name: 'Anthropic Key', regex: /sk-ant-[A-Za-z0-9_-]{32,}/ },
+];
+
+// Files to always skip (test fixtures, examples)
+const SKIP_PATHS = /\/(test|tests|__tests__|fixtures|__mocks__|examples?|\.test\.|\.spec\.)/i;
+
+// Scan staged content (not files on disk — staged content via git show)
+const findings = [];
+
+for (const file of stagedFiles) {
+  // Skip test/fixture files
+  if (SKIP_PATHS.test(file)) continue;
+
+  // Skip binary files and lockfiles
+  if (/\.(png|jpg|gif|ico|woff|ttf|lock|lockb)$/i.test(file)) continue;
+
+  let content;
+  try {
+    content = execSync(`git show ":${file}"`, { encoding: 'utf-8', maxBuffer: 1024 * 1024 });
+  } catch {
+    continue; // File deleted or binary
+  }
+
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of BLOCK_PATTERNS) {
+      if (pattern.regex.test(line)) {
+        findings.push({
+          file,
+          line: i + 1,
+          pattern: pattern.name,
+          snippet: line.substring(0, 80).trim(),
+        });
+      }
+    }
+  }
+}
+
+if (findings.length > 0) {
+  console.error('\n\u{1F6A8} [Rune secrets-scan] BLOCKED — hardcoded secrets detected in staged files:\n');
+  for (const f of findings) {
+    console.error(`  ${f.file}:${f.line} — ${f.pattern}`);
+    console.error(`    ${f.snippet}...`);
+  }
+  console.error('\n  Fix: Remove secrets, use environment variables instead.');
+  console.error('  Override: git commit --no-verify (NOT recommended)\n');
+
+  // BLOCK the commit
+  process.exit(2);
+}
+
+// No secrets found — allow commit
+process.exit(0);

package/hooks/session-start/index.cjs

@@ -0,0 +1,65 @@
+// Rune Session Start Hook
+// Loads and injects .rune/ state file CONTENTS into context at session start
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const cwd = process.cwd();
+const runeDir = path.join(cwd, '.rune');
+
+// Reset context-watch counter on session start (fresh context window)
+const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
+const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+try { fs.unlinkSync(counterFile); } catch { /* no counter yet — fine */ }
+
+if (fs.existsSync(runeDir)) {
+  const stateFiles = [
+    'progress.md',
+    'decisions.md',
+    'conventions.md',
+    'RESCUE-STATE.md',
+    'DEVELOPER-GUIDE.md',
+    'logic-manifest.json'
+  ];
+  const loaded = [];
+
+  for (const file of stateFiles) {
+    const filePath = path.join(runeDir, file);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf-8').trim();
+      if (content.length > 0) {
+        console.log(`\n=== .rune/${file} ===\n${content}`);
+        loaded.push(file);
+      }
+    }
+  }
+
+  // Inject active behavioral context mode
+  const activeContextFile = path.join(runeDir, 'active-context.md');
+  if (fs.existsSync(activeContextFile)) {
+    try {
+      const mode = fs.readFileSync(activeContextFile, 'utf-8').trim();
+      if (mode) {
+        // Look for the context file in plugin's contexts/ directory
+        const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || path.join(__dirname, '..', '..');
+        const contextFile = path.join(pluginRoot, 'contexts', `${mode}.md`);
+        if (fs.existsSync(contextFile)) {
+          const contextContent = fs.readFileSync(contextFile, 'utf-8').trim();
+          console.log(`\n=== Active Context: ${mode} mode ===\n${contextContent}`);
+          loaded.push(`active-context(${mode})`);
+        }
+      }
+    } catch {
+      // Non-critical — skip silently
+    }
+  }
+
+  if (loaded.length > 0) {
+    console.log(`\n[Rune: injected project state from ${loaded.join(', ')}]`);
+  } else {
+    console.log('[Rune: .rune/ directory found but no state files yet. Run /rune onboard to populate.]');
+  }
+} else {
+  console.log('[Rune: No .rune/ directory found. Run /rune onboard to set up project context.]');
+}

package/hooks/typecheck/index.cjs

@@ -0,0 +1,65 @@
+// Rune TypeScript Check Hook
+// PostToolUse hook on Edit/Write — runs tsc --noEmit after .ts/.tsx file edits
+//
+// Only runs if tsconfig.json exists in the project.
+// Async hook — doesn't block the agent, just warns.
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const input = JSON.parse(process.env.CLAUDE_TOOL_INPUT || '{}');
+const filePath = input.file_path || input.filePath || '';
+
+// Only check TypeScript files
+if (!/\.(ts|tsx)$/i.test(filePath)) {
+  process.exit(0);
+}
+
+// Find tsconfig.json by walking up from the file
+let dir = path.dirname(filePath);
+let tsConfigDir = null;
+
+for (let i = 0; i < 10; i++) {
+  if (fs.existsSync(path.join(dir, 'tsconfig.json'))) {
+    tsConfigDir = dir;
+    break;
+  }
+  const parent = path.dirname(dir);
+  if (parent === dir) break;
+  dir = parent;
+}
+
+if (!tsConfigDir) {
+  // No tsconfig.json found — skip
+  process.exit(0);
+}
+
+// Run tsc --noEmit
+try {
+  execSync('npx tsc --noEmit --pretty 2>&1', {
+    cwd: tsConfigDir,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+    timeout: 30000,
+  });
+  // Silent success
+} catch (e) {
+  const output = (e.stdout || e.message || '').trim();
+  const errorLines = output.split('\n').filter(l => /error TS\d+/.test(l));
+  const errorCount = errorLines.length;
+
+  if (errorCount > 0) {
+    console.log(`\n[Rune typecheck] ${errorCount} TypeScript error(s) after editing ${path.basename(filePath)}:`);
+    // Show first 5 errors
+    errorLines.slice(0, 5).forEach(line => {
+      console.log(`  ${line.trim()}`);
+    });
+    if (errorCount > 5) {
+      console.log(`  ... and ${errorCount - 5} more. Run \`npx tsc --noEmit\` for full list.`);
+    }
+    console.log('');
+  }
+}
+
+process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rune-kit/rune",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "58-skill mesh for AI coding assistants — 5-layer architecture, 200+ connections, 8 platforms (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)",
   "type": "module",
   "bin": {
@@ -8,8 +8,14 @@
   },
   "scripts": {
     "build": "node compiler/bin/rune.js build",
-    "doctor": "node compiler/bin/rune.js doctor",
-    "test": "node --test compiler/__tests__/*.test.js"
+    "doctor": "node compiler/bin/rune.js doctor && node scripts/version-sync-check.js",
+    "test": "node --test compiler/__tests__/*.test.js",
+    "lint": "biome check .",
+    "lint:fix": "biome check --fix .",
+    "format": "biome format --write .",
+    "ci": "biome check . && node --test compiler/__tests__/*.test.js && node compiler/bin/rune.js doctor",
+    "version-check": "node scripts/version-sync-check.js",
+    "prepublishOnly": "node scripts/version-sync-check.js"
   },
   "keywords": [
     "claude-code",
@@ -41,10 +47,16 @@
     "extensions/",
     "contexts/",
     "commands/",
-    "agents/"
+    "agents/",
+    "hooks/",
+    "docs/",
+    "references/"
   ],
   "homepage": "https://github.com/rune-kit/rune",
   "bugs": {
     "url": "https://github.com/rune-kit/rune/issues"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.7"
   }
 }

package/references/ui-pro-max-data/LICENSE-UI-PRO-MAX

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Next Level Builder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.