@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/grammar-source.js

@@ -0,0 +1,229 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { getPackageRoot } from "./package-root.js";
+export const TREE_SITTER_WASMS_VERSION = "0.1.13";
+const GRAMMAR_CDN_BASE = `https://unpkg.com/tree-sitter-wasms@${TREE_SITTER_WASMS_VERSION}/out`;
+export const GRAMMAR_SOURCE_OVERRIDES = {
+  "tree-sitter-lua.wasm": {
+    package: "@tree-sitter-grammars/tree-sitter-lua",
+    version: "0.4.1",
+    url: "https://unpkg.com/@tree-sitter-grammars/tree-sitter-lua@0.4.1/tree-sitter-lua.wasm"
+  },
+  "tree-sitter-yaml.wasm": {
+    package: "@tree-sitter-grammars/tree-sitter-yaml",
+    version: "0.7.1",
+    url: "https://unpkg.com/@tree-sitter-grammars/tree-sitter-yaml@0.7.1/tree-sitter-yaml.wasm"
+  },
+  "tree-sitter-bash.wasm": {
+    package: "tree-sitter-bash",
+    version: "0.25.1",
+    url: "https://unpkg.com/tree-sitter-bash@0.25.1/tree-sitter-bash.wasm"
+  }
+};
+export function grammarSourceUrl(filename) {
+  return GRAMMAR_SOURCE_OVERRIDES[filename]?.url ?? `${GRAMMAR_CDN_BASE}/${filename}`;
+}
+export const VENDORED_GRAMMARS = {
+  "tree-sitter-cue.wasm": {
+    repo: "https://github.com/eonpatapon/tree-sitter-cue",
+    commit: "dd7b90e0770ff18070c515937ba3c3d6d93db00e",
+    license: "MIT",
+    buildCommand: "npx tree-sitter-cli build --wasm"
+  }
+};
+export function isVendoredGrammar(filename) {
+  return Object.hasOwn(VENDORED_GRAMMARS, filename);
+}
+export function vendoredGrammarRefusal(filename) {
+  return {
+    ok: false,
+    retryable: false,
+    reason: `${filename} is built in-house and ships in vendor/grammars/; it has no ` + `download source, so a missing copy means the install is incomplete.`
+  };
+}
+export function vendoredGrammarsDir() {
+  return path.join(getPackageRoot(import.meta.url), "vendor", "grammars");
+}
+export const LANGUAGE_TO_GRAMMAR = {
+  typescript: "tree-sitter-typescript.wasm",
+  tsx: "tree-sitter-tsx.wasm",
+  javascript: "tree-sitter-javascript.wasm",
+  python: "tree-sitter-python.wasm",
+  rust: "tree-sitter-rust.wasm",
+  go: "tree-sitter-go.wasm",
+  java: "tree-sitter-java.wasm",
+  kotlin: "tree-sitter-kotlin.wasm",
+  dart: "tree-sitter-dart.wasm",
+  c: "tree-sitter-c.wasm",
+  cpp: "tree-sitter-cpp.wasm",
+  elixir: "tree-sitter-elixir.wasm",
+  ruby: "tree-sitter-ruby.wasm",
+  bash: "tree-sitter-bash.wasm",
+  csharp: "tree-sitter-c_sharp.wasm",
+  css: "tree-sitter-css.wasm",
+  html: "tree-sitter-html.wasm",
+  json: "tree-sitter-json.wasm",
+  lua: "tree-sitter-lua.wasm",
+  ocaml: "tree-sitter-ocaml.wasm",
+  php: "tree-sitter-php.wasm",
+  swift: "tree-sitter-swift.wasm",
+  toml: "tree-sitter-toml.wasm",
+  vue: "tree-sitter-vue.wasm",
+  yaml: "tree-sitter-yaml.wasm",
+  zig: "tree-sitter-zig.wasm",
+  cue: "tree-sitter-cue.wasm"
+};
+export const GRAMMAR_FILES = [
+  ...new Set(Object.values(LANGUAGE_TO_GRAMMAR))
+];
+export const BLOCKED_GRAMMARS = {
+  "tree-sitter-swift.wasm": {
+    blocked: ({ isV8, nodeMajor }) => isV8 && nodeMajor >= 24,
+    reason: "tree-sitter-swift crashes the runtime on Node >= 24 (V8 Turboshaft WASM OOM, #423/#432); skipped so the process degrades gracefully instead of aborting."
+  }
+};
+function currentGrammarRuntime() {
+  const m = /^v?(\d+)/.exec(process.versions?.node ?? "");
+  return {
+    nodeMajor: m ? Number(m[1]) : 0,
+    isV8: !process.versions.bun && Boolean(process.versions.v8),
+    platform: process.platform
+  };
+}
+export function grammarBlockReason(filename, rt = currentGrammarRuntime()) {
+  if (process.env.PILENS_UNSAFE_FORCE_GRAMMAR_LOAD === "1")
+    return null;
+  const block = BLOCKED_GRAMMARS[filename];
+  return block?.blocked(rt) ? block.reason : null;
+}
+const WASM_MAGIC = [0, 97, 115, 109];
+export function hasWasmMagic(bytes) {
+  if (bytes.length < WASM_MAGIC.length)
+    return false;
+  return WASM_MAGIC.every((byte, i) => bytes[i] === byte);
+}
+export function fileHasWasmMagic(filePath) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, "r");
+    const head = Buffer.alloc(WASM_MAGIC.length);
+    const read = fs.readSync(fd, head, 0, head.length, 0);
+    return read === head.length && hasWasmMagic(head);
+  } catch {
+    return false;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch {}
+    }
+  }
+}
+const HTML_PREFIXES = ["<!doctype html", "<html", "<head", "<?xml"];
+export function describeNonWasmBody(bytes) {
+  if (bytes.length === 0) {
+    return "The download returned an empty body (0 bytes) instead of a wasm module.";
+  }
+  const head = Buffer.from(bytes.subarray(0, Math.min(16, bytes.length))).toString("latin1");
+  const lead = head.trimStart().toLowerCase();
+  const shape = HTML_PREFIXES.some((prefix) => lead.startsWith(prefix)) ? "an HTML page (a captive portal or proxy intercepted the request)" : "non-wasm data";
+  const magic = Buffer.from(bytes.subarray(0, WASM_MAGIC.length)).toString("hex").replace(/../g, "$& ").trim();
+  return `The download returned ${shape} — ` + `${bytes.length} bytes starting ${magic}, not a wasm module.`;
+}
+let manifestOverride;
+let cachedManifest;
+function grammarManifestPath() {
+  return path.join(getPackageRoot(import.meta.url), "scripts", "grammars.lock.json");
+}
+function resolveGrammarManifest() {
+  if (manifestOverride !== undefined)
+    return manifestOverride;
+  if (cachedManifest !== undefined)
+    return cachedManifest;
+  try {
+    const raw = fs.readFileSync(grammarManifestPath(), "utf-8");
+    cachedManifest = JSON.parse(raw);
+  } catch {
+    cachedManifest = null;
+  }
+  return cachedManifest;
+}
+function loadGrammarManifest() {
+  const manifest = resolveGrammarManifest();
+  if (manifest === null) {
+    recordDegradationOnce({
+      kind: "grammar-blocked",
+      subject: "grammars.lock.json",
+      reason: "the pinned sha256 manifest is unavailable — runtime grammar downloads " + "fall back to the weaker Content-Length check (or no integrity check at " + "all for a source with neither)."
+    });
+  }
+  return manifest;
+}
+export function _setGrammarManifestForTests(manifest) {
+  manifestOverride = manifest;
+}
+function sha256Hex(data) {
+  return `sha256:${createHash("sha256").update(data).digest("hex")}`;
+}
+export function pinnedGrammarHash(filename) {
+  return loadGrammarManifest()?.grammars[filename];
+}
+export function grammarFileSha256(filePath) {
+  try {
+    return sha256Hex(fs.readFileSync(filePath));
+  } catch {
+    return;
+  }
+}
+function shortHash(hash) {
+  const hex = hash.startsWith("sha256:") ? hash.slice("sha256:".length) : hash;
+  return `sha256:${hex.slice(0, 12)}…`;
+}
+export async function downloadGrammarDetailed(destDir, filename) {
+  if (isVendoredGrammar(filename))
+    return vendoredGrammarRefusal(filename);
+  try {
+    fs.mkdirSync(destDir, { recursive: true });
+    const res = await fetch(grammarSourceUrl(filename));
+    if (!res.ok) {
+      const retryable = res.status !== 404 && res.status !== 410;
+      return { ok: false, retryable };
+    }
+    const data = Buffer.from(await res.arrayBuffer());
+    if (!hasWasmMagic(data)) {
+      return { ok: false, retryable: true, reason: describeNonWasmBody(data) };
+    }
+    const declaredLength = res.headers.get("content-length");
+    if (declaredLength !== null) {
+      const expectedBytes = Number.parseInt(declaredLength, 10);
+      if (Number.isFinite(expectedBytes) && expectedBytes !== data.length) {
+        return {
+          ok: false,
+          retryable: true,
+          reason: `The download reported Content-Length: ${expectedBytes} but only ` + `${data.length} bytes arrived — a truncated transfer.`
+        };
+      }
+    }
+    const expectedHash = loadGrammarManifest()?.grammars[filename];
+    if (expectedHash) {
+      const actualHash = sha256Hex(data);
+      if (actualHash !== expectedHash) {
+        return {
+          ok: false,
+          retryable: true,
+          reason: `The download's sha256 (${shortHash(actualHash)}) does not match the ` + `pinned manifest (${shortHash(expectedHash)}) — a corrupt or truncated transfer.`
+        };
+      }
+    }
+    writeFileAtomic(path.join(destDir, filename), data, { bestEffort: false });
+    return { ok: true, retryable: true };
+  } catch {
+    return { ok: false, retryable: true };
+  }
+}
+export async function downloadGrammar(destDir, filename) {
+  return (await downloadGrammarDetailed(destDir, filename)).ok;
+}

