pi-readseek 0.9.12 → 0.9.14

package/README.md

@@ -1,10 +1,7 @@
 # pi-readseek
 
-`pi-readseek` adds ReadSeek's anchored file operations, structural search,
-symbol navigation, and document tools to Pi. Built-ins remain available unless
-`overrideTools` maps `read`, `edit`, `write`, or `grep` to a ReadSeek-backed
-implementation. The `read` override runs ReadSeek's `digest` command; it does not
-add a separate `readSeek_read` tool.
+Pi extension for anchored file operations, structural search, symbol navigation,
+and document inspection.
 
 ## Install
 
@@ -12,33 +9,18 @@ add a separate `readSeek_read` tool.
 pi install npm:pi-readseek
 ```
 
-The package depends on `@jarkkojs/readseek`, which supplies the native binary on
-supported platforms. The extension uses that packaged binary exclusively; an
-unresolved binary indicates a broken installation rather than falling back to an
-unrelated `readseek` executable on `PATH`.
+The extension uses the native binary supplied by `@jarkkojs/readseek`. Set
+`READSEEK_BINARY` to an absolute executable path to override it.
 
 ## Tools
 
-| Tool              | Purpose                                                                       |
-| ----------------- | ----------------------------------------------------------------------------- |
-| `readSeek_edit`   | Apply hash-verified edits to an existing text file                            |
-| `readSeek_write`  | Create or replace a complete text file and return anchors                     |
-| `readSeek_grep`   | Search text or regex and return edit-ready anchors                            |
-| `readSeek_search` | Search AST patterns                                                           |
-| `readSeek_def`    | Find symbol definitions                                                       |
-| `readSeek_refs`   | Find identifier usages, optionally scoped to a cursor binding                 |
-| `readSeek_rename` | Rename a cursor symbol; set `apply: false` to preview the plan                |
-| `readSeek_digest` | Native `digest` envelope: map, diagnostics, identity, content, metadata       |
-| `readSeek_view`   | View or narrow a structural document index (PDF first); optional asset vision |
-
-The extension also tells Pi to get fresh anchors before editing and to run
-`readSeek_digest` with diagnostics after source edits.
+`readSeek_edit`, `readSeek_write`, `readSeek_grep`, `readSeek_search`,
+`readSeek_def`, `readSeek_refs`, `readSeek_rename`, `readSeek_digest`, and
+`readSeek_view`.
 
 ## Settings
 
-Add a `readseek` object to `~/.pi/agent/settings.json` (global) or
-`.pi/settings.json` (project). Project settings override matching global values.
-Defaults:
+Add `readseek` to `~/.pi/agent/settings.json` or `.pi/settings.json`:
 
 ```json
 {
@@ -47,10 +29,7 @@ Defaults:
     "imageMode": "auto",
     "syntaxValidation": "warn",
     "timeoutMs": 120000,
-    "grep": {
-      "maxLines": 2000,
-      "maxBytes": 51200
-    },
+    "grep": { "maxLines": 2000, "maxBytes": 51200 },
     "display": {
       "grep": "compact",
       "edit": "expanded",
@@ -60,23 +39,8 @@ Defaults:
 }
 ```
 
-- `overrideTools`: any of `"read"`, `"edit"`, `"write"`, and `"grep"`.
-- `imageMode`: controls standalone images when `digest` overrides `read`.
-  `"auto"` passes the prepared image to image-capable Pi models and otherwise
-  runs local analysis, `"on"` always runs local analysis, and `"off"` skips the
-  image. Local analysis defaults to `all` and also supports `ocr`, `caption`, and
-  `objects` through `visionMode`. The namespaced `readSeek_digest` tool applies
-  `visionMode` directly, including `none`. Documents use `readSeek_view` with
-  optional `visionMode` and `visionLevel`. Local analysis uses
-  [Qwen3-VL-2B-Instruct](../../docs/models/qwen3-vl-2b-instruct.md).
-- `syntaxValidation`: `"warn"` (write and warn), `"block"` (abort), or `"off"`.
-  Validation triggers only when an edit increases parser error or missing-node
-  counts.
-- `timeoutMs`: native command timeout in milliseconds.
-- `grep.maxLines` and `grep.maxBytes`: output limits; larger values are clamped
-  to the defaults.
-- `display`: initial `"compact"` or `"expanded"` state for `grep`,
-  `edit`, and `write` results.
+`overrideTools` accepts `read`, `edit`, `write`, and `grep`. `imageMode` is
+`auto`, `on`, or `off`; `syntaxValidation` is `warn`, `block`, or `off`.
 
 ## Development
 
@@ -86,8 +50,7 @@ npm test
 npm run typecheck
 ```
 
-## License
 
-`pi-readseek` is Apache-2.0; see [LICENSE](LICENSE).
-`@jarkkojs/readseek` is licensed separately under
-Apache-2.0 AND LGPL-2.1-or-later.
+## Licensing
+
+[Apache 2.0](../../LICENSE-APACHE-2.0).

package/dist/index.ts

@@ -28,6 +28,13 @@ var DOCUMENT_NODE_KINDS = [
   "section",
   "structural_section"
 ];
+var EDIT_VARIANTS = [
+  "set_line",
+  "replace_lines",
+  "insert_after",
+  "replace",
+  "replace_symbol"
+];
 var TOOL_NAMES = [
   "digest",
   "edit",
@@ -485,6 +492,25 @@ function renderToolRoutingPolicy(options = {}) {
   return [title, ...bullets].join(`
 `);
 }
+// ../readseek-api/src/hashline.ts
+var HASH_LEN = 6;
+var LINE_ANCHOR_RE = /^(\d+):([0-9a-fA-F]{6})$/;
+function tryParseLineAnchor(anchor) {
+  const match = LINE_ANCHOR_RE.exec(anchor.trim());
+  if (!match) {
+    return { ok: false, error: `invalid LINE:HASH anchor: ${anchor}` };
+  }
+  const digits = match[1];
+  const line = Number.parseInt(digits, 10);
+  if (!Number.isSafeInteger(line)) {
+    return { ok: false, error: `Line number must be a safe integer, got ${digits} in "${anchor}".` };
+  }
+  if (line < 1) {
+    return { ok: false, error: `Line number must be >= 1, got ${line} in "${anchor}".` };
+  }
+  return { ok: true, anchor: { line, hash: match[2].toLowerCase() } };
+}
+
 // ../readseek-api/src/validation.ts
 function validateGitSelection(input) {
   if (input.ignored && !input.others) {
@@ -516,6 +542,73 @@ function validateVisionLevelVsMode(input) {
   }
   return { ok: true };
 }
+var VARIANT_FIELDS = {
+  set_line: ["anchor", "new_text"],
+  replace_lines: ["start_anchor", "end_anchor", "new_text"],
+  insert_after: ["anchor", "new_text"],
+  replace: ["old_text", "new_text"],
+  replace_symbol: ["symbol", "new_body"]
+};
+function isEditVariant(value) {
+  return EDIT_VARIANTS.includes(value);
+}
+function parseEditItem(item, index) {
+  const keys = Object.keys(item);
+  const variant = keys[0];
+  if (keys.length !== 1 || variant === undefined || !isEditVariant(variant)) {
+    return {
+      ok: false,
+      error: `edits[${index}] must contain exactly one of: ${EDIT_VARIANTS.join(", ")}. Got: [${keys.join(", ")}]`
+    };
+  }
+  const payload = item[variant];
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return { ok: false, error: `edits[${index}].${variant} must be an object` };
+  }
+  const expected = VARIANT_FIELDS[variant];
+  const allowed = variant === "replace" ? [...expected, "all"] : [...expected];
+  const actual = Object.keys(payload);
+  if (actual.some((field) => !allowed.includes(field)) || expected.some((field) => !actual.includes(field))) {
+    return { ok: false, error: `edits[${index}].${variant} contains invalid fields` };
+  }
+  const values = payload;
+  for (const field of expected) {
+    if (typeof values[field] !== "string") {
+      return { ok: false, error: `edits[${index}].${variant}.${field} must be a string` };
+    }
+  }
+  if (variant === "replace" && values.all !== undefined && typeof values.all !== "boolean") {
+    return { ok: false, error: `edits[${index}].replace.all must be a boolean` };
+  }
+  for (const field of expected) {
+    if (!field.endsWith("anchor"))
+      continue;
+    const parsed = tryParseLineAnchor(values[field]);
+    if (!parsed.ok) {
+      return { ok: false, error: `edits[${index}].${variant}.${field}: ${parsed.error}` };
+    }
+  }
+  return { ok: true, edit: item };
+}
+function validateExactlyOneEditVariant(edits) {
+  if (!Array.isArray(edits) || edits.length === 0) {
+    return { ok: false, error: "edits must contain at least one edit" };
+  }
+  const normalized = [];
+  for (let index = 0;index < edits.length; index++) {
+    const item = edits[index];
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      return { ok: false, error: `edits[${index}] must be an edit object` };
+    }
+    const parsed = parseEditItem(item, index);
+    if (!parsed.ok)
+      return parsed;
+    normalized.push(parsed.edit);
+  }
+  return { ok: true, edits: normalized };
+}
+var MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
 // ../readseek-api/src/argv.ts
 function buildLineLocation(line, column) {
   return column === undefined ? `line:${line}` : `line:${line}:${column}`;
@@ -525,14 +618,12 @@ function appendGitSelectionArgs(args, input) {
   if (!validated.ok) {
     throw new Error(validated.error);
   }
-  const selection = [
-    input.cached ? "cached" : undefined,
-    input.others ? "others" : undefined,
-    input.ignored ? "ignored" : undefined
-  ].filter((value) => value !== undefined);
-  if (selection.length > 0) {
-    args.push("--git", selection.join(","));
-  }
+  if (input.cached)
+    args.push("--cached");
+  if (input.others)
+    args.push("--others");
+  if (input.ignored)
+    args.push("--ignored");
   return args;
 }
 function pushOptionalString(args, flag, value) {
@@ -609,15 +700,17 @@ function buildViewArgs(input) {
   return args;
 }
 function buildSearchArgs(input) {
-  const args = ["search", input.path, input.pattern];
+  const args = ["search", input.pattern];
+  pushOptionalString(args, "--path", input.path);
   pushOptionalString(args, "--language", input.language);
+  pushOptionalNumber(args, "--limit", input.limit);
   return appendGitSelectionArgs(args, input);
 }
 function buildDefArgs(input) {
-  const args = ["def", input.path];
+  const args = ["def", input.name];
+  pushOptionalString(args, "--path", input.path);
   if (input.format !== undefined)
     args.push("--format", input.format);
-  args.push(input.name);
   pushOptionalString(args, "--language", input.language);
   return appendGitSelectionArgs(args, input);
 }
@@ -625,11 +718,14 @@ function buildRefsArgs(input) {
   const validated = validateRefsNameVsScope(input);
   if (!validated.ok)
     throw new Error(validated.error);
-  const args = ["refs", input.path];
-  if (input.scope) {
-    args.push("--at", buildLineLocation(input.line, input.column));
-  } else if (input.name !== undefined) {
+  const args = ["refs"];
+  if (input.name !== undefined)
     args.push(input.name);
+  pushOptionalString(args, "--path", input.path);
+  if (input.scope) {
+    args.push("--scope");
+    pushOptionalNumber(args, "--line", input.line);
+    pushOptionalNumber(args, "--column", input.column);
   }
   if (input.format !== undefined)
     args.push("--format", input.format);
@@ -645,13 +741,13 @@ function buildEditArgs(input) {
   });
   pushOptionalString(args, "--language", input.language);
   if (input.requestFromStdin)
-    args.push("--request", "-");
+    args.push("--edits", "-");
   return args;
 }
 function buildRenameArgs(input) {
   const args = ["rename", input.path, "--at", buildLineLocation(input.line, input.column), "--to", input.to];
   if (input.workspace !== undefined)
-    args.push("--workspace", input.workspace);
+    args.push(`--workspace=${input.workspace}`);
   appendApplyAndPlanHash(args, {
     apply: input.apply,
     planHash: input.planHash,
@@ -661,9 +757,10 @@ function buildRenameArgs(input) {
   return appendGitSelectionArgs(args, input);
 }
 // ../readseek-api/src/platform.ts
-import { accessSync, constants as fsConstants } from "node:fs";
+import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
+var READSEEK_BINARY_ENV = "READSEEK_BINARY";
 var READSEEK_PLATFORM_PACKAGES = {
   "darwin-arm64": "@jarkkojs/readseek-darwin-arm64",
   "linux-arm64": "@jarkkojs/readseek-linux-arm64",
@@ -677,6 +774,24 @@ function readSeekBinaryName(platform = process.platform) {
 function readSeekPlatformKey(platform = process.platform, arch = process.arch) {
   return `${platform}-${arch}`;
 }
+function resolveReadSeekBinaryOverride(environment = process.env) {
+  const binaryPath = environment[READSEEK_BINARY_ENV];
+  if (binaryPath === undefined)
+    return null;
+  if (!path.isAbsolute(binaryPath)) {
+    throw new Error(`${READSEEK_BINARY_ENV} must be an absolute path to the readseek executable`);
+  }
+  try {
+    if (!statSync(binaryPath).isFile())
+      throw new Error("not a regular file");
+    accessSync(binaryPath, fsConstants.X_OK);
+  } catch (error) {
+    throw new Error(`${READSEEK_BINARY_ENV} does not point to an executable file: ${binaryPath}`, {
+      cause: error
+    });
+  }
+  return binaryPath;
+}
 function resolveReadSeekBinaryFromPackages(resolver = resolveFromPackage, options = {}) {
   const resolve = typeof resolver === "function" ? resolver : resolver.resolve.bind(resolver);
   const platform = options.platform ?? process.platform;
@@ -1033,6 +1148,7 @@ function parseCheckOutput(value) {
   if (!Array.isArray(output.diagnostics))
     throw new Error("invalid readseek diagnostics");
   return {
+    file_hash: optionalString(output.file_hash, "file_hash"),
     errorCount: requireNumber(output.error_count, "error_count"),
     missingCount: requireNumber(output.missing_count, "missing_count"),
     diagnostics: output.diagnostics.map((diagnostic) => {
@@ -1437,6 +1553,7 @@ function createReadSeekClient(runner) {
         path: target,
         pattern,
         language: options.language,
+        limit: options.limit,
         cached: options.cached,
         others: options.others,
         ignored: options.ignored
@@ -1502,7 +1619,8 @@ function createReadSeekClient(runner) {
         path: filePath,
         apply: options.apply,
         planHash: options.planHash,
-        language: options.language
+        language: options.language,
+        requestFromStdin: true
       });
       return parseEditOutput(await runner.json(args, {
         signal: options.signal,
@@ -1574,10 +1692,7 @@ import * as Diff from "diff";
 
 // src/hashline.ts
 import xxhashWasm from "xxhash-wasm";
-var HASH_LEN = 3;
-var RADIX = 16;
-var HASH_MOD = RADIX ** HASH_LEN;
-var DICT = Array.from({ length: HASH_MOD }, (_, i) => i.toString(RADIX).padStart(HASH_LEN, "0"));
+var ANCHOR_MASK = 16777215;
 var HASHLINE_STATE_KEY = Symbol.for("pi-readseek.hashlineState.v1");
 function getHashlineState() {
   const globalObject = globalThis;
@@ -1595,6 +1710,9 @@ async function ensureHashInit() {
   if (!state.initPromise) {
     state.initPromise = xxhashWasm().then((hasher) => {
       state.h32Fn = hasher.h32;
+    }).catch((error) => {
+      state.initPromise = null;
+      throw error;
     });
   }
   await state.initPromise;
@@ -1605,11 +1723,11 @@ function xxh32(input) {
     throw new Error("Hash not initialized — call ensureHashInit() first");
   return state.h32Fn(input, 0) >>> 0;
 }
+function canonicalizeLine(line) {
+  return line.match(/[^\t\r\n ]+/g)?.join(" ") ?? "";
+}
 function computeLineHash(line) {
-  if (line.endsWith("\r"))
-    line = line.slice(0, -1);
-  line = line.replace(/\s+/g, "");
-  return DICT[xxh32(line) % HASH_MOD];
+  return (xxh32(canonicalizeLine(line)) & ANCHOR_MASK).toString(16).padStart(HASH_LEN, "0");
 }
 var DISPLAY_CONTROL_CHAR_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
 function escapeControlCharsForDisplay(text) {
@@ -1762,27 +1880,10 @@ function generateCompactOrFullDiff(oldContent, newContent, contextLines = 4) {
 }
 
 // src/path-utils.ts
-import { homedir } from "node:os";
-import { isAbsolute, resolve as resolvePath } from "node:path";
-var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-function normalizeUnicodeSpaces(str) {
-  return str.replace(UNICODE_SPACES, " ");
-}
-function normalizeAtPrefix(filePath) {
-  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
-}
-function expandPath(filePath) {
-  const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
-  if (normalized === "~")
-    return homedir();
-  if (normalized.startsWith("~/"))
-    return homedir() + normalized.slice(1);
-  return normalized;
-}
-function resolveToCwd(filePath, cwd) {
-  const expanded = expandPath(filePath);
-  return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
-}
+import {
+  expandUserPath as expandUserPath2,
+  resolveToCwd as resolveToCwd2
+} from "@jarkkojs/readseek-api";
 
 // src/runtime.ts
 function throwIfAborted(signal) {
@@ -2112,41 +2213,14 @@ function classifyEdit(oldContent, newContent) {
 }
 
 // src/readseek-client.ts
-import { existsSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync2, statSync as statSync3 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir2 } from "node:os";
 import path2 from "node:path";
 
-// src/readseek/enums.ts
-var SymbolKind;
-((SymbolKind2) => {
-  SymbolKind2["Class"] = "class";
-  SymbolKind2["Function"] = "function";
-  SymbolKind2["Method"] = "method";
-  SymbolKind2["Variable"] = "variable";
-  SymbolKind2["Constant"] = "constant";
-  SymbolKind2["Interface"] = "interface";
-  SymbolKind2["Type"] = "type";
-  SymbolKind2["Enum"] = "enum";
-  SymbolKind2["Struct"] = "struct";
-  SymbolKind2["Import"] = "import";
-  SymbolKind2["Module"] = "module";
-  SymbolKind2["Namespace"] = "namespace";
-  SymbolKind2["Property"] = "property";
-  SymbolKind2["Heading"] = "heading";
-  SymbolKind2["Table"] = "table";
-  SymbolKind2["View"] = "view";
-  SymbolKind2["Procedure"] = "procedure";
-  SymbolKind2["Trigger"] = "trigger";
-  SymbolKind2["Index"] = "index";
-  SymbolKind2["Schema"] = "schema";
-  SymbolKind2["Signal"] = "signal";
-  SymbolKind2["Unknown"] = "unknown";
-})(SymbolKind ||= {});
-
 // src/readseek-settings.ts
-import { readFileSync, statSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { readFileSync, statSync as statSync2 } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 var READSEEK_TOOL_REPLACEMENTS = {
   read: "readSeek_digest",
@@ -2163,7 +2237,7 @@ var DEFAULT_DISPLAY_MODES = {
   write: "expanded"
 };
 function globalSettingsPath() {
-  return join(homedir2(), ".pi/agent/settings.json");
+  return join(homedir(), ".pi/agent/settings.json");
 }
 function projectSettingsPath() {
   return join(process.cwd(), ".pi/settings.json");
@@ -2303,7 +2377,7 @@ function validateSettings(raw, source) {
 var settingsFileCache = new Map;
 function statFileOrNull(path2) {
   try {
-    return statSync(path2);
+    return statSync2(path2);
   } catch {
     return null;
   }
@@ -2362,7 +2436,7 @@ function resolveReadSeekToolDisplayMode(tool) {
 // src/readseek-client.ts
 var resolveFromHost = createRequire2(import.meta.url).resolve;
 function readSeekBinaryPath() {
-  return resolveReadSeekBinaryFromPackages(resolveFromHost);
+  return resolveReadSeekBinaryOverride() ?? resolveReadSeekBinaryFromPackages(resolveFromHost);
 }
 function readSeekBinaryAvailability() {
   try {
@@ -2372,46 +2446,18 @@ function readSeekBinaryAvailability() {
     return { available: false, reason: classifyReadSeekFailure(err).message };
   }
 }
-var READSEEK_REPO_PACKAGE_NAMES = new Set(["@jarkkojs/readseek", "readseek"]);
 var defaultReadSeekDirInit;
-function directoryExists(dirPath) {
+function defaultReadSeekDir() {
+  const home = homedir2();
+  return home ? path2.join(home, ".pi", "readseek") : null;
+}
+function directoryExists(dir) {
   try {
-    return statSync2(dirPath).isDirectory();
+    return statSync3(dir).isDirectory();
   } catch {
     return false;
   }
 }
-var ownRepositoryByDir = new Map;
-function isOwnReadSeekRepository(cwd = process.cwd()) {
-  const start = path2.resolve(cwd);
-  const cached = ownRepositoryByDir.get(start);
-  if (cached !== undefined)
-    return cached;
-  let dir = start;
-  let result = false;
-  while (true) {
-    const packageJsonPath = path2.join(dir, "package.json");
-    if (existsSync(packageJsonPath)) {
-      try {
-        const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-        if (typeof packageJson.name === "string" && READSEEK_REPO_PACKAGE_NAMES.has(packageJson.name)) {
-          result = true;
-          break;
-        }
-      } catch {}
-    }
-    const parent = path2.dirname(dir);
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  ownRepositoryByDir.set(start, result);
-  return result;
-}
-function defaultReadSeekDir() {
-  const home = homedir3();
-  return home ? path2.join(home, ".pi", "readseek") : null;
-}
 var DEFAULT_READSEEK_VISION_TIMEOUT_MS = 30 * 60000;
 function readSeekTimeoutMs() {
   return resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_TIMEOUT_MS;
@@ -2435,8 +2481,19 @@ async function ensureDefaultReadSeekDir() {
   });
   return defaultReadSeekDirInit;
 }
+function hasProjectReadSeekDir(cwd = process.cwd()) {
+  let dir = path2.resolve(cwd);
+  while (true) {
+    if (existsSync2(path2.join(dir, ".readseek")))
+      return true;
+    const parent = path2.dirname(dir);
+    if (parent === dir)
+      return false;
+    dir = parent;
+  }
+}
 async function readSeekInvocationArgs(args) {
-  if (isOwnReadSeekRepository())
+  if (hasProjectReadSeekDir())
     return [...args];
   const readSeekDir = await ensureDefaultReadSeekDir();
   return readSeekDir ? ["--readseek-dir", readSeekDir, ...args] : [...args];
@@ -2491,7 +2548,7 @@ async function runReadSeekVisionRaw(args, options = {}) {
   }
 }
 async function runReadSeekVision(args, options = {}) {
-  return JSON.parse(await runReadSeekVisionRaw(args, options));
+  return parseReadSeekJson(await runReadSeekVisionRaw(args, options));
 }
 var runner = {
   text: (args, options = {}) => options.vision ? runReadSeekVisionRaw(args, options) : runReadSeekRaw(args, options),
@@ -2512,67 +2569,12 @@ var readSeekIdentify = client.identify;
 var readSeekDetect = client.detect;
 var readSeekEdit = client.edit;
 var readSeekRename = client.rename;
-function normalizeLanguage(language) {
-  return language === "java" ? "Java" : language;
-}
-function normalizeKind(kind) {
-  if (kind === "constructor")
-    return "method" /* Method */;
-  if (Object.values(SymbolKind).includes(kind))
-    return kind;
-  return "unknown" /* Unknown */;
-}
-function parentQualifiedNameFor(qualifiedName) {
-  const lastDot = qualifiedName.lastIndexOf(".");
-  return lastDot === -1 ? "" : qualifiedName.slice(0, lastDot);
-}
-function symbolsFromReadSeek(symbols) {
-  const symbolsByQualifiedName = new Map;
-  const entries = [];
-  for (const symbol of symbols) {
-    const parentQualifiedName = parentQualifiedNameFor(symbol.qualified_name);
-    const fileSymbol = {
-      name: symbol.name,
-      kind: normalizeKind(symbol.kind),
-      startLine: symbol.start_line,
-      endLine: symbol.end_line
-    };
-    const bucket = symbolsByQualifiedName.get(symbol.qualified_name);
-    if (bucket)
-      bucket.push(fileSymbol);
-    else
-      symbolsByQualifiedName.set(symbol.qualified_name, [fileSymbol]);
-    entries.push({ parentQualifiedName, symbol: fileSymbol });
-  }
-  const roots = [];
-  for (const entry of entries) {
-    const parent = entry.parentQualifiedName ? symbolsByQualifiedName.get(entry.parentQualifiedName)?.[0] : undefined;
-    if (!parent) {
-      roots.push(entry.symbol);
-      continue;
-    }
-    parent.children ??= [];
-    parent.children.push(entry.symbol);
-  }
-  return roots;
-}
-function fileMapFromReadSeekOutput(output, filePath, totalBytes) {
-  if (output.language === "unknown" && output.symbols.length === 0)
-    return null;
-  return {
-    path: filePath,
-    totalLines: output.line_count,
-    totalBytes,
-    language: normalizeLanguage(output.language),
-    detailLevel: "full" /* Full */,
-    symbols: symbolsFromReadSeek(output.symbols)
-  };
-}
-async function readSeekMap(filePath, totalBytes, options = {}) {
+async function readSeekMap(filePath, options = {}) {
   const envelope = await client.digest(filePath, { select: "map", signal: options.signal });
-  if (!envelope.map)
+  const map = envelope.map;
+  if (!map || map.language === "unknown" && map.symbols.length === 0)
     return null;
-  return fileMapFromReadSeekOutput(envelope.map, filePath, totalBytes);
+  return map;
 }
 
 // src/edit-syntax-validate.ts
@@ -2677,19 +2679,19 @@ function parseCompactDiffEntries(diff, oldContent, newContent) {
 `);
   const newLines = newContent.split(`
 `);
-  const compactDelete = diff.match(/^(\d+):[0-9a-f]{3}\|(.*) → \[deleted\]$/);
+  const compactDelete = diff.match(/^(\d+):[0-9a-f]{6}\|(.*) → \[deleted\]$/);
   if (compactDelete) {
     const oldLine2 = Number(compactDelete[1]);
     const text = compactDelete[2] ?? "";
     if (oldLines[oldLine2 - 1] === text)
       return [{ kind: "remove", oldLine: oldLine2, text }];
   }
-  const compactPrefix = diff.match(/^(\d+):[0-9a-f]{3}\|/);
+  const compactPrefix = diff.match(/^(\d+):[0-9a-f]{6}\|/);
   if (!compactPrefix)
     return;
   const oldLine = Number(compactPrefix[1]);
   const oldTextStart = compactPrefix[0].length;
-  const separatorPattern = / → (\d+):[0-9a-f]{3}\|/g;
+  const separatorPattern = / → (\d+):[0-9a-f]{6}\|/g;
   let separator;
   while ((separator = separatorPattern.exec(diff)) !== null) {
     const newLine = Number(separator[1]);
@@ -2873,7 +2875,7 @@ function linkToolPath(styledText, rawPath, cwd) {
   try {
     if (!getCapabilities().hyperlinks)
       return styledText;
-    const absolutePath = resolveToCwd(rawPath, cwd);
+    const absolutePath = resolveToCwd2(rawPath, cwd);
     return hyperlink(styledText, pathToFileURL(absolutePath).href);
   } catch {
     return styledText;
@@ -3149,11 +3151,6 @@ class DiffPreviewComponent {
     });
     for (const line of body.lines)
       lines.push(line);
-    for (const suffix of this.options.suffixLines ?? []) {
-      for (const line of suffix.split(`
-`))
-        lines.push(clampLineToWidth(line, normalized));
-    }
     const clamped = lines.map((line) => visibleWidth3(line) <= normalized ? line : clampLineToWidth(line, normalized));
     this.cachedLines = clamped;
     this.cachedWidth = normalized;
@@ -3251,7 +3248,7 @@ async function executeEdit(opts) {
   const parsed = params;
   const rawPath = parsed.path;
   const path3 = rawPath.replace(/^@/, "");
-  const absolutePath = resolveToCwd(path3, cwd);
+  const absolutePath = resolveToCwd2(path3, cwd);
   throwIfAborted(signal);
   try {
     return await withFileMutationQueue(absolutePath, async () => {
@@ -3260,18 +3257,11 @@ async function executeEdit(opts) {
         const hint = `Call readSeek_digest(${JSON.stringify(rawPath)}) first, or use readSeek_grep, readSeek_search, or readSeek_write to produce fresh anchors for this file.`;
         return buildEditError(absolutePath, "file-not-read", `You must get fresh anchors for ${absolutePath} before editing it. ${hint}`, hint);
       }
-      const edits = parsed.edits ?? [];
-      if (!edits.length) {
-        return buildEditError(absolutePath, "invalid-edit-variant", "No edits provided.");
-      }
-      const variants = new Set(["set_line", "replace_lines", "insert_after", "replace", "replace_symbol"]);
-      for (let index = 0;index < edits.length; index++) {
-        const edit = edits[index];
-        const keys = edit && typeof edit === "object" && !Array.isArray(edit) ? Object.keys(edit) : [];
-        if (keys.length !== 1 || !variants.has(keys[0])) {
-          return buildEditError(absolutePath, "invalid-edit-variant", `edits[${index}] must contain exactly one of: 'set_line', 'replace_lines', 'insert_after', 'replace', 'replace_symbol'. Got: [${keys.join(", ")}].`);
-        }
+      const parsedEdits = validateExactlyOneEditVariant(parsed.edits ?? []);
+      if (!parsedEdits.ok) {
+        return buildEditError(absolutePath, "invalid-edit-variant", parsedEdits.error);
       }
+      const edits = parsedEdits.edits;
       let plan;
       try {
         plan = await readSeekEdit(absolutePath, edits, { signal, language: parsed.language });
@@ -3619,39 +3609,34 @@ ${text}`;
 }
 
 // src/file-map.ts
-import { stat } from "node:fs/promises";
 async function getOrGenerateMap(absPath) {
   try {
-    const { size } = await stat(absPath);
-    return await readSeekMap(absPath, size);
+    return await readSeekMap(absPath);
   } catch {
     return null;
   }
 }
 
-// src/readseek/symbol-tree.ts
-function traverseSymbolTree(symbols, visit) {
-  const result = [];
-  const walk = (nodes, parentName) => {
-    for (const symbol of nodes) {
-      result.push(visit(symbol, parentName));
-      if (symbol.children?.length)
-        walk(symbol.children, symbol.name);
-    }
-  };
-  walk(symbols);
-  return result;
-}
-
 // src/grep-symbol-scope.ts
 function findEnclosingSymbol(map, lineNumber) {
-  const candidates = traverseSymbolTree(map.symbols, (symbol, parentName) => ({
-    name: symbol.name,
-    kind: symbol.kind,
-    startLine: symbol.startLine,
-    endLine: symbol.endLine,
-    parentName
-  })).filter((s) => lineNumber >= s.startLine && lineNumber <= s.endLine).sort((a, b) => {
+  const byQualifiedName = new Map;
+  for (const symbol of map.symbols) {
+    const qname = symbol.qualified_name ?? symbol.name;
+    if (!byQualifiedName.has(qname))
+      byQualifiedName.set(qname, symbol);
+  }
+  const candidates = map.symbols.filter((symbol) => lineNumber >= symbol.start_line && lineNumber <= symbol.end_line).map((symbol) => {
+    const qname = symbol.qualified_name ?? symbol.name;
+    const dot = qname.lastIndexOf(".");
+    const parent = dot === -1 ? undefined : byQualifiedName.get(qname.slice(0, dot));
+    return {
+      name: symbol.name,
+      kind: symbol.kind === "constructor" ? "method" : symbol.kind,
+      startLine: symbol.start_line,
+      endLine: symbol.end_line,
+      parentName: parent?.name
+    };
+  }).sort((a, b) => {
     const rangeA = a.endLine - a.startLine;
     const rangeB = b.endLine - b.startLine;
     if (rangeA !== rangeB)
@@ -3660,7 +3645,7 @@ function findEnclosingSymbol(map, lineNumber) {
       return a.startLine - b.startLine;
     return a.name.localeCompare(b.name);
   });
-  return candidates.length ? candidates[0] : null;
+  return candidates[0] ?? null;
 }
 function firstLineNumber(group) {
   const first = group.entries.find((e) => e.kind !== "separator");
@@ -3851,38 +3836,9 @@ function formatGrepResultText(input) {
 }
 
 // src/coerce-obvious-int.ts
-var BASE10_INT_RE = /^-?\d+$/;
-var MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
-var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
-function formatReceived(value) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return String(value);
-  return JSON.stringify(value) ?? String(value);
-}
-function invalidInteger(value, name) {
-  return {
-    ok: false,
-    message: `Invalid ${name}: expected a safe base-10 integer, received ${formatReceived(value)}.`
-  };
-}
-function coerceObviousBase10Int(value, name) {
-  if (value === undefined || typeof value === "string" && value.trim() === "") {
-    return { ok: true, value: undefined };
-  }
-  if (typeof value === "number") {
-    if (Number.isSafeInteger(value)) {
-      return { ok: true, value };
-    }
-    return invalidInteger(value, name);
-  }
-  if (typeof value === "string" && BASE10_INT_RE.test(value)) {
-    const parsed = BigInt(value);
-    if (parsed >= MIN_SAFE_INTEGER && parsed <= MAX_SAFE_INTEGER) {
-      return { ok: true, value: Number(parsed) };
-    }
-  }
-  return invalidInteger(value, name);
-}
+import {
+  coerceObviousBase10Int as coerceObviousBase10Int2
+} from "@jarkkojs/readseek-api";
 
 // src/tui-source-render.ts
 import { getLanguageFromPath, highlightCode } from "@earendil-works/pi-coding-agent";
@@ -4019,15 +3975,15 @@ async function executeGrep(opts) {
   const { toolCallId, params, signal, onUpdate, cwd, onFileAnchored } = opts;
   await ensureHashInit();
   const rawParams = params;
-  const context = coerceObviousBase10Int(rawParams.context, "context");
+  const context = coerceObviousBase10Int2(rawParams.context, "context");
   if (!context.ok) {
     return buildToolErrorResult("grep", "invalid-params-combo", context.message);
   }
-  const limit = coerceObviousBase10Int(rawParams.limit, "limit");
+  const limit = coerceObviousBase10Int2(rawParams.limit, "limit");
   if (!limit.ok) {
     return buildToolErrorResult("grep", "invalid-limit", limit.message);
   }
-  const scopeContext = coerceObviousBase10Int(rawParams.scopeContext, "scopeContext");
+  const scopeContext = coerceObviousBase10Int2(rawParams.scopeContext, "scopeContext");
   if (!scopeContext.ok) {
     return buildToolErrorResult("grep", "invalid-params-combo", scopeContext.message);
   }
@@ -4055,7 +4011,7 @@ async function executeGrep(opts) {
   if (!textBlock?.text)
     return result;
   const { path: rawSearchPath } = p;
-  const searchPath = resolveToCwd(rawSearchPath || ".", cwd);
+  const searchPath = resolveToCwd2(rawSearchPath || ".", cwd);
   let searchPathIsDirectory = false;
   try {
     searchPathIsDirectory = (await fsStat(searchPath)).isDirectory();
@@ -4481,7 +4437,7 @@ async function executeSearch(opts) {
   const ignoredError = validateIgnoredRequiresOthers("search", p);
   if (ignoredError)
     return ignoredError;
-  const searchPath = resolveToCwd(p.path ?? ".", cwd);
+  const searchPath = resolveToCwd2(p.path ?? ".", cwd);
   const statResult = await statSearchPathOrError("search", p.path, searchPath);
   if (!statResult.ok)
     return statResult.error;
@@ -4656,7 +4612,7 @@ async function executeRefs(opts) {
   if (!scopeError.ok) {
     return buildToolErrorResult("refs", "invalid-parameter", `refs parameter: ${scopeError.error}`);
   }
-  const searchPath = resolveToCwd(p.path ?? ".", cwd);
+  const searchPath = resolveToCwd2(p.path ?? ".", cwd);
   const statResult = await statSearchPathOrError("refs", p.path, searchPath);
   if (!statResult.ok)
     return statResult.error;
@@ -4762,7 +4718,7 @@ async function executeRename(opts) {
   if (p.column !== undefined && (!Number.isSafeInteger(p.column) || p.column < 1)) {
     return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'column' must be a positive integer");
   }
-  const filePath = resolveToCwd(p.path, cwd);
+  const filePath = resolveToCwd2(p.path, cwd);
   try {
     const output = await readSeekRename(filePath, {
       to: p.to,
@@ -4885,8 +4841,8 @@ import { Text as Text6 } from "@earendil-works/pi-tui";
 import { Type as Type8 } from "@sinclair/typebox";
 
 // src/pending-diff-preview.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, realpathSync, statSync as statSync3 } from "node:fs";
-import { dirname, isAbsolute as isAbsolute2, relative as relative2, resolve, sep } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync, statSync as statSync4 } from "node:fs";
+import { dirname, isAbsolute, relative as relative2, resolve, sep } from "node:path";
 var PENDING_DIFF_MAX_BYTES = 1024 * 1024;
 function skip(reason) {
   return { type: "skip", reason };
@@ -4900,9 +4856,9 @@ function resolveWorkspacePreviewPath(rawPath, cwd, allowMissing) {
     return { type: "skip", reason: "missing path" };
   const workspace = realpathSync(cwd);
   const normalizedPath = rawPath.replace(/^@/, "");
-  const explicitAbsolute = isAbsolute2(normalizedPath);
+  const explicitAbsolute = isAbsolute(normalizedPath);
   const requested = resolve(workspace, normalizedPath);
-  if (existsSync2(requested)) {
+  if (existsSync3(requested)) {
     const realTarget = realpathSync(requested);
     if (!explicitAbsolute && !isInsidePath(workspace, realTarget))
       return { type: "skip", reason: "path outside workspace" };
@@ -4913,17 +4869,17 @@ function resolveWorkspacePreviewPath(rawPath, cwd, allowMissing) {
   if (!allowMissing)
     return { type: "skip", reason: "file not found" };
   const parent = dirname(requested);
-  if (!existsSync2(parent))
+  if (!existsSync3(parent))
     return { type: "skip", reason: "parent directory not found" };
   return { type: "ok", path: requested, existed: false };
 }
 function readUtf8File(filePath) {
-  const stat2 = statSync3(filePath);
-  if (!stat2.isFile())
+  const stat = statSync4(filePath);
+  if (!stat.isFile())
     return { type: "skip", reason: "not a file" };
-  if (stat2.size > PENDING_DIFF_MAX_BYTES)
+  if (stat.size > PENDING_DIFF_MAX_BYTES)
     return { type: "skip", reason: "file too large" };
-  const content = readFileSync3(filePath, "utf-8");
+  const content = readFileSync2(filePath, "utf-8");
   if (content.includes("\x00"))
     return { type: "skip", reason: "binary file" };
   return { type: "ok", content };
@@ -5184,7 +5140,7 @@ function registerWriteTool(pi, options = {}) {
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const cwd = ctx?.cwd ?? process.cwd();
-      const absolutePath = resolveToCwd(params.path, cwd);
+      const absolutePath = resolveToCwd2(params.path, cwd);
       try {
         return await withFileMutationQueue2(absolutePath, async () => {
           let result;
@@ -5294,7 +5250,7 @@ async function executeDef(opts) {
   if (!p.name || !p.name.trim()) {
     return buildToolErrorResult("def", "invalid-parameter", "readSeek_def requires 'name'");
   }
-  const searchPath = resolveToCwd(p.path ?? ".", cwd);
+  const searchPath = resolveToCwd2(p.path ?? ".", cwd);
   const statResult = await statSearchPathOrError("def", p.path, searchPath);
   if (!statResult.ok)
     return statResult.error;
@@ -5506,12 +5462,12 @@ async function executeDigest(opts) {
   }
   const facets = selectedFacets(select);
   const appliesImagePolicy = opts.imageMode !== undefined && facets.includes("content");
-  const end = coerceObviousBase10Int(p.end, "end");
+  const end = coerceObviousBase10Int2(p.end, "end");
   if (!end.ok || end.value !== undefined && end.value < 1) {
     const message = end.ok ? `Invalid end: expected a positive integer, received ${end.value}.` : end.message;
     return buildToolErrorResult("digest", "invalid-parameter", message, { path: p.path });
   }
-  const limit = coerceObviousBase10Int(p.limit, "limit");
+  const limit = coerceObviousBase10Int2(p.limit, "limit");
   if (!limit.ok || limit.value !== undefined && limit.value < 1) {
     const message = limit.ok ? `Invalid limit: expected a positive integer, received ${limit.value}.` : limit.message;
     return buildToolErrorResult("digest", "invalid-parameter", message, { path: p.path });
@@ -5527,7 +5483,7 @@ async function executeDigest(opts) {
       path: p.path
     });
   }
-  const filePath = resolveToCwd(p.path, cwd);
+  const filePath = resolveToCwd2(p.path, cwd);
   const commonOptions = { select, signal };
   const textOptions = {
     ...commonOptions,
@@ -5665,12 +5621,12 @@ var VIEW_PROMPT_METADATA = defineToolPromptMetadata({
 async function executeView(opts) {
   const { params, signal, cwd } = opts;
   const input = params;
-  const page = coerceObviousBase10Int(input.page, "page");
+  const page = coerceObviousBase10Int2(input.page, "page");
   if (!page.ok || page.value !== undefined && page.value < 1) {
     const message = page.ok ? `Invalid page: expected a positive integer, received ${page.value}.` : page.message;
     return buildToolErrorResult("view", "invalid-page", message, { path: input.path });
   }
-  const depth = coerceObviousBase10Int(input.depth, "depth");
+  const depth = coerceObviousBase10Int2(input.depth, "depth");
   if (!depth.ok || depth.value !== undefined && depth.value < 0) {
     const message = depth.ok ? `Invalid depth: expected a non-negative integer, received ${depth.value}.` : depth.message;
     return buildToolErrorResult("view", "invalid-depth", message, { path: input.path });
@@ -5691,7 +5647,7 @@ async function executeView(opts) {
       path: input.path
     });
   }
-  const filePath = resolveToCwd(input.path, cwd);
+  const filePath = resolveToCwd2(input.path, cwd);
   try {
     const output = await readSeekView(filePath, {
       node,
@@ -5823,7 +5779,6 @@ function piReadSeekExtension(pi) {
   const forgetAnchors = (absolutePath) => sessionAnchors.forget(absolutePath);
   const { settings } = resolveReadSeekJsonSettings();
   const replacedBuiltIns = new Set(settings.overrideTools ?? []);
-  const binaryAvailable = readSeekBinaryAvailability().available;
   const swap = (builtIn, readSeekName) => replacedBuiltIns.has(builtIn) ? builtIn : readSeekName;
   const readName = swap("read", "readSeek_digest");
   const editName = swap("edit", "readSeek_edit");
@@ -5853,8 +5808,24 @@ function piReadSeekExtension(pi) {
   });
   registerViewTool(pi);
   registerWriteTool(pi, { onFileAnchored: markAnchored, name: writeName });
+  const activeReadSeekNames = READSEEK_TOOL_ENTRIES.map((entry) => entry.builtIn && replacedBuiltIns.has(entry.builtIn) ? entry.builtIn : entry.readSeekName);
+  const inactiveReadSeekNames = new Set(READSEEK_TOOL_ENTRIES.filter((entry) => entry.builtIn !== null && replacedBuiltIns.has(entry.builtIn)).map((entry) => entry.readSeekName));
+  const activateReadSeekTools = () => {
+    if (!readSeekBinaryAvailability().available)
+      return false;
+    const current = pi.getActiveTools();
+    const currentSet = new Set(current);
+    const missing = activeReadSeekNames.some((name) => !currentSet.has(name));
+    const extraInactive = current.some((name) => inactiveReadSeekNames.has(name));
+    if (!missing && !extraInactive)
+      return true;
+    pi.setActiveTools([
+      ...new Set([...current, ...activeReadSeekNames].filter((name) => !inactiveReadSeekNames.has(name)))
+    ]);
+    return true;
+  };
   pi.on("before_agent_start", (event) => {
-    if (!binaryAvailable)
+    if (!activateReadSeekTools())
       return;
     return { systemPrompt: `${event.systemPrompt}
 
@@ -5874,12 +5845,7 @@ ${toolRoutingPolicy(policyAliases)}` };
       else
         console.warn(problem);
     }
-    if (!availability.available)
-      return;
-    const activeReadSeekNames = READSEEK_TOOL_ENTRIES.map((entry) => entry.builtIn && replacedBuiltIns.has(entry.builtIn) ? entry.builtIn : entry.readSeekName);
-    const inactiveReadSeekNames = new Set(READSEEK_TOOL_ENTRIES.filter((entry) => entry.builtIn !== null && replacedBuiltIns.has(entry.builtIn)).map((entry) => entry.readSeekName));
-    const activeTools = [...pi.getActiveTools(), ...activeReadSeekNames].filter((name) => !inactiveReadSeekNames.has(name));
-    pi.setActiveTools([...new Set(activeTools)]);
+    activateReadSeekTools();
   });
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-readseek",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "Pi extension for LINE:HASH-anchored file operations and structural code navigation",
   "type": "module",
   "exports": {
@@ -27,7 +27,6 @@
   "files": [
     "dist/",
     "prompts/",
-    "LICENSE",
     "README.md"
   ],
   "scripts": {
@@ -40,7 +39,8 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@jarkkojs/readseek": "^0.9.12",
+    "@jarkkojs/readseek": "^0.9.14",
+    "@jarkkojs/readseek-api": "^0.9.14",
     "diff": "^9.0.0",
     "xxhash-wasm": "^1.1.0"
   },
@@ -50,13 +50,13 @@
     "@sinclair/typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.82.1",
-    "@earendil-works/pi-coding-agent": "^0.82.1",
-    "@earendil-works/pi-tui": "^0.82.1",
+    "@earendil-works/pi-ai": "^0.84.2",
+    "@earendil-works/pi-coding-agent": "^0.84.2",
+    "@earendil-works/pi-tui": "^0.84.2",
     "@sinclair/typebox": "^0.34.48",
     "@types/node": "^26.1.1",
     "jiti": "^2.7.0",
-    "typescript": "^7.0.2",
+    "typescript": "^5.9.3",
     "vitest": "^4.1.0"
   },
   "directories": {

package/prompts/edit.md

@@ -24,15 +24,15 @@ plain file content, not a diff or hashline output.
 {
   "path": "src/foo.ts",
   "edits": [
-    { "set_line": { "anchor": "42:ab1", "new_text": "const x = 2;" } },
+    { "set_line": { "anchor": "42:ab1cde", "new_text": "const x = 2;" } },
     {
       "replace_lines": {
-        "start_anchor": "50:c3d",
-        "end_anchor": "55:e4f",
+        "start_anchor": "50:c3d4e5",
+        "end_anchor": "55:e4f5a6",
         "new_text": "const y = 3;\nreturn y;"
       }
     },
-    { "insert_after": { "anchor": "60:f5a", "new_text": "// TODO\n" } }
+    { "insert_after": { "anchor": "60:f5a6b7", "new_text": "// TODO\n" } }
   ]
 }
 ```

package/LICENSE

@@ -1,176 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS