@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/chunk-NL5GLMFI.js

@@ -0,0 +1,211 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  collectSourceFiles
+} from "./chunk-6QIUX4EP.js";
+import "./chunk-VHQLPIRJ.js";
+import "./chunk-VN2AXLEX.js";
+import "./chunk-QYF5S6P6.js";
+import "./chunk-5ZEJHV35.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/todo-scanner.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var MAX_SCAN_FILE_BYTES = 512 * 1024;
+var MARKDOWN_FILE_RE = /\.(?:md|mdx|markdown)$/i;
+var TodoScanner = class {
+  /**
+   * Pattern matches actionable annotations only.
+   * Excludes NOTE and DEPRECATED — these are documentation, not work items.
+   * Case-sensitive to avoid matching "Note:" in prose.
+   */
+  pattern = /\b(TODO|FIXME|HACK|XXX|BUG)\b\s*[(:]?\s*(.+)/g;
+  /**
+   * Check if a match position is inside a comment context.
+   * Handles: // line comments, star-slash block comments, * JSDoc lines, # Python comments
+   */
+  isInComment(line, matchIndex, markdown = false) {
+    if (markdown) {
+      const beforeMatch2 = line.slice(0, matchIndex);
+      const open = beforeMatch2.lastIndexOf("<!--");
+      return open !== -1 && beforeMatch2.lastIndexOf("-->") < open;
+    }
+    const trimmed = line.trimStart();
+    if (/^\/\/|^\/\*|^\*|^#/.test(trimmed))
+      return true;
+    const beforeMatch = line.slice(0, matchIndex);
+    const lineCommentPos = beforeMatch.lastIndexOf("//");
+    if (lineCommentPos !== -1) {
+      const beforeComment = beforeMatch.slice(0, lineCommentPos);
+      const singleQuotes = (beforeComment.match(/'/g) || []).length;
+      const doubleQuotes = (beforeComment.match(/"/g) || []).length;
+      const backticks = (beforeComment.match(/`/g) || []).length;
+      if (singleQuotes % 2 === 0 && doubleQuotes % 2 === 0 && backticks % 2 === 0) {
+        return true;
+      }
+    }
+    const blockOpen = beforeMatch.lastIndexOf("/*");
+    const blockClose = beforeMatch.lastIndexOf("*/");
+    if (blockOpen !== -1 && blockClose < blockOpen)
+      return true;
+    const hashPos = beforeMatch.lastIndexOf("#");
+    if (hashPos !== -1) {
+      const beforeHash = beforeMatch.slice(0, hashPos);
+      const singleQuotes = (beforeHash.match(/'/g) || []).length;
+      const doubleQuotes = (beforeHash.match(/"/g) || []).length;
+      if (singleQuotes % 2 === 0 && doubleQuotes % 2 === 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Scan a single file for TODOs.
+   */
+  scanFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    try {
+      const stat = fs.statSync(absolutePath);
+      if (!stat.isFile() || stat.size > MAX_SCAN_FILE_BYTES)
+        return [];
+    } catch {
+      return [];
+    }
+    let content;
+    try {
+      content = fs.readFileSync(absolutePath, "utf-8");
+    } catch {
+      return [];
+    }
+    const markdown = MARKDOWN_FILE_RE.test(absolutePath);
+    const lines = content.split("\n");
+    const items = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const matches = line.matchAll(this.pattern);
+      for (const match of matches) {
+        if (!this.isInComment(line, match.index ?? 0, markdown))
+          continue;
+        const type = match[1];
+        const message = (match[2] || "").trim().replace(/\s*\*\/\s*$/, "");
+        items.push({
+          type,
+          message: message.slice(0, 200),
+          // Limit message length
+          file: path.relative(process.cwd(), absolutePath),
+          line: i + 1,
+          column: match.index || 0
+        });
+      }
+    }
+    return items;
+  }
+  /**
+   * Scan a list of pre-filtered files (recommended — uses source-filter module).
+   * Callers should use collectSourceFiles() to get deduplicated source files.
+   */
+  scanFiles(filePaths) {
+    const items = [];
+    for (const filePath of filePaths) {
+      if (filePath.endsWith("todo-scanner.ts") || filePath.endsWith("todo-scanner.js"))
+        continue;
+      if (/\.(test|spec)\.[jt]sx?$/.test(filePath))
+        continue;
+      items.push(...this.scanFile(filePath));
+    }
+    return this.groupResults(items);
+  }
+  /**
+   * Scan a directory recursively using the source-filter module to exclude build artifacts.
+   * This is the preferred entry point for new callers.
+   */
+  scanDirectory(dirPath) {
+    const sourceFiles = collectSourceFiles(dirPath);
+    return this.scanFiles(sourceFiles);
+  }
+  /**
+   * Group scan results by type and file.
+   */
+  groupResults(items) {
+    const byType = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const existing = byType.get(item.type) || [];
+      existing.push(item);
+      byType.set(item.type, existing);
+    }
+    const byFile = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const existing = byFile.get(item.file) || [];
+      existing.push(item);
+      byFile.set(item.file, existing);
+    }
+    return { items, byType, byFile };
+  }
+  /**
+   * Format scan results for LLM consumption.
+   */
+  formatResult(result, maxItems = 30) {
+    if (result.items.length === 0)
+      return "";
+    let output = `[TODOs] ${result.items.length} annotation(s) found`;
+    const typeCounts = [];
+    for (const [type, items] of result.byType) {
+      typeCounts.push(`${items.length} ${type}`);
+    }
+    if (typeCounts.length > 0) {
+      output += ` (${typeCounts.join(", ")})`;
+    }
+    output += ":\n";
+    const priorityOrder = [
+      "FIXME",
+      "HACK",
+      "BUG",
+      "TODO",
+      "XXX"
+    ];
+    const sorted = [...result.items].sort((a, b) => {
+      const aIdx = priorityOrder.indexOf(a.type);
+      const bIdx = priorityOrder.indexOf(b.type);
+      return (aIdx === -1 ? 99 : aIdx) - (bIdx === -1 ? 99 : bIdx);
+    });
+    for (const item of sorted.slice(0, maxItems)) {
+      const icon = this.getIcon(item.type);
+      output += `  ${icon} ${item.file}:${item.line} \u2014 ${item.type}: ${item.message}
+`;
+    }
+    if (result.items.length > maxItems) {
+      output += `  ... and ${result.items.length - maxItems} more
+`;
+    }
+    return output;
+  }
+  getIcon(type) {
+    switch (type) {
+      case "FIXME":
+        return "\u{1F534}";
+      case "HACK":
+        return "\u{1F7E0}";
+      case "BUG":
+        return "\u{1F41B}";
+      case "TODO":
+        return "\u{1F4DD}";
+      case "XXX":
+        return "\u274C";
+      default:
+        return "\u2022";
+    }
+  }
+};
+export {
+  TodoScanner
+};

package/node_modules/pi-lens/dist/chunk-NMABWBZN.js

@@ -0,0 +1,327 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  BoundedLruCache
+} from "./chunk-ABBOA7UD.js";
+import {
+  normalizeMapKey
+} from "./chunk-Q5U6FMDI.js";
+
+// dist/clients/dispatch/fact-store.js
+var capacityEvictionReporter;
+function setFactStoreEvictionReporter(reporter) {
+  capacityEvictionReporter = reporter;
+}
+function getFactStoreEvictionReporter() {
+  return capacityEvictionReporter;
+}
+var MAX_FILE_FACT_RECORDS = 1024;
+var MAX_FILE_FACT_CONTENT_BYTES = 64 * 1024 * 1024;
+var MAX_SESSION_FACT_RECORDS = 4096;
+var FactStore = class {
+  subject;
+  // Insertion order is eviction order: the oldest-used record is evicted first.
+  fileFacts = /* @__PURE__ */ new Map();
+  sessionFacts = /* @__PURE__ */ new Map();
+  // Bounded sibling of `sessionFacts` for per-file-keyed session facts (#2282).
+  // True LRU: every fetch (get or create, see getBoundedSessionFact) refreshes
+  // recency, so the oldest-UNUSED record is evicted first, not merely the
+  // oldest-inserted.
+  boundedSessionFacts = new BoundedLruCache(MAX_SESSION_FACT_RECORDS);
+  // Keys evicted from `boundedSessionFacts` and not written since, so a reader
+  // can tell "evicted" from "never seen" (#2282). Same cap, same FIFO order.
+  evictedSessionFactKeys = /* @__PURE__ */ new Set();
+  // Pin refcount per file. A file is exempt from capacity eviction while its
+  // count is > 0. Refcounted, not a Set, so two overlapping dispatches of the
+  // same file both hold the pin until BOTH settle (#2243 item 2).
+  pinnedFiles = /* @__PURE__ */ new Map();
+  // Running UTF-8 byte total for file.content only. Maintaining it at every
+  // mutation keeps getFileFact/setFileFact O(1) amortized; never scan the map
+  // to decide whether the byte budget is exceeded.
+  retainedContentBytes = 0;
+  // Subset of retainedContentBytes held by currently pinned files (#2247
+  // review F2). Maintained incrementally the same way — a scan over
+  // `pinnedFiles` looks small in isolation, but `evictColdFileFacts` calls it
+  // on EVERY unpinned insert for as long as pinned bytes stay over budget, so
+  // a scan there would re-walk a large pinned file's full string on every
+  // single write admitted during that window. Keeping a running total avoids
+  // reintroducing exactly the scan `retainedContentBytes` exists to avoid.
+  pinnedContentBytesTotal = 0;
+  /**
+   * @param subject Discriminates this store's capacity-eviction telemetry
+   *   from every other production FactStore's (#2243 review round 3, F1).
+   *   Production callers pass a label naming the store (e.g. `"dispatch"`,
+   *   `"runtime-session-call-graph"`); the default is only for call sites
+   *   that never wired a reporter and tests that don't care.
+   */
+  constructor(subject = "session-fact-store") {
+    this.subject = subject;
+  }
+  // All file-keyed methods normalize the path internally via normalizeMapKey().
+  // Callers always pass raw/resolved paths — normalization is not their concern.
+  getFileFact(filePath, factId) {
+    return this.touchFileFacts(normalizeMapKey(filePath))?.get(factId);
+  }
+  setFileFact(filePath, factId, value) {
+    const key = normalizeMapKey(filePath);
+    let facts = this.touchFileFacts(key);
+    if (!facts) {
+      facts = /* @__PURE__ */ new Map();
+      this.fileFacts.set(key, facts);
+    }
+    if (factId === "file.content") {
+      const delta = this.contentBytes(value) - this.contentBytes(facts.get(factId));
+      this.retainedContentBytes += delta;
+      if (this.pinnedFiles.has(key))
+        this.pinnedContentBytesTotal += delta;
+    }
+    facts.set(factId, value);
+    this.evictColdFileFacts();
+  }
+  hasFileFact(filePath, factId) {
+    return this.fileFacts.get(normalizeMapKey(filePath))?.has(factId) ?? false;
+  }
+  /** Drop one file fact without disturbing the file's derived facts.
+   *  Removes the per-file entry too when the deleted fact was its last value. */
+  deleteFileFact(filePath, factId) {
+    const key = normalizeMapKey(filePath);
+    const facts = this.fileFacts.get(key);
+    if (!facts)
+      return;
+    if (factId === "file.content") {
+      const dropped = this.contentBytes(facts.get(factId));
+      this.retainedContentBytes -= dropped;
+      if (this.pinnedFiles.has(key))
+        this.pinnedContentBytesTotal -= dropped;
+    }
+    facts.delete(factId);
+    if (facts.size === 0)
+      this.fileFacts.delete(key);
+  }
+  /** Clear facts for one specific file only, and mark the file's dispatch as
+   *  begun. Use at the start of each per-file dispatch call.
+   *  Preserves facts for other files computed in the same turn.
+   *  Normalizes filePath internally — callers pass raw paths.
+   *  Pins the file against capacity eviction until the matching
+   *  {@link endDispatchFor} runs in the dispatch's settle path (#2243 item 2).
+   *  Every `clearFileFactsFor` MUST be paired with an `endDispatchFor`. */
+  clearFileFactsFor(filePath) {
+    const key = normalizeMapKey(filePath);
+    this.deleteFileFactsRecord(key);
+    this.pinFile(key);
+  }
+  /** Pin a file against capacity eviction for the duration of a dispatch,
+   *  WITHOUT clearing its existing facts. Pairs with {@link endDispatchFor}
+   *  exactly like {@link clearFileFactsFor} does.
+   *
+   *  #2243 review round 3 (F5): `clearFileFactsFor`'s clear+re-derive is
+   *  right for a dispatch driven by a fresh edit, but the debounced
+   *  ast-grep warning scan runs ~2s AFTER the inline dispatch for that same
+   *  edit already re-derived every fact for this exact file — a second
+   *  clear there bought nothing but ~51ms of redundant re-parsing across
+   *  all five providers (measured; a warm-cache read is ~1ms). Use this
+   *  where the facts are very likely already fresh: `runProviders` still
+   *  re-derives any fact this file is missing (a genuine miss, e.g. the
+   *  fact was evicted meanwhile), so a read never depends on staleness. */
+  beginDispatchFor(filePath) {
+    this.pinFile(normalizeMapKey(filePath));
+  }
+  /** Release the pin a {@link clearFileFactsFor} or {@link beginDispatchFor}
+   *  took for one file's dispatch. Call once per matching call, from the
+   *  dispatch's finally/settle path, so the pin set tracks dispatches
+   *  actually in flight rather than the last N files touched (#2243 item 2). */
+  endDispatchFor(filePath) {
+    this.unpinFile(normalizeMapKey(filePath));
+    this.evictColdFileFacts();
+  }
+  /** Clear one file's facts WITHOUT pinning. For sequential single-store scans
+   *  (project-diagnostics) that own their store and race no concurrent walk:
+   *  pinning there would exempt every scanned file from the capacity cap and
+   *  defeat it. Normalizes filePath internally. */
+  dropFileFacts(filePath) {
+    this.deleteFileFactsRecord(normalizeMapKey(filePath));
+  }
+  /** LRU touch: re-inserting an existing record moves it to the end of the
+   *  eviction order, so a record still in use is not the next victim. */
+  touchFileFacts(key) {
+    const facts = this.fileFacts.get(key);
+    if (!facts)
+      return void 0;
+    this.fileFacts.delete(key);
+    this.fileFacts.set(key, facts);
+    return facts;
+  }
+  pinFile(key) {
+    const count = this.pinnedFiles.get(key) ?? 0;
+    if (count === 0) {
+      this.pinnedContentBytesTotal += this.contentBytes(this.fileFacts.get(key)?.get("file.content"));
+    }
+    this.pinnedFiles.set(key, count + 1);
+  }
+  unpinFile(key) {
+    const count = this.pinnedFiles.get(key);
+    if (count === void 0)
+      return;
+    if (count <= 1) {
+      this.pinnedFiles.delete(key);
+      this.pinnedContentBytesTotal -= this.contentBytes(this.fileFacts.get(key)?.get("file.content"));
+    } else {
+      this.pinnedFiles.set(key, count - 1);
+    }
+  }
+  /** Drop least-recently-used records past either cap, skipping the files whose
+   *  dispatch pinned them. Pinned content counts toward the byte total, but is
+   *  never evicted before endDispatchFor. Pins survive until clearAll.
+   *
+   *  #2247 review F2: a leaked (or several overlapping) pin(s) can put pinned
+   *  bytes over budget ON THEIR OWN. Evicting every unpinned record can never
+   *  bring the total back under budget in that state — before this guard, the
+   *  loop below evicted each newly inserted unpinned record on the very next
+   *  call (it was always the sole remaining unpinned key), so unpinned writes
+   *  never retained anything: a silent, permanent collapse for the rest of
+   *  the process. Once byte pressure is unpinned-bytes-driven-only, stop
+   *  evicting and admit unpinned inserts as-is — best-effort under pin
+   *  pressure — and record the state distinctly so it is visible instead of
+   *  inferred from "the store stopped retaining anything". */
+  evictColdFileFacts() {
+    if (!this.overCapacity())
+      return;
+    for (const key of this.fileFacts.keys()) {
+      if (this.pinnedFiles.has(key))
+        continue;
+      const axis = this.capacityAxis();
+      if (axis === "bytes" && this.pinnedContentBytesTotal > MAX_FILE_FACT_CONTENT_BYTES) {
+        this.reportPinnedOverBudget();
+        return;
+      }
+      this.deleteFileFactsRecord(key);
+      this.reportCapacityEviction(key, axis);
+      if (!this.overCapacity())
+        return;
+    }
+  }
+  overCapacity() {
+    return this.fileFacts.size > MAX_FILE_FACT_RECORDS || this.retainedContentBytes > MAX_FILE_FACT_CONTENT_BYTES;
+  }
+  capacityAxis() {
+    return this.fileFacts.size > MAX_FILE_FACT_RECORDS ? "count" : "bytes";
+  }
+  contentBytes(value) {
+    return typeof value === "string" ? Buffer.byteLength(value, "utf8") : 0;
+  }
+  deleteFileFactsRecord(key) {
+    const facts = this.fileFacts.get(key);
+    if (!facts)
+      return;
+    const dropped = this.contentBytes(facts.get("file.content"));
+    this.retainedContentBytes -= dropped;
+    if (this.pinnedFiles.has(key))
+      this.pinnedContentBytesTotal -= dropped;
+    this.fileFacts.delete(key);
+  }
+  // #2243 item 4: the cap silently drops a fact a live dispatch may read back
+  // as "" (dispatcher.ts reads `file.content` with `?? ""`). Emit through the
+  // injected reporter so the drop is visible in the ledger instead of being
+  // inferred from a downstream symptom. integration.ts routes this to
+  // `recordDegradationOnce` keyed on THIS store's `subject` (#2243 review
+  // round 3, F1), so the ledger's own per-kind+subject dedupe yields exactly
+  // ONE record per session PER STORE (re-arming at session_start when the
+  // ledger resets) — no latch or generation compare here, so fact-store
+  // keeps no session-scoped state to forget to re-arm.
+  reportCapacityEviction(evictedKey, axis) {
+    capacityEvictionReporter?.(this.subject, axis, axis === "count" ? `file-fact store axis=count exceeded ${MAX_FILE_FACT_RECORDS} records; evicted least-recently-used fact for ${evictedKey}` : `file-fact store axis=bytes exceeded ${MAX_FILE_FACT_CONTENT_BYTES} retained content bytes; evicted least-recently-used fact for ${evictedKey}`);
+  }
+  // #2247 review F2: pinned bytes alone exceeding budget is not an eviction —
+  // nothing is dropped — so it is reported through a distinct axis rather
+  // than reusing `reportCapacityEviction`'s "evicted least-recently-used
+  // fact for X" language, which would misdescribe what happened.
+  reportPinnedOverBudget() {
+    const pinnedBytes = this.pinnedContentBytesTotal;
+    capacityEvictionReporter?.(this.subject, "pinned-over-budget", `file-fact store pinned content bytes (${pinnedBytes}) exceed the ${MAX_FILE_FACT_CONTENT_BYTES}-byte budget; unpinned inserts are admitted without eviction until a pin releases`);
+  }
+  /** Running UTF-8 byte total for retained `file.content` values. Exposed so
+   *  tests can crosscheck it against a fresh sum over retained records
+   *  (#2247 review F3) — the running total is maintained incrementally on
+   *  every insert/delete path rather than recomputed, so a subtraction
+   *  dropped from one of those paths would otherwise drift silently. */
+  getRetainedContentBytes() {
+    return this.retainedContentBytes;
+  }
+  /** Running UTF-8 byte total for the pinned SUBSET of retained
+   *  `file.content` values. Exposed so tests can crosscheck it against a
+   *  fresh sum over `pinnedFiles ∩ fileFacts` (#2247 review F4) — like
+   *  `retainedContentBytes`, it is maintained incrementally on the pin
+   *  0→1 transition, the unpin 1→0 transition, content overwrite/delete,
+   *  and `clearAll`, so a drop from any one of those paths would
+   *  otherwise drift silently instead of failing loudly. */
+  getPinnedContentBytes() {
+    return this.pinnedContentBytesTotal;
+  }
+  getSessionFact(factId) {
+    return this.sessionFacts.get(factId);
+  }
+  setSessionFact(factId, value) {
+    this.sessionFacts.set(factId, value);
+  }
+  hasSessionFact(factId) {
+    return this.sessionFacts.has(factId);
+  }
+  /** Bounded counterpart to {@link getSessionFact} for per-file-keyed session
+   *  facts (#2282) — session baselines, cascade baselines, review-graph entity
+   *  snapshots. LRU touch: a read moves the record off the eviction end. */
+  getBoundedSessionFact(factId) {
+    if (!this.boundedSessionFacts.has(factId))
+      return void 0;
+    return this.boundedSessionFacts.get(factId);
+  }
+  /** Bounded counterpart to {@link setSessionFact}. Callers use this instead
+   *  of `setSessionFact` for any family that mints one key per file/entity
+   *  touched, so the store's count stays bounded across a large batch instead
+   *  of retaining one entry per distinct path for the process lifetime. */
+  setBoundedSessionFact(factId, value) {
+    this.evictedSessionFactKeys.delete(factId);
+    const evicted = this.boundedSessionFacts.set(factId, value);
+    for (const [oldestKey] of evicted) {
+      this.evictedSessionFactKeys.add(oldestKey);
+      while (this.evictedSessionFactKeys.size > MAX_SESSION_FACT_RECORDS) {
+        const oldestTombstone = this.evictedSessionFactKeys.values().next().value;
+        if (oldestTombstone === void 0)
+          break;
+        this.evictedSessionFactKeys.delete(oldestTombstone);
+      }
+      capacityEvictionReporter?.(this.subject, "session-count", `session-fact store axis=count exceeded ${MAX_SESSION_FACT_RECORDS} records; evicted least-recently-used fact for ${oldestKey}`);
+    }
+  }
+  hasBoundedSessionFact(factId) {
+    return this.boundedSessionFacts.has(factId);
+  }
+  /** True when this key held a bounded session fact that capacity eviction
+   *  dropped and nothing has rewritten since (#2282). Readers whose "absent"
+   *  branch is not a safe default — the review-graph entity snapshot, where
+   *  absent would read as "every symbol is new" — use this to tell an evicted
+   *  key from one this session has never seen. */
+  wasBoundedSessionFactEvicted(factId) {
+    return this.evictedSessionFactKeys.has(factId);
+  }
+  /** O(1) entry count for memory-attribution sampling (#2282 Observability):
+   *  the fixed-vocabulary map plus the bounded per-file map, so a caller gets
+   *  this store's whole `sessionFacts` footprint in one number. */
+  getSessionFactEntryCount() {
+    return this.sessionFacts.size + this.boundedSessionFacts.size;
+  }
+  /** Call on session reset only. Clears everything including tool cache and baselines. */
+  clearAll() {
+    this.fileFacts.clear();
+    this.sessionFacts.clear();
+    this.boundedSessionFacts.clear();
+    this.evictedSessionFactKeys.clear();
+    this.pinnedFiles.clear();
+    this.retainedContentBytes = 0;
+    this.pinnedContentBytesTotal = 0;
+  }
+};
+
+export {
+  setFactStoreEvictionReporter,
+  getFactStoreEvictionReporter,
+  FactStore
+};

package/node_modules/pi-lens/dist/chunk-NTHH2J74.js

@@ -0,0 +1,27 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  GoClient,
+  goClient,
+  resetGoAvailability
+} from "./chunk-6VCD4VKZ.js";
+import "./chunk-F3P7VQ7H.js";
+import "./chunk-EOKRQ3SA.js";
+import "./chunk-WONERJTP.js";
+import "./chunk-VN2AXLEX.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  GoClient,
+  goClient,
+  resetGoAvailability
+};

package/node_modules/pi-lens/dist/chunk-NTUJEGDZ.js

@@ -0,0 +1,59 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  recordDegradation
+} from "./chunk-N3YQJI6O.js";
+import {
+  logExtension
+} from "./chunk-O6TQT6RI.js";
+
+// dist/clients/project-trust.js
+var trustState = "unknown";
+var installRefusalWarnings = /* @__PURE__ */ new Set();
+var INSTALL_REFUSAL_WARNING_CAP = 200;
+var trustGeneration = 0;
+function getProjectTrustGeneration() {
+  return trustGeneration;
+}
+function getProjectTrustState() {
+  return trustState;
+}
+function isToolInstallAllowedByTrust() {
+  return trustState !== "untrusted";
+}
+function assertInstallAllowed(context) {
+  if (isToolInstallAllowedByTrust())
+    return true;
+  recordDegradation({
+    kind: "trust-refusal",
+    subject: context,
+    reason: projectTrustDenialReason() ?? "project trust denied"
+  });
+  if (!installRefusalWarnings.has(context)) {
+    if (installRefusalWarnings.size >= INSTALL_REFUSAL_WARNING_CAP) {
+      installRefusalWarnings.clear();
+    }
+    installRefusalWarnings.add(context);
+    logExtension({
+      subsystem: "project-trust",
+      level: "warn",
+      message: `install/materialization blocked: ${context}`,
+      metadata: { context, trustState }
+    });
+  }
+  return false;
+}
+function isLspSpawnAllowedByTrust() {
+  return trustState !== "untrusted";
+}
+function projectTrustDenialReason() {
+  return trustState === "untrusted" ? "project is not trusted (host isProjectTrusted() === false)" : void 0;
+}
+
+export {
+  getProjectTrustGeneration,
+  getProjectTrustState,
+  isToolInstallAllowedByTrust,
+  assertInstallAllowed,
+  isLspSpawnAllowedByTrust,
+  projectTrustDenialReason
+};

package/node_modules/pi-lens/dist/chunk-NXL4FFQQ.js

@@ -0,0 +1,47 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};