package/extensions/dm-lens/dist/clients/grammar-wasm-imports.js

@@ -0,0 +1,48 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { getPackageRoot } from "./package-root.js";
+const requireFromHere = createRequire(import.meta.url);
+export const ADMITTED_UNRESOLVED_IMPORTS = {
+  __assert_fail: "C assert(): only reached after an invariant already broke",
+  abort: "C abort(): the grammar ends the process deliberately"
+};
+const wasm = globalThis.WebAssembly;
+function runtimeDir() {
+  return dirname(requireFromHere.resolve("web-tree-sitter"));
+}
+export function runtimeExports() {
+  const module = new wasm.Module(fs.readFileSync(join(runtimeDir(), "tree-sitter.wasm")));
+  return new Set(wasm.Module.exports(module).map((entry) => entry.name));
+}
+export function unresolvedImports(wasmBytes, exported) {
+  const unresolved = [];
+  for (const { kind, module, name } of wasm.Module.imports(new wasm.Module(wasmBytes))) {
+    if (kind !== "function" || module !== "env")
+      continue;
+    if (exported.has(name) || exported.has(`_${name}`))
+      continue;
+    if (Object.hasOwn(ADMITTED_UNRESOLVED_IMPORTS, name))
+      continue;
+    unresolved.push(name);
+  }
+  return unresolved;
+}
+export function grammarWasmFiles() {
+  const root = getPackageRoot(import.meta.url);
+  const byName = new Map;
+  for (const dir of [
+    join(root, "vendor", "grammars"),
+    join(root, "grammars"),
+    join(runtimeDir(), "grammars")
+  ]) {
+    if (!fs.existsSync(dir))
+      continue;
+    for (const name of fs.readdirSync(dir)) {
+      if (name.endsWith(".wasm") && !byName.has(name)) {
+        byName.set(name, join(dir, name));
+      }
+    }
+  }
+  return byName;
+}

