ravensight-playtest 0.5.2 → 0.6.0

package/src/run/trace.js

@@ -0,0 +1,124 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * `trace.jsonl`: what a lockstep persona run actually did to the game, tick by
+ * tick, so it can be played again with no model and compared.
+ *
+ *   {"type":"header","version":1,"engine":"godot","seed":123,"ticks_per_second":60,...}
+ *   {"type":"boot","state":{...}}
+ *   {"type":"step","i":0,"frame":0,"action":"key","args":{...},"events":[...],"ticks":30,"state":{...}}
+ *   {"type":"end","tick":310,"reason":"completed"}
+ *
+ * `frame` is the simulation tick the step began on. It counts ticks the game
+ * was allowed to run and nothing else, so the seconds a persona spent thinking
+ * are not in it. `events` are what the driver was told verbatim, and `state` is
+ * the digest it answered with (see `_state_digest` in the addon).
+ *
+ * Inputs and digests only: never a screenshot, never the persona's reasoning,
+ * never the game's source. A step that typed one of the local brief's secrets
+ * records `redacted` instead of its keys, and a replay stops there rather than
+ * guessing at them.
+ */
+
+export const TRACE_FILE = 'trace.jsonl';
+export const TRACE_VERSION = 1;
+/** The server scans an uploaded text artifact for secrets up to this size. */
+export const MAX_TRACE_BYTES = 2 * 1024 * 1024;
+export const MAX_TRACE_STEPS = 5000;
+
+/**
+ * A stable 31 bit seed from any text, so a run id or a pair index always names
+ * the same seed and a seed fits every integer the engine takes.
+ * @param {string} text
+ * @returns {number}
+ */
+export function seedFrom(text) {
+  return parseInt(createHash('sha256').update(String(text)).digest('hex').slice(0, 8), 16) & 0x7fffffff;
+}
+
+/**
+ * Append only, bounded, and never able to fail a run: a trace that cannot be
+ * written costs the replay of this run and nothing else.
+ *
+ * @param {string} file
+ * @param {{maxBytes?: number, maxSteps?: number}} [limits]
+ */
+export function createTraceWriter(file, { maxBytes = MAX_TRACE_BYTES, maxSteps = MAX_TRACE_STEPS } = {}) {
+  let bytes = 0;
+  let steps = 0;
+  let closed = false;
+  let truncated = false;
+  let chain = Promise.resolve();
+  const append = (line) => {
+    const text = `${JSON.stringify(line)}\n`;
+    bytes += Buffer.byteLength(text);
+    chain = chain.then(() => fs.appendFile(file, text, { mode: 0o600 })).catch(() => {});
+    return chain;
+  };
+  return {
+    file,
+    get truncated() { return truncated; },
+    get steps() { return steps; },
+    async start(header, boot) {
+      await fs.mkdir(path.dirname(file), { recursive: true });
+      await fs.rm(file, { force: true });
+      await append({ type: 'header', version: TRACE_VERSION, ...header });
+      await append({ type: 'boot', state: boot });
+    },
+    async step(entry) {
+      if (closed || truncated) return;
+      const candidate = Buffer.byteLength(JSON.stringify(entry)) + 64;
+      if (steps >= maxSteps || bytes + candidate > maxBytes) {
+        truncated = true;
+        await append({ type: 'truncated', at_step: steps });
+        return;
+      }
+      await append({ type: 'step', i: steps, ...entry });
+      steps += 1;
+    },
+    async end(fields) {
+      if (closed) return;
+      closed = true;
+      await append({ type: 'end', ...fields });
+      await chain;
+    }
+  };
+}
+
+/**
+ * Read and check a trace. Refuses anything that cannot be replayed honestly,
+ * with the reason, rather than replaying part of a file nobody recognises.
+ *
+ * @param {string} text
+ * @returns {{header: Object, boot: Object, steps: Array<Object>, end: Object|null, truncated: boolean}}
+ */
+export function parseTrace(text) {
+  if (Buffer.byteLength(text) > MAX_TRACE_BYTES + 1024) throw new Error('This trace is larger than a replay can read.');
+  const out = { header: null, boot: null, steps: [], end: null, truncated: false };
+  for (const line of String(text).split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { throw new Error('This trace has a line that is not JSON.'); }
+    if (entry.type === 'header') out.header = entry;
+    else if (entry.type === 'boot') out.boot = entry.state;
+    else if (entry.type === 'step') out.steps.push(entry);
+    else if (entry.type === 'end') out.end = entry;
+    else if (entry.type === 'truncated') out.truncated = true;
+  }
+  if (!out.header || out.header.version !== TRACE_VERSION) throw new Error('This is not a trace this CLI can replay.');
+  if (out.header.engine !== 'godot') throw new Error('Only a Godot trace can be replayed.');
+  if (!Number.isInteger(out.header.seed) || !Number.isInteger(out.header.ticks_per_second)) throw new Error('This trace has no seed or tick rate.');
+  for (const step of out.steps) {
+    if (!Number.isInteger(step.ticks) || step.ticks < 1 || !Array.isArray(step.events) && !step.redacted) throw new Error(`Trace step ${step.i} is not valid.`);
+  }
+  return out;
+}
+
+/** @param {string} directory a run directory @returns {Promise<string|null>} */
+export async function findTraceIn(directory) {
+  const file = path.join(directory, TRACE_FILE);
+  const stat = await fs.stat(file).catch(() => null);
+  return stat?.isFile() ? file : null;
+}

