titanpl 6.0.0 → 7.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "titanpl",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "Titan Planet is a JavaScript-first backend framework that embeds JS actions into a Rust + Axum server and ships as a single native binary. Routes are compiled to static metadata; only actions run in the embedded JS runtime. No Node.js. No event loop in production.",
   "license": "ISC",
   "author": "ezetgalaxy",
@@ -12,10 +12,6 @@
     "t8n-dev": "node ../../packages/cli/index.js",
     "test-start": "taskkill /f /im titan-server.exe; ../../engine/target/release/titan-server.exe run dist"
   },
-  "workspaces": [
-    "packages/*",
-    "test-apps/*"
-  ],
   "files": [
     "index.js",
     "packages/",
@@ -78,7 +74,7 @@
     "test:all": "vitest run && vitest run --config vitest.config.e2e.ts"
   },
   "dependencies": {
-    "@titanpl/core": "latest",
+    "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest",
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2",

package/packages/cli/index.js

@@ -11,6 +11,10 @@ import { migrateCommand } from "./src/commands/migrate.js";
 import { updateCommand } from "./src/commands/update.js";
 import { initCommand } from "./src/commands/init.js";
 
+import { createCommand } from "./src/commands/create.js";
+import { buildExtensionCommand } from "./src/commands/build-ext.js";
+import { runExtensionCommand } from "./src/commands/run-ext.js";
+
 /* -------------------------------------------------------
  * Resolve __dirname (ESM safe)
  * ----------------------------------------------------- */
@@ -54,6 +58,7 @@ ${bold(cyan("╰─────────────────────
     ${cyan("init")}      ${gray("Scaffold a new Titan project")}
     ${cyan("create")}    ${gray("Create a new project or extension (e.g. 'titan create ext my-ext')")}
     ${cyan("build")}     ${gray("Compile actions and build production dist. Use --release or -r for a production-ready folder.")}
+    ${cyan("run")}       ${gray("Run the production Gravity Engine or an extension sandbox")}
     ${cyan("dev")}       ${gray("Start the Gravity Engine in dev/watch mode")}
     ${cyan("start")}     ${gray("Start the production Gravity Engine")}
     ${cyan("update")}    ${gray("Update an existing project to latest Titan version")}
@@ -112,26 +117,35 @@ const cmd = process.argv[2];
       case "create": {
         const type = process.argv[3];
         const name = process.argv[4];
-        if (type === "ext" || type === "extension") {
-          await initCommand(name, "extension");
-        } else {
-          // Fallback to init behavior
-          await initCommand(type, null);
-        }
+        await createCommand(type, name);
         break;
       }
 
-      case "build":
-        const isRelease = process.argv.includes("--release") || process.argv.includes("-r");
-        console.log(cyan(`→ Building Titan project${isRelease ? " (Release mode)" : ""}...`));
-        await buildCommand(isRelease);
-        console.log(green(`✔ ${isRelease ? "Release" : "Build"} complete`));
+      case "build": {
+        if (process.argv[3] === "ext" || process.argv[3] === "extension") {
+          await buildExtensionCommand();
+        } else {
+          const isRelease = process.argv.includes("--release") || process.argv.includes("-r");
+          console.log(cyan(`→ Building Titan project${isRelease ? " (Release mode)" : ""}...`));
+          await buildCommand(isRelease);
+          console.log(green(`✔ ${isRelease ? "Release" : "Build"} complete`));
+        }
         break;
+      }
 
       case "dev":
         await devCommand();
         break;
 
+      case "run":
+        if (process.argv[3] === "ext" || process.argv[3] === "extension") {
+          await runExtensionCommand();
+        } else {
+          console.log(cyan("→ Starting Titan Server..."));
+          startCommand();
+        }
+        break;
+
       case "start":
         console.log(cyan("→ Starting Titan Server..."));
         startCommand();

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/cli",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "The unified CLI for Titan Planet. Use it to create, manage, build, and deploy high-performance backend projects.",
   "keywords": [
     "titanpl",
@@ -29,11 +29,11 @@
     "tit": "./index.js"
   },
   "optionalDependencies": {
-    "@titanpl/engine-win32-x64": "6.0.0",
-    "@titanpl/engine-linux-x64": "6.0.0"
+    "@titanpl/engine-win32-x64": "7.0.0",
+    "@titanpl/engine-linux-x64": "7.0.0"
   },
   "dependencies": {
-    "@titanpl/packet": "6.0.0",
+    "@titanpl/packet": "7.0.0",
     "prompts": "^2.4.2",
     "commander": "^11.0.0",
     "chalk": "^4.1.2"

package/packages/cli/src/commands/build-ext.js

@@ -0,0 +1,157 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+export async function buildExtensionCommand() {
+    const titanJsonPath = path.join(process.cwd(), 'titan.json');
+    if (!fs.existsSync(titanJsonPath)) {
+        console.log(chalk.red("✖ No titan.json found in current directory."));
+        return;
+    }
+
+    const titanJson = JSON.parse(fs.readFileSync(titanJsonPath, 'utf8'));
+    const type = titanJson.type;
+
+    if (type === 'js') {
+        console.log(chalk.yellow("! JS-only extensions do not require a build step."));
+        return;
+    }
+
+    console.log(chalk.cyan(`\n→ Building ${type.toUpperCase()} extension '${titanJson.name}'...\n`));
+
+    if (type === 'wasm') {
+        await buildWasmExtension(titanJson);
+    } else if (type === 'native') {
+        await buildNativeExtension(titanJson);
+    }
+}
+
+async function buildWasmExtension(titanJson) {
+    const nativeDir = path.join(process.cwd(), 'native');
+    if (!fs.existsSync(nativeDir)) {
+        console.log(chalk.red("✖ native/ directory not found."));
+        return;
+    }
+
+    console.log(chalk.gray("  Compiling Rust to WebAssembly..."));
+    try {
+        // We assume wasm-pack or similar is used, or just bare cargo with wasm32 target
+        // The spec mentions: native/pkg/my_ext.wasm, which is wasm-pack's default
+        execSync('wasm-pack build --target web', { cwd: nativeDir, stdio: 'inherit' });
+    } catch (err) {
+        console.log(chalk.red("✖ Wasm compilation failed. Make sure 'wasm-pack' is installed."));
+        return;
+    }
+
+    console.log(chalk.gray("  Generating bindings..."));
+    const libRsPath = path.join(nativeDir, 'src/lib.rs');
+    const libRs = fs.readFileSync(libRsPath, 'utf8');
+    
+    const exports = [];
+    const exportRegex = /#\[titan::export\]\s+pub\s+fn\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*([^\{]+))?/g;
+    let match;
+    while ((match = exportRegex.exec(libRs)) !== null) {
+        const name = match[1];
+        const paramsRaw = match[2];
+        const params = paramsRaw.split(',').map(p => p.trim().split(':')[0].trim()).filter(p => p);
+        exports.push({ name, params });
+    }
+
+    const bindingsJs = `// Auto-generated by titan build ext
+import * as wasm from './my_ext_bg.wasm';
+export const { ${exports.map(e => e.name).join(', ')} } = wasm;
+`;
+    
+    const pkgDir = path.join(nativeDir, 'pkg');
+    fs.writeFileSync(path.join(pkgDir, 'bindings.js'), bindingsJs);
+
+    // Update index.js
+    const indexJs = `import { registerExtension } from './utils/registerExtension.js';
+import * as native from './native/pkg/bindings.js';
+
+const myExt = {
+    ${exports.map(e => `${e.name}: (${e.params.join(', ')}) => native.${e.name}(${e.params.join(', ')})`).join(',\n    ')}
+};
+
+registerExtension("${titanJson.name.split('/').pop()}", myExt);
+`;
+    fs.writeFileSync(path.join(process.cwd(), 'index.js'), indexJs);
+
+    // Update titan.json
+    titanJson.wasm = "native/pkg/my_ext_bg.wasm";
+    titanJson.bindings = "native/pkg/bindings.js";
+    fs.writeFileSync(path.join(process.cwd(), 'titan.json'), JSON.stringify(titanJson, null, 2));
+
+    console.log(chalk.green("✔ Wasm build complete."));
+}
+
+async function buildNativeExtension(titanJson) {
+    const nativeDir = path.join(process.cwd(), 'native');
+    if (!fs.existsSync(nativeDir)) {
+        console.log(chalk.red("✖ native/ directory not found."));
+        return;
+    }
+
+    console.log(chalk.gray("  Compiling Rust native library..."));
+    try {
+        execSync('cargo build --release', { cwd: nativeDir, stdio: 'inherit' });
+    } catch (err) {
+        console.log(chalk.red("✖ Native compilation failed."));
+        return;
+    }
+
+    const libName = titanJson.name.split('/').pop().replace(/-/g, '_');
+    const isWindows = process.platform === 'win32';
+    const isMac = process.platform === 'darwin';
+    
+    let binName = `lib${libName}.so`;
+    if (isWindows) binName = `${libName}.dll`;
+    if (isMac) binName = `lib${libName}.dylib`;
+
+    const buildDir = path.join(nativeDir, 'build');
+    if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir);
+
+    const targetDir = path.join(nativeDir, 'target/release');
+    const srcPath = path.join(targetDir, binName);
+    const destPath = path.join(buildDir, binName);
+
+    if (fs.existsSync(srcPath)) {
+        fs.copyFileSync(srcPath, destPath);
+    }
+
+    // Parse exports for index.js
+    const libRsPath = path.join(nativeDir, 'src/lib.rs');
+    const libRs = fs.readFileSync(libRsPath, 'utf8');
+    const exports = [];
+    const exportRegex = /#\[titan::native_export\]\s+pub\s+extern\s+"C"\s+fn\s+(\w+)\s*\(([^)]*)\)/g;
+    let match;
+    while ((match = exportRegex.exec(libRs)) !== null) {
+        const name = match[1];
+        const paramsRaw = match[2];
+        const params = paramsRaw.split(',').map(p => p.trim().split(':')[0].trim()).filter(p => p);
+        exports.push({ name, params });
+    }
+
+    // Update index.js
+    const indexJs = `import { registerExtension } from './utils/registerExtension.js';
+
+// native bindings are injected by Gravity's NativeHost IPC bridge
+const myExt = {
+    ${exports.map(e => `${e.name}: (${e.params.join(', ')}) => t.__native.call("${titanJson.name}", "${e.name}", [${e.params.join(', ')}])`).join(',\n    ')}
+};
+
+registerExtension("${titanJson.name.split('/').pop()}", myExt);
+`;
+    fs.writeFileSync(path.join(process.cwd(), 'index.js'), indexJs);
+
+    // Update titan.json
+    titanJson.native = {
+        linux: `native/build/lib${libName}.so`,
+        windows: `native/build/${libName}.dll`,
+        macos: `native/build/lib${libName}.dylib`
+    };
+    fs.writeFileSync(path.join(process.cwd(), 'titan.json'), JSON.stringify(titanJson, null, 2));
+
+    console.log(chalk.green("✔ Native build complete."));
+}

package/packages/cli/src/commands/build.js

@@ -1,7 +1,19 @@
 import { build, release } from "@titanpl/packet";
+import fs from 'fs';
+import path from 'path';
 
 export async function buildCommand(isRelease = false) {
   const buildFn = isRelease ? release : build;
   const dist = await buildFn(process.cwd());
+
+  const tanfigPath = path.join(process.cwd(), 'tanfig.json');
+  if (fs.existsSync(tanfigPath)) {
+    fs.copyFileSync(tanfigPath, path.join(dist, 'tanfig.json'));
+  }
+  const pkgPath = path.join(process.cwd(), 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    fs.copyFileSync(pkgPath, path.join(dist, 'package.json'));
+  }
+
   console.log(`✔ ${isRelease ? 'Release' : 'Build'} complete →`, dist);
 }

package/packages/cli/src/commands/create.js

@@ -0,0 +1,160 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import { copyDir } from './init.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function createCommand(type, name) {
+    if (type === 'ext' || type === 'extension') {
+        await createExtension(name);
+    } else {
+        console.log(chalk.red(`\n✖ Unknown creation type: ${type}`));
+        console.log(chalk.gray(`  Available types: ext\n`));
+    }
+}
+
+async function createExtension(extensionName) {
+    let name = extensionName;
+    if (!name) {
+        const res = await prompts({
+            type: 'text',
+            name: 'name',
+            message: 'Extension name:',
+            initial: 'my-ext'
+        });
+        name = res.name;
+    }
+
+    if (!name) {
+        console.log(chalk.red("✖ Extension name is required."));
+        return;
+    }
+
+    const res = await prompts({
+        type: 'select',
+        name: 'type',
+        message: 'What type of extension do you want to create?',
+        choices: [
+            { title: 'js      — JavaScript only, zero build step, always safe', value: 'js' },
+            { title: 'wasm    — Rust compiled to WebAssembly, sandboxed, auto-bound', value: 'wasm' },
+            { title: 'native  — Rust compiled to .so/.dll, out-of-process, requires allowNative', value: 'native' },
+        ],
+        initial: 0
+    });
+
+    const extType = res.type;
+    if (!extType) return;
+
+    const targetDir = path.resolve(process.cwd(), name);
+    if (fs.existsSync(targetDir)) {
+        console.log(chalk.red(`\n✖ Directory '${name}' already exists.\n`));
+        return;
+    }
+
+    // Find template path (similar to init.js)
+    let templateDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'extension');
+    if (!fs.existsSync(templateDir)) {
+        templateDir = path.resolve(__dirname, '..', '..', 'templates', 'extension');
+    }
+
+    console.log(chalk.cyan(`\n→ Creating ${extType.toUpperCase()} extension '${name}'...\n`));
+
+    if (extType === 'js') {
+        try {
+            console.log(chalk.gray(`  Cloning JS template from https://github.com/t8nlab/extTemplate.git...`));
+            const { execSync } = await import('child_process');
+            execSync(`git clone https://github.com/t8nlab/extTemplate.git "${targetDir}"`, { stdio: 'pipe' });
+            // Remove git history
+            fs.rmSync(path.join(targetDir, '.git'), { recursive: true, force: true });
+        } catch (err) {
+            console.log(chalk.yellow(`  Git clone failed, falling back to local template...`));
+            copyDir(templateDir, targetDir);
+        }
+    } else {
+        // 1. Copy the source template
+        copyDir(templateDir, targetDir);
+    }
+
+    // 2. Perform transformations
+    transformExtension(targetDir, name, extType);
+
+    console.log(chalk.green(`\n✔ Extension '${name}' created successfully!`));
+    console.log(chalk.yellow(`  cd ${name}`));
+    if (extType !== 'js') {
+        console.log(chalk.yellow(`  titan build ext`));
+    }
+    console.log(chalk.yellow(`  titan run ext\n`));
+}
+
+function transformExtension(target, name, type) {
+    // 1. Remove optional native folder if it's a JS extension
+    if (type === 'js') {
+        const nativeDir = path.join(target, 'native');
+        if (fs.existsSync(nativeDir)) {
+            fs.rmSync(nativeDir, { recursive: true, force: true });
+        }
+    }
+
+    // 2. Patch package.json
+    const pkgPath = path.join(target, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        pkg.name = name;
+        pkg.version = "1.0.0";
+        // Ensure dependencies
+        pkg.dependencies = pkg.dependencies || {};
+        pkg.dependencies["@titanpl/sdk"] = "2.0.0";
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+    }
+
+    // 3. Patch titan.json
+    const titanPath = path.join(target, 'titan.json');
+    if (fs.existsSync(titanPath)) {
+        const titan = JSON.parse(fs.readFileSync(titanPath, 'utf8'));
+        titan.name = name;
+        titan.type = type;
+        titan.version = "1.0.0";
+        fs.writeFileSync(titanPath, JSON.stringify(titan, null, 2));
+    }
+
+    // 4. Cleanup git if it exists accidentally
+    const gitDir = path.join(target, '.git');
+    if (fs.existsSync(gitDir)) {
+        fs.rmSync(gitDir, { recursive: true, force: true });
+    }
+
+    // 5. Recursive template substitution for any {{name}} in files
+    substituteTemplates(target, name);
+}
+
+function substituteTemplates(dir, name) {
+    for (const file of fs.readdirSync(dir)) {
+        const fullPath = path.join(dir, file);
+        if (fs.lstatSync(fullPath).isDirectory()) {
+            substituteTemplates(fullPath, name);
+        } else {
+            const ext = path.extname(file).toLowerCase();
+            const textExts = ['.js', '.ts', '.json', '.md', '.txt', '.rs', '.toml', '.html', '.css', '.d.ts'];
+            if (textExts.includes(ext)) {
+                let content = fs.readFileSync(fullPath, 'utf8');
+                let changed = false;
+                if (content.includes("{{name}}")) {
+                    content = content.replace(/{{name}}/g, name);
+                    changed = true;
+                }
+                if (content.includes("workspace:*")) {
+                    content = content.replace(/"@titanpl\/sdk": "workspace:\*"/g, '"@titanpl/sdk": "2.0.0"');
+                    content = content.replace(/workspace:\*/g, "6.0.0");
+                    changed = true;
+                }
+                if (changed) {
+                    fs.writeFileSync(fullPath, content);
+                }
+            }
+        }
+    }
+}

package/packages/cli/src/commands/init.js

@@ -176,17 +176,7 @@ export async function initCommand(projectName, templateName) {
         }
     }
 
-    // 4. Ensure tanfig.json exists with default build config
-    const tanfigPath = path.join(target, "tanfig.json");
-    if (!fs.existsSync(tanfigPath)) {
-        const defaultConfig = {
-            name: projName,
-            build: {
-                files: ["public", "static", "db", "config"]
-            }
-        };
-        fs.writeFileSync(tanfigPath, JSON.stringify(defaultConfig, null, 2));
-    }
+    // 4. Substitution is handled below by substitute()
 
 
     // Recursive template substitution
@@ -212,6 +202,10 @@ export async function initCommand(projectName, templateName) {
                         content = content.replace(/{{native_name}}/g, projName.replace(/-/g, '_'));
                         changed = true;
                     }
+                    if (content.includes("workspace:*")) {
+                        content = content.replace(/workspace:\*/g, "6.0.0");
+                        changed = true;
+                    }
                     if (changed) {
                         fs.writeFileSync(fullPath, content);
                     }

package/packages/cli/src/commands/run-ext.js

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import http from 'node:http';
+
+/**
+ * Runs the extension sandbox using a native Node.js server (zero dependencies).
+ */
+export async function runExtensionCommand() {
+    const titanJsonPath = path.join(process.cwd(), 'titan.json');
+    if (!fs.existsSync(titanJsonPath)) {
+        console.log(chalk.red("✖ No titan.json found in current directory."));
+        return;
+    }
+
+    const titanJson = JSON.parse(fs.readFileSync(titanJsonPath, 'utf8'));
+    const port = 3000;
+
+    const server = http.createServer((req, res) => {
+        if (req.url === '/test' && req.method === 'GET') {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(`
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Titan Extension Sandbox - ${titanJson.name}</title>
+    <style>
+        body { font-family: 'Inter', sans-serif; background: #0f172a; color: #f8fafc; padding: 2rem; margin: 0; }
+        .container { max-width: 800px; margin: 0 auto; }
+        .card { background: #1e293b; padding: 2rem; border-radius: 1rem; border: 1px solid #334155; box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.3); }
+        h1 { color: #38bdf8; margin-top: 0; display: flex; align-items: center; gap: 1rem; }
+        .badge { background: #0ea5e9; color: white; padding: 0.2rem 0.6rem; border-radius: 9999px; font-size: 0.75rem; text-transform: uppercase; letter-spacing: 0.05em; }
+        .method-list { margin-top: 2rem; }
+        .method-item { background: #334155; padding: 1rem; margin-bottom: 1rem; border-radius: 0.5rem; display: flex; justify-content: space-between; align-items: center; }
+        .method-name { font-family: monospace; font-weight: bold; color: #7dd3fc; }
+        button { background: #38bdf8; color: #0f172a; border: none; padding: 0.5rem 1.25rem; border-radius: 0.375rem; cursor: pointer; font-weight: 600; transition: all 0.2s; }
+        button:hover { background: #7dd3fc; transform: translateY(-1px); }
+        .output-container { margin-top: 2rem; }
+        pre { background: #020617; padding: 1.5rem; border-radius: 0.5rem; border: 1px solid #1e293b; color: #10b981; overflow-x: auto; font-family: 'Fira Code', monospace; line-height: 1.5; }
+        .log-entry { margin-bottom: 0.5rem; }
+        .status-ok { color: #10b981; }
+        .status-call { color: #fbbf24; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="card">
+            <h1>
+                Extension Sandbox 
+                <span class="badge">${titanJson.type}</span>
+            </h1>
+            <p>Testing extension: <code style="color: #38bdf8;">${titanJson.name}</code> v${titanJson.version}</p>
+            
+            <div class="method-list">
+                <div class="method-item">
+                    <span class="method-name">hello()</span>
+                    <button onclick="callMethod('hello', [])">Invoke</button>
+                </div>
+                <!-- Dynamic methods would be listed here -->
+            </div>
+
+            <div class="output-container">
+                <h3>Live Output Log</h3>
+                <pre id="output"><div class="log-entry status-ok">[System] Sandbox ready at localhost:${port}</div></pre>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const output = document.getElementById('output');
+        function log(msg, type = 'ok') {
+            const entry = document.createElement('div');
+            entry.className = 'log-entry status-' + type;
+            entry.textContent = \`[\${new Date().toLocaleTimeString()}] \${msg}\`;
+            output.appendChild(entry);
+            output.scrollTop = output.scrollHeight;
+        }
+
+        async function callMethod(name, args) {
+            log(\`Calling \${name}...\`, 'call');
+            try {
+                // In a real sandbox this would fetch a /call endpoint
+                const res = "Hello from ${titanJson.name}!";
+                log(\`Result: \${JSON.stringify(res)}\`, 'ok');
+            } catch (e) {
+                log(\`Error: \${e.message}\`, 'error');
+            }
+        }
+    </script>
+</body>
+</html>`);
+        } else {
+            res.writeHead(404);
+            res.end('Not Found');
+        }
+    });
+
+    server.listen(port, () => {
+        console.log(chalk.cyan(`\n🪐 Titan Extension Sandbox running at:`));
+        console.log(chalk.bold(`  http://localhost:${port}/test\n`));
+        console.log(chalk.gray(`  Press Ctrl+C to stop.\n`));
+    });
+}

package/{titanpl-sdk → packages/core-source}/LICENSE

@@ -12,4 +12,4 @@ MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.