@gajae-code/coding-agent 0.17.1 → 0.17.4

package/src/utils/git.ts

@@ -805,10 +805,18 @@ export const status = Object.assign(
 // ════════════════════════════════════════════════════════════════════════════
 
 export const stage = {
-	/** Stage files. Empty array stages all (`git add -A`). */
-	async files(cwd: string, files: readonly string[] = [], signal?: AbortSignal): Promise<void> {
+	/**
+	 * Stage files. Empty array stages all (`git add -A`). Accepts a bare signal or
+	 * `{ env, signal }`; `env` exists so a caller can stage into an isolated
+	 * `GIT_INDEX_FILE` instead of the repository's real index.
+	 */
+	async files(
+		cwd: string,
+		files: readonly string[] = [],
+		options: AbortSignal | Pick<CommandOptions, "env" | "signal"> = {},
+	): Promise<void> {
 		const args = files.length === 0 ? ["add", "-A"] : ["add", "--", ...files];
-		await runEffect(cwd, args, { signal });
+		await runEffect(cwd, args, options instanceof AbortSignal ? { signal: options } : options);
 	},
 
 	/** Selectively stage hunks from the provided diff or the current working tree diff. */
@@ -902,6 +910,28 @@ export async function writeTree(cwd: string, options: Pick<CommandOptions, "env"
 	return (await runText(cwd, ["write-tree"], options)).trim();
 }
 
+export interface CommitTreeOptions {
+	readonly env?: Record<string, string | undefined>;
+	readonly parents?: readonly string[];
+	readonly signal?: AbortSignal;
+}
+
+/**
+ * Create a commit object from an existing tree and return its SHA. Plumbing:
+ * unlike `commit` this touches neither the index nor any ref, and runs no
+ * `pre-commit`/`commit-msg` hook.
+ */
+export async function commitTree(
+	cwd: string,
+	tree: string,
+	message: string,
+	options: CommitTreeOptions = {},
+): Promise<string> {
+	const args = ["commit-tree", tree];
+	for (const parent of options.parents ?? []) args.push("-p", parent);
+	return (await runText(cwd, args, { env: options.env, signal: options.signal, stdin: message })).trim();
+}
+
 // ════════════════════════════════════════════════════════════════════════════
 // API: show
 // ════════════════════════════════════════════════════════════════════════════
@@ -1075,6 +1105,26 @@ export const ref = {
 		return result.stdout.trim() || null;
 	},
 
+	/**
+	 * Move a ref to `newValue`, but only while it still holds `expectedOldValue`
+	 * (the empty string asserts the ref does not exist yet). Git verifies the old
+	 * value and writes the new one under its own ref lock, so this is an atomic
+	 * compare-and-swap: a concurrent writer that moved the ref first makes this
+	 * throw instead of silently clobbering their commit.
+	 */
+	async update(
+		cwd: string,
+		refName: string,
+		newValue: string,
+		expectedOldValue: string,
+		options: { reason?: string; signal?: AbortSignal } = {},
+	): Promise<void> {
+		const args = ["update-ref"];
+		if (options.reason) args.push("-m", options.reason);
+		args.push(refName, newValue, expectedOldValue);
+		await runEffect(cwd, args, { signal: options.signal });
+	},
+
 	/** Tags pointing at a ref. */
 	async tags(cwd: string, refName = "HEAD", signal?: AbortSignal): Promise<string[]> {
 		return splitLines(

package/src/utils/markit.ts

@@ -1,7 +1,7 @@
 import { untilAborted } from "@gajae-code/utils";
-import type { Markit, StreamInfo } from "markit-ai";
+import type { Markit, StreamInfo } from "../../vendor/markit-ai/dist/index.js";
 import { ToolAbortError } from "../tools/tool-errors";
-import { ensureMupdfWasmResolution } from "./mupdf-wasm";
+import { prepareMuPdf, sanitizeMuPdfDiagnostic, withMuPdfDiagnostic } from "./mupdf";
 
 export interface MarkitConversionResult {
 	content: string;
@@ -9,20 +9,23 @@ export interface MarkitConversionResult {
 	error?: string;
 }
 
-let markit: () => Markit | Promise<Markit> = async () => {
-	const promise = import("markit-ai").then(({ Markit }) => {
-		const instance = new Markit();
-		markit = () => instance;
-		return instance;
-	});
-	markit = () => promise;
-	return promise;
-};
+let instance: Markit | undefined;
+let instancePromise: Promise<Markit> | undefined;
 
-// #5433: mupdf's wasm asset is not reachable at the Emscripten loader's
-// default bunfs path in compiled binaries. Seed the embedded-asset hook
-// before any markit conversion (and therefore before any mupdf import).
-ensureMupdfWasmResolution();
+async function loadMarkit(): Promise<Markit> {
+	if (instancePromise === undefined) {
+		instancePromise = import("../../vendor/markit-ai/dist/index.js")
+			.then(({ Markit: MarkitConstructor }) => {
+				instance = new MarkitConstructor();
+				return instance;
+			})
+			.catch(error => {
+				instancePromise = undefined;
+				throw error;
+			});
+	}
+	return instancePromise;
+}
 
 function normalizeExtension(extension: string): string {
 	const trimmed = extension.trim().toLowerCase();
@@ -30,33 +33,27 @@ function normalizeExtension(extension: string): string {
 	return trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
 }
 
-function normalizeError(error: unknown): string {
-	if (error instanceof Error && error.message.trim().length > 0) {
-		return error.message.trim();
-	}
-	return "Conversion failed";
-}
-
-/**
- * markit-ai's PDF converter swallows the real mupdf import failure behind a
- * generic "Install it" message (#5433). Re-run the import here so release
- * diagnostics carry the actual module/asset/initialization error.
- */
-async function describeConversionError(error: unknown): Promise<string> {
-	const base = normalizeError(error);
-	if (!base.includes("PDF support requires 'mupdf'")) return base;
-	try {
-		await import("mupdf");
-	} catch (cause) {
-		return `${base} (mupdf import failed: ${normalizeError(cause)})`;
+function normalizeError(error: unknown, pdf = false): string {
+	const messages: string[] = [];
+	const seen = new Set<unknown>();
+	while (error !== undefined && !seen.has(error)) {
+		seen.add(error);
+		if (error instanceof Error) {
+			const message = `${error.name}: ${error.message}`;
+			messages.push(pdf ? sanitizeMuPdfDiagnostic(message) : message);
+			error = error.cause;
+		} else {
+			messages.push(pdf ? sanitizeMuPdfDiagnostic(String(error)) : String(error));
+			break;
+		}
 	}
-	return base;
+	return messages.join("; caused by: ") || "Conversion failed";
 }
 
 async function runMarkitConversion<T>(task: (markit: Markit) => Promise<T>, signal?: AbortSignal): Promise<T> {
 	try {
-		const instance = await markit();
-		return signal ? await untilAborted(signal, () => task(instance)) : await task(instance);
+		const markit = instance ?? (await loadMarkit());
+		return signal ? await untilAborted(signal, () => task(markit)) : await task(markit);
 	} catch (error) {
 		if (error instanceof ToolAbortError) {
 			throw error;
@@ -78,13 +75,22 @@ function finalizeConversion(markdown?: string): MarkitConversionResult {
 
 export async function convertFileWithMarkit(filePath: string, signal?: AbortSignal): Promise<MarkitConversionResult> {
 	try {
-		const result = await runMarkitConversion(markit => markit.convertFile(filePath), signal);
+		if (filePath.toLowerCase().endsWith(".pdf")) await prepareMuPdf();
+		const result = await runMarkitConversion(async markit => {
+			return markit.convertFile(filePath);
+		}, signal);
 		return finalizeConversion(result.markdown);
 	} catch (error) {
 		if (error instanceof ToolAbortError) {
 			throw error;
 		}
-		return { content: "", ok: false, error: await describeConversionError(error) };
+		return {
+			content: "",
+			ok: false,
+			error: filePath.toLowerCase().endsWith(".pdf")
+				? normalizeError(withMuPdfDiagnostic(error), true)
+				: normalizeError(error),
+		};
 	}
 }
 
@@ -100,12 +106,20 @@ export async function convertBufferWithMarkit(
 	};
 
 	try {
-		const result = await runMarkitConversion(markit => markit.convert(Buffer.from(buffer), streamInfo), signal);
+		if (normalizedExtension === ".pdf") await prepareMuPdf();
+		const result = await runMarkitConversion(async markit => {
+			return markit.convert(Buffer.from(buffer), streamInfo);
+		}, signal);
 		return finalizeConversion(result.markdown);
 	} catch (error) {
 		if (error instanceof ToolAbortError) {
 			throw error;
 		}
-		return { content: "", ok: false, error: await describeConversionError(error) };
+		return {
+			content: "",
+			ok: false,
+			error:
+				normalizedExtension === ".pdf" ? normalizeError(withMuPdfDiagnostic(error), true) : normalizeError(error),
+		};
 	}
 }

package/src/utils/mupdf-assets.d.ts

@@ -0,0 +1,4 @@
+declare module "*.wasm" {
+	const assetPath: string;
+	export default assetPath;
+}

package/src/utils/mupdf-embedded.ts

@@ -0,0 +1,4 @@
+// AUTOGENERATED FILE -- DO NOT EDIT DIRECTLY
+// See scripts/embed-mupdf.ts. Source installs resolve the package lazily.
+export const embeddedMuPdfWasm: string | undefined = undefined;
+export const embeddedMuPdfModule: string | undefined = undefined;

package/src/utils/mupdf-wasm-embedded.ts

@@ -0,0 +1,3 @@
+import mupdfWasmPath from "../../../../node_modules/mupdf/dist/mupdf-wasm.wasm" with { type: "file" };
+
+export default mupdfWasmPath;

package/src/utils/mupdf-wasm.ts

@@ -14,13 +14,35 @@
  * read the wasm from the bunfs directly — no disk sidecar needed.
  *
  * This must run before the first `import("mupdf")` anywhere in the process.
+ *
+ * The embedded asset lives behind a separate module (#5663) so that an
+ * npm-installed source tree never resolves the monorepo-only
+ * `node_modules/mupdf/...` specifier at import time. That module is pulled in
+ * with a synchronous `require`, NOT a top-level `await import(...)`: a
+ * top-level await here makes this module async, and bun 1.4.0 fails to
+ * propagate that async-ness through the `model-registry` <-> `model-resolver`
+ * import cycle. The resulting bundle emits a non-async `__esm(() => { ...
+ * await init_model_registry(); ... })` wrapper, so every compiled binary died
+ * at parse time with `SyntaxError: Unexpected identifier
+ * 'init_model_registry'` (#5674). Keep this resolution synchronous.
  */
-import mupdfWasmPath from "../../../../node_modules/mupdf/dist/mupdf-wasm.wasm" with { type: "file" };
+import { isCompiledBinary } from "@gajae-code/utils/env";
 
 const MODULE_CONFIG_KEY = "$libmupdf_wasm_Module";
 
+function loadEmbeddedMupdfWasmPath(): string | undefined {
+	if (!isCompiledBinary()) return undefined;
+	// Only reached inside a compiled binary, where the embedded module — and
+	// therefore the bunfs asset it points at — is always bundled in.
+	const embedded = require("./mupdf-wasm-embedded") as { default?: unknown };
+	const embeddedPath = embedded.default;
+	return typeof embeddedPath === "string" ? embeddedPath : undefined;
+}
+
+const mupdfWasmPath = loadEmbeddedMupdfWasmPath();
+
 export function ensureMupdfWasmResolution(): void {
 	const globalScope = globalThis as typeof globalThis & Record<string, unknown>;
-	if (globalScope[MODULE_CONFIG_KEY] !== undefined) return;
+	if (globalScope[MODULE_CONFIG_KEY] !== undefined || mupdfWasmPath === undefined) return;
 	globalScope[MODULE_CONFIG_KEY] = { locateFile: () => String(mupdfWasmPath) };
 }

package/src/utils/mupdf.ts

@@ -0,0 +1,129 @@
+import * as path from "node:path";
+import * as url from "node:url";
+import * as util from "node:util";
+import { logger } from "@gajae-code/utils";
+import { embeddedMuPdfModule, embeddedMuPdfWasm } from "./mupdf-embedded";
+
+export let mupdfAssetMapping = "module mupdf; WASM mupdf-wasm.wasm -> unresolved";
+let wasmAsset: string | undefined;
+let initializationFailure: unknown;
+let preparation: Promise<void> | undefined;
+
+interface MuPdfModuleConfiguration {
+	wasmBinary?: Uint8Array;
+	locateFile?: (filename?: string) => string;
+	onAbort?: (error: unknown) => void;
+}
+
+type MuPdfGlobal = typeof globalThis & {
+	$libmupdf_wasm_Module?: MuPdfModuleConfiguration;
+};
+
+function resolveWasmAsset(): string {
+	if (wasmAsset) return wasmAsset;
+	let moduleMapping: string;
+	if (embeddedMuPdfWasm) {
+		wasmAsset = embeddedMuPdfWasm;
+		moduleMapping = `build-time provenance ${embeddedMuPdfModule}`;
+	} else {
+		if (process.env.PI_COMPILED || /\$bunfs|~BUN|%7EBUN/.test(import.meta.url)) {
+			throw new Error("Compiled MuPDF WASM mapping is missing; run scripts/embed-mupdf.ts before compiling.");
+		}
+		const markitModule = url.fileURLToPath(new URL("../../vendor/markit-ai/dist/index.js", import.meta.url));
+		moduleMapping = Bun.resolveSync("mupdf", path.dirname(markitModule));
+		wasmAsset = path.join(path.dirname(moduleMapping), "mupdf-wasm.wasm");
+	}
+	mupdfAssetMapping = `module mupdf -> ${moduleMapping}; WASM mupdf-wasm.wasm -> ${wasmAsset}`;
+	return wasmAsset;
+}
+
+// The official Emscripten hook is consumed by markit-ai's lazy MuPDF import.
+// Capture initialization aborts while preserving the import error's cause chain.
+const globalScope = globalThis as MuPdfGlobal;
+const hostConfiguration = globalScope.$libmupdf_wasm_Module;
+const configuration: MuPdfModuleConfiguration = hostConfiguration ?? {
+	locateFile: resolveWasmAsset,
+	onAbort(error: unknown) {
+		initializationFailure = error;
+	},
+};
+
+if (hostConfiguration === undefined) {
+	globalScope.$libmupdf_wasm_Module = configuration;
+} else {
+	// Reuse an SDK host's configuration and hooks. Only fill absent fields; do
+	// not replace locateFile/onAbort or discard caller-owned settings.
+	if (configuration.locateFile === undefined) configuration.locateFile = resolveWasmAsset;
+	if (configuration.onAbort === undefined) {
+		configuration.onAbort = error => {
+			initializationFailure = error;
+		};
+	}
+}
+
+function preparationAsset(): string {
+	const configuredPath = configuration.locateFile?.("mupdf-wasm.wasm");
+	return configuredPath ?? resolveWasmAsset();
+}
+
+export function prepareMuPdf(): Promise<void> {
+	// A new conversion attempt must not inherit an abort from a prior attempt.
+	initializationFailure = undefined;
+	const previousWasmBinary = configuration.wasmBinary;
+	preparation ??= Promise.resolve()
+		.then(async () => {
+			const bytes = await Bun.file(preparationAsset()).bytes();
+			// Reject corrupt assets before Emscripten starts: its abort path can also
+			// reject a secondary promise even when the module import is caught.
+			await WebAssembly.compile(bytes);
+			if (configuration.wasmBinary === undefined) configuration.wasmBinary = bytes;
+		})
+		.catch(error => {
+			preparation = undefined;
+			configuration.wasmBinary = previousWasmBinary;
+			throw error;
+		});
+	return preparation;
+}
+
+export function withMuPdfDiagnostic(error: unknown): Error {
+	const capturedInitializationFailure = initializationFailure;
+	initializationFailure = undefined;
+	const cause = capturedInitializationFailure ?? error;
+	const debugDetails: Record<string, unknown> = {
+		asset: embeddedMuPdfWasm ? "embedded" : "package",
+		error: formatMuPdfCauseChain(error),
+	};
+	if (capturedInitializationFailure !== undefined) {
+		debugDetails.initializationFailure = formatMuPdfCauseChain(capturedInitializationFailure);
+	}
+	logger.debug("MuPDF conversion failed", debugDetails);
+	const asset = embeddedMuPdfWasm ? "embedded asset" : "package asset";
+	return new Error(`PDF conversion failed [MuPDF; ${asset}; mupdf-wasm.wasm]`, { cause });
+}
+
+function formatMuPdfCauseChain(error: unknown): string {
+	const messages: string[] = [];
+	const seen = new Set<unknown>();
+	while (error !== undefined && !seen.has(error)) {
+		seen.add(error);
+		if (error instanceof Error) {
+			messages.push(sanitizeMuPdfDiagnostic(`${error.name}: ${error.message}`));
+			error = error.cause;
+		} else {
+			messages.push(sanitizeMuPdfDiagnostic(String(error)));
+			break;
+		}
+	}
+	return messages.join("; caused by: ") || "Conversion failed";
+}
+
+// Only the model-facing rendering is redacted; Error.cause remains intact for
+// internal inspection and operational debug logging. Conservatively redact the
+// rest of a path-bearing field so spaces in install paths cannot leak suffixes.
+export function sanitizeMuPdfDiagnostic(message: string): string {
+	return util
+		.stripVTControlCharacters(message)
+		.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g, "")
+		.replace(/[^\s"'`]*(?:[/\\]|%2f|%5c)[^"'`]*(?=["'`]|$)/gi, "[path redacted]");
+}

package/src/utils/session-title-generation.ts

@@ -0,0 +1,29 @@
+/**
+ * In-memory generation lease for asynchronous session-title regeneration.
+ *
+ * The lease is keyed by the session manager instance so TUI and ACP command
+ * dispatchers share the same ordering state without adding protocol fields to
+ * the persisted session format.
+ */
+const generations = new WeakMap<object, number>();
+
+function currentGeneration(owner: object): number {
+	return generations.get(owner) ?? 0;
+}
+
+/** Start a new regeneration and invalidate every older completion. */
+export function beginSessionTitleGeneration(owner: object): number {
+	const generation = currentGeneration(owner) + 1;
+	generations.set(owner, generation);
+	return generation;
+}
+
+/** Invalidate pending regeneration after a newer session mutation is accepted. */
+export function invalidateSessionTitleGeneration(owner: object): void {
+	generations.set(owner, currentGeneration(owner) + 1);
+}
+
+/** Return whether a regeneration still owns the latest generation lease. */
+export function isSessionTitleGenerationCurrent(owner: object, generation: number): boolean {
+	return currentGeneration(owner) === generation;
+}

package/src/utils/title-generator.ts

@@ -3,6 +3,7 @@
  */
 import * as path from "node:path";
 
+import type { AgentMessage } from "@gajae-code/agent-core";
 import { type Api, type AssistantMessage, completeSimple, type Model, type Tool } from "@gajae-code/ai/core";
 import { logger, prompt } from "@gajae-code/utils";
 import type { ModelRegistry } from "../config/model-registry";
@@ -17,6 +18,9 @@ const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 const DEFAULT_TERMINAL_TITLE = "GJC";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
+const MAX_TITLE_CONVERSATION_MESSAGES = 6;
+const MAX_TITLE_MESSAGE_CHARS = 400;
+
 const MAX_INPUT_CHARS = 2000;
 const TITLE_MAX_TOKENS = 30;
 const REASONING_SAFE_MAX_TOKENS = 1024;
@@ -29,6 +33,44 @@ const SET_TITLE_TOOL_NAME = "set_title";
 const MAX_TITLE_CHARS = 80;
 const MAX_TITLE_WORDS = 12;
 
+/**
+ * Build a bounded conversation digest for title regeneration. Regeneration
+ * reads several messages so a throwaway first prompt can be corrected, while
+ * the automatic first-message path intentionally uses only its initial input.
+ */
+export function buildConversationTitleInput(messages: readonly AgentMessage[]): string | undefined {
+	const userMessages: string[] = [];
+	for (const message of messages) {
+		if (message.role !== "user") continue;
+		const content = message.content;
+		const text =
+			typeof content === "string"
+				? content
+				: content
+						.filter(block => block.type === "text")
+						.map(block => block.text)
+						.join("\n");
+		const trimmed = text.trim();
+		if (trimmed) userMessages.push(trimmed);
+	}
+
+	if (userMessages.length === 0) return undefined;
+
+	const keptMessages =
+		userMessages.length > MAX_TITLE_CONVERSATION_MESSAGES
+			? [userMessages[0]!, ...userMessages.slice(-(MAX_TITLE_CONVERSATION_MESSAGES - 1))]
+			: userMessages;
+	// Reserve separator and ellipsis room so the digest is already within the
+	// generator's MAX_INPUT_CHARS bound; its existing truncation is a no-op here.
+	const maxMessageChars = Math.min(
+		MAX_TITLE_MESSAGE_CHARS,
+		Math.floor((MAX_INPUT_CHARS - (keptMessages.length - 1) - keptMessages.length) / keptMessages.length),
+	);
+	return keptMessages
+		.map(message => (message.length > maxMessageChars ? `${message.slice(0, maxMessageChars)}…` : message))
+		.join("\n");
+}
+
 const setTitleTool: Tool = {
 	name: SET_TITLE_TOOL_NAME,
 	description: "Set the generated session title.",
@@ -58,9 +100,11 @@ function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel
 }
 
 /**
- * Generate a title for a session based on the first user message.
+ * Generate a title for a session based on the provided user-message input.
+ * Automatic titles pass the first user message; regeneration passes a bounded
+ * conversation digest.
  *
- * @param firstMessage The first user message
+ * @param firstMessage The first user message or bounded conversation digest
  * @param registry Model registry
  * @param settings Settings used to resolve the smol role
  * @param sessionId Optional session id for sticky API key selection

package/src/web/scrapers/types.ts

@@ -78,7 +78,10 @@ export interface LoadPageOptions {
 
 export interface LoadPageResult {
 	content: string;
+	/** The bounded response bytes retained for binary classification/conversion. */
+	buffer?: Uint8Array;
 	contentType: string;
+	contentDisposition?: string;
 	finalUrl: string;
 	ok: boolean;
 	status?: number;
@@ -173,6 +176,7 @@ export async function loadPage(url: string, options: LoadPageOptions = {}): Prom
 				}
 
 				const contentType = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() ?? "";
+				const contentDisposition = response.headers.get("content-disposition") || undefined;
 				const finalUrl = logicalUrl;
 
 				const reader = response.body?.getReader();
@@ -196,16 +200,33 @@ export async function loadPage(url: string, options: LoadPageOptions = {}): Prom
 					}
 				}
 
-				const content = Buffer.concat(chunks).toString("utf-8");
+				const bytes = Buffer.concat(chunks);
+				const content = bytes.toString("utf-8");
+				const buffer =
+					contentType.length === 0 ||
+					contentType === "application/octet-stream" ||
+					contentType === "binary/octet-stream" ||
+					contentType === "unknown" ||
+					contentDisposition !== undefined
+						? bytes
+						: undefined;
 				if (isBotBlocked(response.status, content) && attempt < USER_AGENTS.length - 1) {
 					continue attempts;
 				}
 
 				if (!response.ok) {
-					return { content, contentType, finalUrl, ok: false, status: response.status };
+					return {
+						content,
+						buffer,
+						contentType,
+						contentDisposition,
+						finalUrl,
+						ok: false,
+						status: response.status,
+					};
 				}
 
-				return { content, contentType, finalUrl, ok: true, status: response.status };
+				return { content, buffer, contentType, contentDisposition, finalUrl, ok: true, status: response.status };
 			}
 			return {
 				content: "",

package/vendor/markit-ai/LICENSE

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