package/extensions/dm-lens/dist/clients/gzip-stage-write.js

@@ -0,0 +1,93 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { parentPort } from "node:worker_threads";
+import { createGzip } from "node:zlib";
+import { stagePathFor } from "./atomic-write-staging.js";
+export async function writeGzipStageFile(data, stagePath, testDelayMs, options) {
+  const startedAt = performance.now();
+  const tmpPath = stagePathFor(stagePath);
+  try {
+    if (testDelayMs) {
+      await new Promise((resolve) => setTimeout(resolve, testDelayMs));
+    }
+    const serializeStarted = performance.now();
+    const body = data instanceof Uint8Array ? data : JSON.stringify(data);
+    const serializeMs = performance.now() - serializeStarted;
+    const rawBytes = Buffer.byteLength(body);
+    const semanticFingerprint = options?.semanticFingerprint?.(body);
+    if (semanticFingerprint !== undefined && options?.skipIfFingerprints?.includes(semanticFingerprint)) {
+      return {
+        rawBytes,
+        gzBytes: 0,
+        serializeMs,
+        writeMs: 0,
+        durationMs: performance.now() - startedAt,
+        semanticFingerprint,
+        skippedUnchanged: true
+      };
+    }
+    const writeStarted = performance.now();
+    await fs.promises.mkdir(path.dirname(stagePath), { recursive: true });
+    const chunks = function* () {
+      const chunkSize = 256 * 1024;
+      let offset = 0;
+      while (offset < body.length) {
+        let end = Math.min(offset + chunkSize, body.length);
+        if (typeof body === "string" && end < body.length) {
+          const last = body.charCodeAt(end - 1);
+          if (last >= 55296 && last <= 56319)
+            end--;
+        }
+        yield typeof body === "string" ? body.slice(offset, end) : body.subarray(offset, end);
+        offset = end;
+      }
+    };
+    await pipeline(Readable.from(chunks()), createGzip(), fs.createWriteStream(tmpPath));
+    await fs.promises.rename(tmpPath, stagePath);
+    const writeMs = performance.now() - writeStarted;
+    const gzBytes = (await fs.promises.stat(stagePath)).size;
+    return {
+      rawBytes,
+      gzBytes,
+      serializeMs,
+      writeMs,
+      durationMs: performance.now() - startedAt,
+      semanticFingerprint
+    };
+  } catch (err) {
+    await fs.promises.rm(tmpPath, { force: true }).catch(() => {});
+    throw err;
+  }
+}
+export function serveGzipStageWorker(buildBaseResult, options) {
+  const port = parentPort;
+  if (!port) {
+    throw new Error("gzip stage persist worker requires a parent port");
+  }
+  port.on("message", (request) => {
+    (async () => {
+      const result = {
+        ...buildBaseResult(request)
+      };
+      try {
+        const fingerprint = options?.semanticFingerprint;
+        const metrics = await writeGzipStageFile(request.data, request.stagePath, request.testDelayMs, {
+          semanticFingerprint: fingerprint ? (body) => fingerprint(request, body) : undefined,
+          skipIfFingerprints: options?.skipIfFingerprints?.(request)
+        });
+        result.rawBytes = metrics.rawBytes;
+        result.gzBytes = metrics.gzBytes;
+        result.serializeMs = metrics.serializeMs;
+        result.writeMs = metrics.writeMs;
+        result.durationMs = metrics.durationMs;
+        result.semanticFingerprint = metrics.semanticFingerprint;
+        result.skippedUnchanged = metrics.skippedUnchanged;
+      } catch (err) {
+        result.error = err instanceof Error ? err.message : String(err);
+      }
+      port.postMessage(result);
+    })();
+  });
+}