package/src/simulation/godotPack.js

@@ -0,0 +1,112 @@
+import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { crc32, deflateRawSync } from 'node:zlib';
+import { allowlistedEnv } from '../run/drivers/godot.js';
+
+/**
+ * Turning one commit of a Godot project into what a hosted comparison plays: a game
+ * pack, with the simulate addon in it, in a ZIP of one file.
+ *
+ * All of this runs on the developer's machine against a throwaway copy of the commit.
+ * The pack holds exported scripts and resources, and no source tree leaves this
+ * machine. Nothing is written to the developer's checkout.
+ */
+
+/** The engine in the hosted guest image. A pack has to come from this version. */
+export const HOSTED_GODOT = '4.5';
+export const PACK_NAME = 'game.pck';
+const PRESET = 'ravensight_simulate';
+const AUTOLOAD_LINE = 'RavensightSimulate="*res://addons/ravensight_simulate/simulate.gd"';
+// Never in a pack, whatever a project's own export settings say.
+const NEVER_EXPORT = 'ravensight_key*.cfg, *.env, .env*, *.pem, *.key, addons/ravensight_driver/*';
+
+export function packagedSimulateAddon() {
+  return path.resolve(import.meta.dirname, '../../addons/ravensight_simulate');
+}
+
+/** project.godot with the addon first among autoloads and stdout flushed per line. */
+export function patchProjectSettings(text) {
+  let out = String(text).replace(/\r\n/g, '\n');
+  if (out.includes(AUTOLOAD_LINE)) return out;
+  // First, so its _ready takes the seed before another autoload can draw a number.
+  out = /^\[autoload\]$/m.test(out)
+    ? out.replace(/^\[autoload\]\n+/m, `[autoload]\n\n${AUTOLOAD_LINE}\n`)
+    : `${out.trimEnd()}\n\n[autoload]\n\n${AUTOLOAD_LINE}\n`;
+  const flush = 'run/flush_stdout_on_print=true';
+  out = out.replace(/^run\/flush_stdout_on_print(\.[a-z]+)?=.*\n/gm, '');
+  out = /^\[application\]$/m.test(out)
+    ? out.replace(/^\[application\]\n+/m, `[application]\n\n${flush}\n`)
+    : `[application]\n\n${flush}\n\n${out}`;
+  return out;
+}
+
+export function exportPreset() {
+  return [
+    '[preset.0]', '', `name="${PRESET}"`, 'platform="Linux"', 'runnable=false', 'dedicated_server=false', 'custom_features=""',
+    'export_filter="all_resources"', 'include_filter=""', `exclude_filter="${NEVER_EXPORT}"`, `export_path="${PACK_NAME}"`, 'script_export_mode=2', '',
+    '[preset.0.options]', '', 'binary_format/embed_pck=false', 'binary_format/architecture="x86_64"', ''
+  ].join('\n');
+}
+
+/** Writes into the throwaway copy only. A symlink in it is never written through. */
+export async function injectSimulate(projectDir, addonDir = packagedSimulateAddon()) {
+  const settings = path.join(projectDir, 'project.godot');
+  const overrideable = async file => { const stat = await fs.lstat(file).catch(() => null); if (stat?.isSymbolicLink()) await fs.unlink(file); };
+  const text = await fs.readFile(settings, 'utf8');
+  await overrideable(settings);
+  await fs.writeFile(settings, patchProjectSettings(text));
+  const presets = path.join(projectDir, 'export_presets.cfg');
+  await overrideable(presets);
+  await fs.writeFile(presets, exportPreset());
+  await overrideable(path.join(projectDir, 'addons'));
+  await fs.mkdir(path.join(projectDir, 'addons'), { recursive: true });
+  await fs.cp(addonDir, path.join(projectDir, 'addons/ravensight_simulate'), { recursive: true, force: true });
+}
+
+/** A ZIP of one deflated file, which is all the worker's archive check needs. */
+export function zipOneFile(name, body) {
+  const data = deflateRawSync(body, { level: 9 });
+  const fileName = Buffer.from(name);
+  const crc = crc32(body);
+  const local = Buffer.alloc(30);
+  local.writeUInt32LE(0x04034b50, 0); local.writeUInt16LE(20, 4); local.writeUInt16LE(8, 8); local.writeUInt32LE(crc, 14);
+  local.writeUInt32LE(data.length, 18); local.writeUInt32LE(body.length, 22); local.writeUInt16LE(fileName.length, 26);
+  const central = Buffer.alloc(46);
+  central.writeUInt32LE(0x02014b50, 0); central.writeUInt16LE(0x0314, 4); central.writeUInt16LE(20, 6); central.writeUInt16LE(8, 10); central.writeUInt32LE(crc, 16);
+  central.writeUInt32LE(data.length, 20); central.writeUInt32LE(body.length, 24); central.writeUInt16LE(fileName.length, 28); central.writeUInt32LE(0o100644 << 16 >>> 0, 38);
+  const end = Buffer.alloc(22);
+  const directoryAt = local.length + fileName.length + data.length;
+  end.writeUInt32LE(0x06054b50, 0); end.writeUInt16LE(1, 8); end.writeUInt16LE(1, 10); end.writeUInt32LE(central.length + fileName.length, 12); end.writeUInt32LE(directoryAt, 16);
+  return Buffer.concat([local, fileName, data, central, fileName, end]);
+}
+
+function runGodot({ godotPath, args, env, spawnFn = spawn, timeoutMs = 300000 }) {
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(godotPath, args, { env, stdio: ['ignore', 'ignore', 'pipe'] });
+    let stderr = '';
+    const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('Godot did not finish exporting in time.')); }, timeoutMs);
+    child.stderr?.on('data', chunk => { stderr = (stderr + chunk).slice(-2000); });
+    child.on('error', error => { clearTimeout(timer); reject(error); });
+    child.on('exit', code => { clearTimeout(timer); code === 0 ? resolve() : reject(new Error(`Godot could not export this commit: ${stderr.trim().slice(-400) || `exit ${code}`}`)); });
+  });
+}
+
+/**
+ * @param {{projectDir: string, godotPath: string, env?: Object, addonDir?: string, spawnFn?: Function}} options
+ * @returns {Promise<{zip: Buffer, sha256: string, bytes: number}>}
+ */
+export async function buildPack({ projectDir, godotPath, env: callerEnv = process.env, addonDir, spawnFn }) {
+  await injectSimulate(projectDir, addonDir);
+  const base = ['--headless', '--path', projectDir];
+  // A commit's editor plugins run in both of these, so they get no token and no key.
+  const env = allowlistedEnv(callerEnv);
+  await runGodot({ godotPath, args: [...base, '--import'], env, spawnFn });
+  const out = path.join(projectDir, PACK_NAME);
+  await runGodot({ godotPath, args: [...base, '--export-pack', PRESET, out], env, spawnFn });
+  const pack = await fs.readFile(out).catch(() => null);
+  if (!pack || pack.subarray(0, 4).toString('latin1') !== 'GDPC') throw new Error('Godot finished, but it did not write a game pack.');
+  const zip = zipOneFile(PACK_NAME, pack);
+  return { zip, sha256: createHash('sha256').update(zip).digest('hex'), bytes: zip.length };
+}

package/src/ui/index.js

@@ -30,9 +30,23 @@ export function setStreams({ out, err } = {}) {
   errStream = err || process.stderr;
 }
 
+/**
+ * Text fit for a terminal. A lot of what this CLI prints was written by a model, a
+ * game or a file in the repository, and a terminal obeys what it is sent: clear the
+ * screen, set the title, write the clipboard, overwrite the line above. Newlines and
+ * tabs stay, and so does this file's own bold.
+ *
+ * @param {*} text
+ * @returns {string}
+ */
+export function printable(text) {
+  /* eslint-disable-next-line no-control-regex */
+  return String(text).replace(/\u001b(?!\[(?:1|22)m)|[\u0000-\u0008\u000b-\u001a\u001c-\u001f\u007f-\u009f]/g, '');
+}
+
 function write(text) {
   if (isQuiet()) return;
-  stream.write(`${text}\n`);
+  stream.write(`${printable(text)}\n`);
 }
 
 export function info(text) {
@@ -49,7 +63,7 @@ export function warn(text) {
 
 /** Errors go to stderr and are printed even in quiet mode: a silent failure is a bug. */
 export function error(text) {
-  errStream.write(`${SYMBOLS.fail} ${text}\n`);
+  errStream.write(`${SYMBOLS.fail} ${printable(text)}\n`);
 }
 
 export function blank() {
@@ -64,13 +78,44 @@ export function json(value) {
 /** Stable JSON, for anything that gets hashed or compared between runs. */
 export const stable = stableStringify;
 
+/**
+ * Words of `text` in lines of at most `width` characters; a word longer than
+ * the width is broken inside itself.
+ * @param {string} text
+ * @param {number} width
+ * @returns {string[]}
+ */
+export function wrapText(text, width) {
+  const lines = [];
+  let current = '';
+  for (const word of String(text).split(/\s+/).filter(Boolean)) {
+    let rest = word;
+    while (rest.length > width) {
+      if (current) { lines.push(current); current = ''; }
+      lines.push(rest.slice(0, width));
+      rest = rest.slice(width);
+    }
+    if (!current) current = rest;
+    else if (current.length + 1 + rest.length <= width) current += ` ${rest}`;
+    else { lines.push(current); current = rest; }
+  }
+  if (current || lines.length === 0) lines.push(current);
+  return lines;
+}
+
+/** The width tables wrap to when the output is not a terminal. */
+export const DEFAULT_TABLE_WIDTH = 100;
+
 /**
  * An aligned table with no borders, which is what fits in a terminal that may
- * be 80 columns wide.
+ * be 80 columns wide. The last column is never padded, and wraps under itself
+ * when a row would run past the terminal: check's login row once listed 17
+ * games inline and padded every other row to the same 900 columns.
  * @param {Array<Object>} rows
  * @param {Array<{key: string, label: string, align?: 'left'|'right'}>} columns
+ * @param {{width?: number}} [options]
  */
-export function table(rows, columns) {
+export function table(rows, columns, options = {}) {
   if (isQuiet()) return;
   const cells = rows.map(row => columns.map(column => {
     const value = row[column.key];
@@ -82,11 +127,18 @@ export function table(rows, columns) {
     0
   ));
   const pad = (text, width, align) => (align === 'right' ? text.padStart(width) : text.padEnd(width));
+  const last = columns.length - 1;
+  const total = Number(options.width) || (stream.columns > 0 ? stream.columns : DEFAULT_TABLE_WIDTH);
+  const indent = widths.slice(0, last).reduce((sum, width) => sum + width + 2, 0);
+  const room = Math.max(20, total - indent);
 
-  write(columns.map((column, i) => pad(column.label, widths[i], column.align)).join('  '));
-  write(widths.map(width => '-'.repeat(width)).join('  '));
+  const line = (texts) => texts.map((text, i) => (i === last ? text : pad(text, widths[i], columns[i].align))).join('  ').trimEnd();
+  write(line(columns.map(column => column.label)));
+  write(line(widths.map((width, i) => '-'.repeat(i === last ? Math.min(width, room) : width))));
   for (const row of cells) {
-    write(row.map((text, i) => pad(text, widths[i], columns[i].align)).join('  '));
+    const wrapped = row[last].length > room ? wrapText(row[last], room) : [row[last]];
+    write(line([...row.slice(0, last), wrapped[0]]));
+    for (const more of wrapped.slice(1)) write(`${' '.repeat(indent)}${more}`);
   }
 }
 
@@ -150,7 +202,7 @@ export async function confirm(question, options = {}) {
 
   const rl = createInterface({ input, output: options.output || stream });
   try {
-    const answer = await rl.question(`${question} [y/N] `);
+    const answer = await rl.question(`${printable(question)} [y/N] `);
     return /^y(es)?$/i.test(answer.trim());
   } finally {
     rl.close();
@@ -175,7 +227,7 @@ export async function choose(question, labels, options = {}) {
   labels.forEach((label, index) => output.write(`  ${index + 1}. ${label}\n`));
   const rl = createInterface({ input, output });
   try {
-    const answer = (await rl.question(`${question} `)).trim();
+    const answer = (await rl.question(`${printable(question)} `)).trim();
     if (!/^\d+$/.test(answer)) return null;
     const index = Number(answer) - 1;
     return index >= 0 && index < labels.length ? index : null;

package/src/upload/allowlist.js

@@ -32,6 +32,9 @@ export const ALLOWED_PATHS = [
   { pattern: /^job-review\.json$/, contentType: 'application/json' },
   { pattern: /^expectations-brief\.json$/, contentType: 'application/json' },
   { pattern: /^next-action-plan\.json$/, contentType: 'application/json' },
+  { pattern: /^validation-report\.json$/, contentType: 'application/json' },
+  { pattern: /^validation-report\.md$/, contentType: 'text/markdown' },
+  { pattern: /^trace\.jsonl$/, contentType: 'application/x-ndjson', optIn: 'trace' },
   { pattern: /^session\.webm$/, contentType: 'video/webm', optIn: 'video' },
   { pattern: /^session\.mp4$/, contentType: 'video/mp4', optIn: 'video' },
   { pattern: /^transcript\.jsonl$/, contentType: 'application/x-ndjson', optIn: 'transcript' }
@@ -39,14 +42,15 @@ export const ALLOWED_PATHS = [
 
 export const TRANSCRIPT_PATH = 'transcript.jsonl';
 export const VIDEO_PATHS = Object.freeze(['session.webm', 'session.mp4']);
+export const TRACE_PATH = 'trace.jsonl';
 
 /**
- * The three paths whose objects carry the `retention=90d` S3 tag, from W8's
+ * The paths whose objects carry the `retention=90d` S3 tag, from W8's
  * `RETENTION_TAGGED_PATHS`. The CLI never computes the tag value itself: the
  * presign response hands back the exact string that was signed. This list is
  * only used to explain, in `--dry-upload` output, which files expire.
  */
-export const RETENTION_TAGGED_PATHS = Object.freeze([...VIDEO_PATHS, TRANSCRIPT_PATH]);
+export const RETENTION_TAGGED_PATHS = Object.freeze([...VIDEO_PATHS, TRANSCRIPT_PATH, TRACE_PATH]);
 
 /**
  * The only three artifacts that belong to a job rather than to one of its runs,

package/src/upload/index.js

@@ -233,8 +233,8 @@ export async function putFile(options) {
  * honest reading of the one it has is "include the opt in artifacts", and that
  * is what is sent.
  */
-function presignWith({ api, gameId, jobId, runId, includeVideo, includeTranscript }) {
-  const includeOptIn = Boolean(includeVideo) || Boolean(includeTranscript);
+function presignWith({ api, gameId, jobId, runId, includeVideo, includeTranscript, includeTrace }) {
+  const includeOptIn = Boolean(includeVideo) || Boolean(includeTranscript) || Boolean(includeTrace);
   return files => (runId
     ? api.runs.uploads(gameId, jobId, runId, { files, includeVideo: includeOptIn })
     : api.jobs.uploads(gameId, jobId, { files }));
@@ -274,7 +274,7 @@ function presignWith({ api, gameId, jobId, runId, includeVideo, includeTranscrip
 export async function uploadRunDir(runDir, options) {
   const {
     api, gameId, jobId, runId = null,
-    includeVideo = false, includeTranscript = false,
+    includeVideo = false, includeTranscript = false, includeTrace = false,
     dryRun = false, force = false, only = null, allowedPaths = null, exclude = null, excludeReason = 'excluded',
     onFile, repoRoot, fetch: fetchImpl, sleep
   } = options;
@@ -283,6 +283,7 @@ export async function uploadRunDir(runDir, options) {
   const plan = await planRunDir(runDir, {
     video: includeVideo,
     transcript: includeTranscript,
+    trace: includeTrace,
     allowedPaths
   });
   let files = plan.files;
@@ -328,7 +329,7 @@ export async function uploadRunDir(runDir, options) {
     return { uploaded: [], skipped, bytes: 0, dryRun: false };
   }
 
-  const presign = presignWith({ api, gameId, jobId, runId, includeVideo, includeTranscript });
+  const presign = presignWith({ api, gameId, jobId, runId, includeVideo, includeTranscript, includeTrace });
   const request = files.map(({ path, size, sha256, content_type: contentType }) => ({
     path, size, sha256, content_type: contentType
   }));

package/templates/godot-2d/README.md

@@ -0,0 +1,36 @@
+# __GAME_NAME__
+
+A placeholder prototype made with `ravensight-playtest create` (Experimental). The
+design is in `DESIGN.md`. Every visual is a placeholder primitive, and your own art
+and audio replace them.
+
+## Run it
+
+Open this folder in Godot 4, or run `godot --path .`. Move with WASD or the arrow
+keys, use Space or E for the game's action, and Esc for settings.
+
+`godot --headless --path . --script tools/selftest.gd` checks the parts a game
+depends on.
+
+## Analytics
+
+The Ravensight SDK (`addons/ravensight/Ravensight.gd`, MIT, unmodified) is an autoload.
+Report events with `Telemetry.track(name, data, kind)`, where `kind` is `level_start`,
+`level_complete`, `death` or `none`. It always sets `rs_kind`, so an event's name is
+never used to guess what it means.
+
+- **The key.** `ravensight_key.cfg` is this game's development key. It is ignored by
+  git. `scripts/autoload/game_config.gd` says where else a key can come from.
+- **The opt-out.** Esc opens settings, and "Share anonymous analytics" is the player's
+  own choice. The SDK saves it and honours it on every later run.
+- **A build anyone can download.** Use a public key, the one that starts `gt_pub_`, so
+  it is written only into the build:
+
+      RAVENSIGHT_RELEASE_KEY=gt_pub_... sh tools/inject_release_key.sh godot --headless --export-release Web build/web/index.html
+
+## How a playtest reads the game
+
+`scripts/state_hook.gd` is in the `ravensight_state` group, and its
+`_ravensight_state()` answer is what a persona sees and a replay compares. Call
+`GameState.complete_core_loop()` once for each pass of the core loop: it is what the
+playable check reads.

package/templates/godot-2d/addons/ravensight/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Reality Software Entertainment
+
+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.