package/extensions/dm-lens/dist/clients/hard-failure-summary.js

@@ -0,0 +1,28 @@
+export function isHardFailureSummary(summary) {
+  return /(timed out|killed|SIGTERM|SIGKILL|SIGABRT)/i.test(summary);
+}
+export const HARD_FAILURE_BACKOFF_MS = 30 * 60 * 1000;
+
+export class HardFailureStamps {
+  stamps = new Map;
+  settle(key, result) {
+    if (result.success)
+      this.stamps.delete(key);
+    else if (isHardFailureSummary(result.summary)) {
+      this.stamps.set(key, { at: Date.now(), summary: result.summary });
+    }
+  }
+  recent(key) {
+    const stamp = this.stamps.get(key);
+    if (!stamp)
+      return null;
+    if (Date.now() - stamp.at > HARD_FAILURE_BACKOFF_MS) {
+      this.stamps.delete(key);
+      return null;
+    }
+    return stamp.summary;
+  }
+  clear() {
+    this.stamps.clear();
+  }
+}

package/extensions/dm-lens/dist/clients/hashline-anchor.js

@@ -0,0 +1,222 @@
+import * as nodeFs from "node:fs";
+import { BoundedFifoMap } from "./bounded-cache.js";
+const HASHLINE_ANCHOR_LENGTH = 3;
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const HASH_SPACE = ALPHABET.length ** HASHLINE_ANCHOR_LENGTH;
+const HASH_PROBE_STRIDE = ALPHABET.length ** 2 + ALPHABET.length + 1;
+const MAX_HASH_SOURCE_BYTES = 500;
+const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
+const ANCHOR_TOKEN_RE = /^[A-Za-z0-9]{3}$/;
+const XXH_PRIME1 = 2654435761;
+const XXH_PRIME2 = 2246822519;
+const XXH_PRIME3 = 3266489917;
+const XXH_PRIME4 = 668265263;
+const XXH_PRIME5 = 374761393;
+function rotl32(value, bits) {
+  return value << bits | value >>> 32 - bits;
+}
+function xxhRound(acc, input) {
+  return Math.imul(rotl32(acc + Math.imul(input, XXH_PRIME2) | 0, 13), XXH_PRIME1) | 0;
+}
+export function xxh32Bytes(bytes) {
+  const length = bytes.length;
+  let index = 0;
+  let hash;
+  if (length >= 16) {
+    const limit = length - 16;
+    let v1 = XXH_PRIME1 + XXH_PRIME2 | 0;
+    let v2 = XXH_PRIME2 | 0;
+    let v3 = 0;
+    let v4 = -XXH_PRIME1 | 0;
+    do {
+      v1 = xxhRound(v1, readU32(bytes, index));
+      v2 = xxhRound(v2, readU32(bytes, index + 4));
+      v3 = xxhRound(v3, readU32(bytes, index + 8));
+      v4 = xxhRound(v4, readU32(bytes, index + 12));
+      index += 16;
+    } while (index <= limit);
+    hash = rotl32(v1, 1) + rotl32(v2, 7) + rotl32(v3, 12) + rotl32(v4, 18) | 0;
+  } else {
+    hash = XXH_PRIME5 | 0;
+  }
+  hash = hash + length | 0;
+  while (index + 4 <= length) {
+    hash = Math.imul(rotl32(hash + Math.imul(readU32(bytes, index), XXH_PRIME3) | 0, 17), XXH_PRIME4) | 0;
+    index += 4;
+  }
+  while (index < length) {
+    hash = Math.imul(rotl32(hash + Math.imul(bytes[index], XXH_PRIME5) | 0, 11), XXH_PRIME1) | 0;
+    index += 1;
+  }
+  hash = hash ^ hash >>> 15 | 0;
+  hash = Math.imul(hash, XXH_PRIME2) | 0;
+  hash = hash ^ hash >>> 13 | 0;
+  hash = Math.imul(hash, XXH_PRIME3) | 0;
+  hash = hash ^ hash >>> 16 | 0;
+  return hash >>> 0;
+}
+function readU32(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24 | 0;
+}
+function canon(line) {
+  return line.replace(/\r/g, "").trimEnd();
+}
+function splitLines(text) {
+  if (text.length === 0)
+    return [""];
+  const lines = text.split(`
+`);
+  return text.endsWith(`
+`) ? lines.slice(0, -1) : lines;
+}
+function hashSourceBytes(line) {
+  const bytes = Buffer.from(canon(line), "utf8");
+  if (bytes.length <= MAX_HASH_SOURCE_BYTES)
+    return bytes;
+  let cut = MAX_HASH_SOURCE_BYTES;
+  while (cut > 0 && (bytes[cut] & 192) === 128)
+    cut -= 1;
+  return bytes.subarray(0, cut);
+}
+function hashSourceKey(line) {
+  return Buffer.from(hashSourceBytes(line)).toString("utf8");
+}
+function indexToAnchor(index) {
+  let out = "";
+  let remaining = index;
+  for (let digit = 0;digit < HASHLINE_ANCHOR_LENGTH; digit += 1) {
+    out = ALPHABET[remaining % ALPHABET.length] + out;
+    remaining = Math.floor(remaining / ALPHABET.length);
+  }
+  return out;
+}
+function getBit(bits, index) {
+  return (bits[index >>> 5] >>> (index & 31) & 1) !== 0;
+}
+function setBit(bits, index) {
+  bits[index >>> 5] |= 1 << (index & 31);
+}
+function nextZeroBit(bits, start) {
+  let index = start % HASH_SPACE;
+  for (let step = 0;step < HASH_SPACE; step += 1) {
+    if (!getBit(bits, index))
+      return index;
+    index += HASH_PROBE_STRIDE;
+    if (index >= HASH_SPACE)
+      index -= HASH_SPACE;
+  }
+  return -1;
+}
+export function computeHashlineAnchors(content) {
+  const lines = splitLines(content);
+  if (lines.length > HASH_SPACE)
+    return;
+  const anchors = [];
+  anchors.length = lines.length;
+  const used = new Uint32Array(BITSET_WORDS);
+  let hint = 0;
+  const sourceCache = new Map;
+  for (let i = 0;i < lines.length; i += 1) {
+    const line = lines[i];
+    let baseIndex = sourceCache.get(line);
+    if (baseIndex === undefined) {
+      baseIndex = (xxh32Bytes(hashSourceBytes(line)) >>> 14) % HASH_SPACE;
+      sourceCache.set(line, baseIndex);
+    }
+    if (!getBit(used, baseIndex)) {
+      setBit(used, baseIndex);
+      hint = baseIndex + HASH_PROBE_STRIDE;
+      anchors[i] = indexToAnchor(baseIndex);
+      continue;
+    }
+    const probed = nextZeroBit(used, hint);
+    if (probed < 0)
+      return;
+    setBit(used, probed);
+    hint = probed + HASH_PROBE_STRIDE;
+    anchors[i] = indexToAnchor(probed);
+  }
+  return anchors;
+}
+export function normalizeHashlineAnchorToken(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return ANCHOR_TOKEN_RE.test(trimmed) ? trimmed : undefined;
+}
+const MAX_ANCHOR_FILE_BYTES = 4 * 1024 * 1024;
+const ANCHOR_INDEX_CACHE_LIMIT = 8;
+const ANCHOR_INDEX_CACHE = new BoundedFifoMap(ANCHOR_INDEX_CACHE_LIMIT);
+export function dropHashlineAnchorMemo() {
+  ANCHOR_INDEX_CACHE.clear();
+}
+function buildAnchorIndex(filePath) {
+  let stats;
+  try {
+    stats = nodeFs.statSync(filePath);
+  } catch {
+    return { failure: "file_unreadable" };
+  }
+  if (!stats.isFile())
+    return { failure: "file_unreadable" };
+  if (stats.size > MAX_ANCHOR_FILE_BYTES)
+    return { failure: "file_too_large" };
+  const cached = ANCHOR_INDEX_CACHE.get(filePath);
+  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+    return { index: cached.index, contentUnique: cached.contentUnique };
+  }
+  let raw;
+  try {
+    raw = nodeFs.readFileSync(filePath, "utf8");
+  } catch {
+    return { failure: "file_unreadable" };
+  }
+  const normalized = (raw.startsWith("\uFEFF") ? raw.slice(1) : raw).replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+  const anchors = computeHashlineAnchors(normalized);
+  if (anchors === undefined)
+    return { failure: "file_too_large" };
+  const index = new Map;
+  for (let i = 0;i < anchors.length; i += 1) {
+    index.set(anchors[i], i + 1);
+  }
+  const lines = splitLines(normalized);
+  const keys = [];
+  keys.length = lines.length;
+  const keyCounts = new Map;
+  const keyCache = new Map;
+  for (let i = 0;i < lines.length; i += 1) {
+    const line = lines[i];
+    let key = keyCache.get(line);
+    if (key === undefined) {
+      key = hashSourceKey(line);
+      keyCache.set(line, key);
+    }
+    keys[i] = key;
+    keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
+  }
+  const contentUnique = keys.map((key) => keyCounts.get(key) === 1);
+  ANCHOR_INDEX_CACHE.set(filePath, {
+    mtimeMs: stats.mtimeMs,
+    size: stats.size,
+    index,
+    contentUnique
+  });
+  return { index, contentUnique };
+}
+export function resolveHashlineAnchor(filePath, anchor) {
+  const token = normalizeHashlineAnchorToken(anchor);
+  if (token === undefined)
+    return { failure: "not_an_anchor" };
+  const built = buildAnchorIndex(filePath);
+  if ("failure" in built)
+    return { failure: built.failure };
+  const line = built.index.get(token);
+  if (line === undefined)
+    return { failure: "anchor_not_found" };
+  if (built.contentUnique[line - 1] !== true) {
+    return { failure: "content_not_unique" };
+  }
+  return { line };
+}

package/extensions/dm-lens/dist/clients/hook-budgets.js

@@ -0,0 +1,17 @@
+export const HOOK_WALL_BUDGET_MS = Object.freeze({
+  session_start: 5000,
+  turn_start: 0,
+  turn_end: 3000,
+  agent_end: 1000,
+  agent_settled: 1e4,
+  tool_result_read_only: 500,
+  tool_result_edit: 1e4,
+  session_shutdown: 0,
+  session_shutdown_quit: 500,
+  context: 0,
+  session_before_fork: 0
+});
+export const HOOK_BUDGET_KEYS = Object.keys(HOOK_WALL_BUDGET_MS);
+export function isHookBudgetKey(value) {
+  return Object.hasOwn(HOOK_WALL_BUDGET_MS, value);
+}