gennady 0.7.0 → 0.7.1

package/dist/chunks/services-Dnk3nB2x.js

@@ -0,0 +1,2732 @@
+import { createServer as ie } from "node:http";
+import { readFileSync as A, writeFileSync as oe, existsSync as K, readdirSync as X, statSync as ae } from "node:fs";
+import * as M from "node:path";
+import { join as $ } from "node:path";
+import * as ce from "node:os";
+import { homedir as D } from "node:os";
+import { execSync as le } from "node:child_process";
+import { DatabaseSync as de } from "node:sqlite";
+const S = { debug: 0, info: 1, warn: 2, error: 3, silent: 4 };
+let E = "warn";
+const mt = (i) => {
+  E = i;
+}, g = {
+  debug: (i, e) => {
+    S[E] <= S.debug && console.debug(i, ...e !== void 0 ? [e] : []);
+  },
+  info: (i, e) => {
+    S[E] <= S.info && console.info(i, ...e !== void 0 ? [e] : []);
+  },
+  warn: (i, e) => {
+    S[E] <= S.warn && console.warn(i, ...e !== void 0 ? [e] : []);
+  },
+  error: (i, e) => {
+    S[E] <= S.error && console.error(i, ...e !== void 0 ? [e] : []);
+  }
+}, gt = (i) => {
+  if (!i || typeof i != "string" || i.trim().length === 0)
+    return null;
+  const e = i.trim();
+  let t;
+  try {
+    t = new URL(e);
+  } catch {
+    return null;
+  }
+  const r = t.host, n = t.pathname.replace(/\/$/, ""), s = n.match(/^\/(.+?)\/-\/merge_requests\/(\d+)$/);
+  if (s) {
+    const a = parseInt(s[2], 10);
+    return isNaN(a) ? null : {
+      provider: "gitlab",
+      host: r,
+      repository: s[1],
+      iid: a
+    };
+  }
+  const o = n.match(/^\/(.+?)\/pull\/(\d+)$/);
+  if (o) {
+    const a = parseInt(o[2], 10);
+    return isNaN(a) ? null : {
+      provider: "github",
+      host: r,
+      repository: o[1],
+      iid: a
+    };
+  }
+  return null;
+};
+class Y {
+}
+class ue extends Y {
+  /** @purpose Bound HTTP request function injected for GitLab API calls */
+  _request;
+  /**
+   * @purpose Wire the HTTP request adapter for GitLab merge request endpoints.
+   * @param request Authenticated HTTP request function targeting GitLab API.
+   */
+  constructor(e) {
+    super(), this._request = e;
+  }
+  /**
+   * @param query Target project and optional filters.
+   * @returns List of merge requests matching the filters.
+   * @sideEffect Network: GET /projects/:project/merge_requests
+   * @see {VcsClientMergeRequests#getList} in services/vcs-client/abstract/vcs-merge-requests.ts
+   */
+  async getList(e) {
+    const t = new URLSearchParams(), r = e?.state ?? "opened";
+    e?.sourceBranch && t.set("source_branch", e.sourceBranch), r && t.set("state", r), e?.perPage && t.set("per_page", String(e.perPage)), e?.page && t.set("page", String(e.page));
+    const n = encodeURIComponent(e.project), s = await this._request(
+      `/projects/${n}/merge_requests?${t.toString()}`
+    );
+    return Array.isArray(s) ? s : [];
+  }
+  /**
+   * @param query Target project and optional filters.
+   * @returns First matching merge request or null.
+   * @sideEffect Network: Delegates to getList() with per_page=1 limit.
+   * @see {VcsClientMergeRequests#getList} in services/vcs-client/abstract/vcs-merge-requests.ts
+   */
+  async getOne(e) {
+    const t = await this.getList({ ...e, perPage: 1 });
+    return t.length > 0 ? t[0] : null;
+  }
+  /**
+   * @param query Target project and MR IID.
+   * @returns Merge request object or null on 404.
+   * @sideEffect Network: GET /projects/:project/merge_requests/:iid
+   * @see {VcsClientMergeRequests#getList} in services/vcs-client/abstract/vcs-merge-requests.ts
+   */
+  async getByIid(e) {
+    const t = encodeURIComponent(e.project), r = encodeURIComponent(String(e.iid));
+    try {
+      return await this._request(`/projects/${t}/merge_requests/${r}`);
+    } catch (n) {
+      if ((n.message ?? "").includes("404"))
+        return null;
+      throw n;
+    }
+  }
+  /**
+   * @param query Target repository and MR IID, optional pagination.
+   * @returns List of changed files with metadata.
+   * @sideEffect Network: GET /projects/:project/merge_requests/:iid/changes
+   * @see {VcsClientMergeRequests#getChanges} in services/vcs-client/abstract/vcs-client-merge-requests.ts
+   */
+  async getChanges(e) {
+    const t = new URLSearchParams();
+    e?.perPage && t.set("per_page", String(e.perPage)), e?.page && t.set("page", String(e.page));
+    const r = encodeURIComponent(e.repository), n = encodeURIComponent(String(e.iid)), s = await this._request(
+      `/projects/${r}/merge_requests/${n}/changes?${t.toString()}`
+    ), o = s?.changes ?? [], a = s.sha ?? s.source_branch ?? "main";
+    return o.map((c) => {
+      const d = c.new_path ?? c.old_path ?? "", l = c.new_file, u = c.deleted_file, h = c.renamed_file;
+      let p = "modified";
+      u ? p = "deleted" : l ? p = "added" : h && (p = "renamed");
+      const f = {
+        path: d,
+        status: p,
+        ref: a
+      };
+      return h && c.old_path && (f.previousPath = c.old_path), typeof c.additions == "number" && (f.additions = c.additions), typeof c.deletions == "number" && (f.deletions = c.deletions), f;
+    });
+  }
+}
+class pe {
+}
+class fe extends pe {
+  /** @purpose Bound HTTP request function injected for GitLab API calls */
+  _request;
+  /**
+   * @purpose Wire the HTTP request adapter for GitLab merge discussion endpoints.
+   * @param request Authenticated HTTP request function targeting GitLab API.
+   */
+  constructor(e) {
+    super(), this._request = e;
+  }
+  /**
+   * @param query Target project, MR, discussion, and note body.
+   * @returns Created note object from GitLab API.
+   * @sideEffect Network: POST /projects/:project/merge_requests/:iid/discussions/:discussion_id/notes
+   * @see {VcsClientMergeDiscussions#addNote} in services/vcs-client/abstract/vcs-merge-discussions.ts
+   */
+  async addNote(e) {
+    const t = encodeURIComponent(e.project), r = encodeURIComponent(String(e.iid)), n = encodeURIComponent(e.discussionId);
+    return this._request(
+      `/projects/${t}/merge_requests/${r}/discussions/${n}/notes`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ body: e.body })
+      }
+    );
+  }
+  /**
+   * @param query Target project, MR, and optional pagination.
+   * @returns List of discussions for the requested page.
+   * @sideEffect Network: GET /projects/:project/merge_requests/:iid/discussions
+   * @see {VcsClientMergeDiscussions#getList} in services/vcs-client/abstract/vcs-merge-discussions.ts
+   */
+  async getList(e) {
+    const t = new URLSearchParams();
+    e?.perPage && t.set("per_page", String(e.perPage)), e?.page && t.set("page", String(e.page));
+    const r = encodeURIComponent(e.project), n = await this._request(
+      `/projects/${r}/merge_requests/${encodeURIComponent(String(e.iid))}/discussions?${t.toString()}`
+    );
+    return Array.isArray(n) ? n : [];
+  }
+  /**
+   * @param query Target project and MR.
+   * @returns Complete list of all discussions across all pages.
+   * @sideEffect Network: Multiple GET requests for paginated loading.
+   * @see {VcsClientMergeDiscussions#getAll} in services/vcs-client/abstract/vcs-merge-discussions.ts
+   */
+  async getAll(e) {
+    let r = 1;
+    const n = [];
+    for (; ; ) {
+      const s = await this.getList({ ...e, perPage: 100, page: r });
+      if (!Array.isArray(s) || s.length === 0 || (n.push(...s), s.length < 100)) break;
+      r += 1;
+    }
+    return n;
+  }
+}
+class Q {
+}
+class he extends Q {
+  /** @purpose GitLab instance base URL */
+  _baseUrl;
+  /** @purpose GitLab access token */
+  _token;
+  /**
+   * @purpose Wire the adapter with GitLab connection params for raw file fetches.
+   * @param baseUrl GitLab instance base URL (e.g. https://gitlab.com/api/v4).
+   * @param token GitLab personal access token.
+   */
+  constructor(e, t) {
+    super(), this._baseUrl = e, this._token = t;
+  }
+  /**
+   * @param query Target repository, file path, and ref.
+   * @returns File content or null if file not found.
+   * @sideEffect Network: GET /projects/:id/repository/files/:path/raw?ref=
+   * @see {VcsClientRepositoryFiles#getFileContent} in services/vcs-client/abstract/vcs-client-repository-files.ts
+   */
+  async getFileContent(e) {
+    const t = encodeURIComponent(e.repository), r = encodeURIComponent(e.path), n = encodeURIComponent(e.ref);
+    let s;
+    try {
+      s = await fetch(
+        `${this._baseUrl}/projects/${t}/repository/files/${r}/raw?ref=${n}`,
+        { headers: { "PRIVATE-TOKEN": this._token } }
+      );
+    } catch (d) {
+      throw new Error(`GitLab request failed: network error for file ${e.path}`, { cause: d });
+    }
+    if (s.status === 404)
+      return null;
+    if (!s.ok) {
+      const d = await s.text().catch(() => "");
+      throw new Error(`GitLab request failed: ${s.status} ${s.statusText} ${d}`);
+    }
+    const o = s.headers.get("content-type") ?? "", a = await s.text(), c = o.startsWith("text/") || o.includes("json") || o.includes("xml") || o.includes("javascript") || !o;
+    return {
+      path: e.path,
+      content: a,
+      encoding: c ? "utf-8" : "base64"
+    };
+  }
+}
+class Z {
+}
+class _t extends Z {
+  /** @see {VcsClient#MergeRequests} in services/vcs-client/abstract/vcs-client.ts */
+  MergeRequests;
+  /** @see {VcsClient#MergeDiscussions} in services/vcs-client/abstract/vcs-client.ts */
+  MergeDiscussions;
+  /** @see {VcsClient#RepositoryFiles} in services/vcs-client/abstract/vcs-client.ts */
+  RepositoryFiles;
+  /**
+   * @purpose Create a GitLab API client bound to a base URL with access token.
+   * @param options Connection parameters: base URL and access token.
+   */
+  constructor(e) {
+    super();
+    const t = async (r, n = {}) => {
+      const s = await fetch(`${e.baseUrl}${r}`, {
+        ...n,
+        headers: {
+          "PRIVATE-TOKEN": e.token,
+          ...n.headers ?? {}
+        }
+      });
+      if (!s.ok) {
+        const o = await s.text().catch(() => "");
+        throw new Error(`GitLab request failed: ${s.status} ${s.statusText} ${o}`);
+      }
+      return s.json();
+    };
+    this.MergeRequests = new ue(t), this.MergeDiscussions = new fe(t), this.RepositoryFiles = new he(e.baseUrl, e.token);
+  }
+}
+class me extends Y {
+  /** @purpose Bound HTTP request function for GitHub API calls */
+  _request;
+  /**
+   * @purpose Wire the HTTP request adapter for GitHub PR endpoints.
+   * @param request Authenticated HTTP request function targeting GitHub API.
+   */
+  constructor(e) {
+    super(), this._request = e;
+  }
+  /**
+   * @purpose GitHub getList not implemented — use getChanges for PR files.
+   * @returns Empty array — not implemented.
+   */
+  async getList() {
+    throw new Error("GitHub getList not implemented — use getChanges for PR files");
+  }
+  /**
+   * @purpose GitHub getOne not implemented.
+   * @returns Null — not implemented.
+   */
+  async getOne() {
+    throw new Error("GitHub getOne not implemented");
+  }
+  /**
+   * @purpose GitHub getByIid not implemented.
+   * @returns Null — not implemented.
+   */
+  async getByIid() {
+    throw new Error("GitHub getByIid not implemented");
+  }
+  /**
+   * @param query Target repository and PR number, optional pagination.
+   * @returns List of changed files with metadata.
+   * @sideEffect Network: GET /repos/:owner/:repo/pulls/:number/files
+   * @see {VcsClientMergeRequests#getChanges} in services/vcs-client/abstract/vcs-client-merge-requests.ts
+   */
+  async getChanges(e) {
+    const t = new URLSearchParams();
+    e?.perPage && t.set("per_page", String(e.perPage)), e?.page && t.set("page", String(e.page));
+    const r = encodeURIComponent(e.repository), n = encodeURIComponent(String(e.iid)), [s, o] = await Promise.all([
+      this._request(`/repos/${r}/pulls/${n}`),
+      this._request(`/repos/${r}/pulls/${n}/files?${t.toString()}`)
+    ]), a = s?.head?.ref ?? "main";
+    return (Array.isArray(o) ? o : []).map((d) => {
+      const l = d.filename ?? "", u = d.status ?? "modified", h = d.additions, p = d.deletions;
+      let f = "modified";
+      u === "added" ? f = "added" : u === "removed" ? f = "deleted" : u === "renamed" && (f = "renamed");
+      const m = {
+        path: l,
+        status: f,
+        ref: a
+      };
+      return f === "renamed" && d.previous_filename && (m.previousPath = d.previous_filename), typeof h == "number" && (m.additions = h), typeof p == "number" && (m.deletions = p), m;
+    });
+  }
+}
+class ge extends Q {
+  /** @purpose GitHub API base URL */
+  _baseUrl;
+  /** @purpose GitHub access token */
+  _token;
+  /**
+   * @purpose Wire the adapter with GitHub connection params for raw content fetches.
+   * @param baseUrl GitHub API base URL (e.g. https://api.github.com).
+   * @param token GitHub personal access token.
+   */
+  constructor(e, t) {
+    super(), this._baseUrl = e, this._token = t;
+  }
+  /**
+   * @param query Target repository, file path, and ref.
+   * @returns File content or null if file not found.
+   * @sideEffect Network: GET /repos/:owner/:repo/contents/:path?ref=
+   * @see {VcsClientRepositoryFiles#getFileContent} in services/vcs-client/abstract/vcs-client-repository-files.ts
+   */
+  async getFileContent(e) {
+    const t = encodeURIComponent(e.repository), r = encodeURIComponent(e.path), n = encodeURIComponent(e.ref);
+    let s;
+    try {
+      s = await fetch(`${this._baseUrl}/repos/${t}/contents/${r}?ref=${n}`, {
+        headers: {
+          Authorization: "Bearer " + this._token,
+          Accept: "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28"
+        }
+      });
+    } catch (l) {
+      throw new Error(`GitHub request failed: network error for file ${e.path}`, { cause: l });
+    }
+    if (s.status === 404)
+      return null;
+    if (!s.ok) {
+      const l = await s.text().catch(() => "");
+      throw new Error(`GitHub request failed: ${s.status} ${s.statusText} ${l}`);
+    }
+    const o = await s.json(), a = o.encoding ?? "none", c = o.content ?? "";
+    if (a === "base64") {
+      const l = Buffer.from(c, "base64").toString("utf-8"), u = !l.includes("\0");
+      return {
+        path: e.path,
+        content: u ? l : c,
+        encoding: u ? "utf-8" : "base64"
+      };
+    }
+    const d = o.type;
+    return d === "submodule" || d === "symlink" ? {
+      path: e.path,
+      content: o.submodule_git_url ?? o.target ?? "",
+      encoding: "utf-8"
+    } : {
+      path: e.path,
+      content: c,
+      encoding: "utf-8"
+    };
+  }
+}
+class yt extends Z {
+  /** @see {VcsClient#MergeRequests} in services/vcs-client/abstract/vcs-client.ts */
+  MergeRequests;
+  /** @see {VcsClient#MergeDiscussions} in services/vcs-client/abstract/vcs-client.ts */
+  MergeDiscussions = void 0;
+  /** @see {VcsClient#RepositoryFiles} in services/vcs-client/abstract/vcs-client.ts */
+  RepositoryFiles;
+  /**
+   * @purpose Create a GitHub API client bound to a base URL with access token.
+   * @param options Connection parameters: base URL and access token.
+   */
+  constructor(e) {
+    super();
+    const t = async (r, n = {}) => {
+      const s = await fetch(`${e.baseUrl}${r}`, {
+        ...n,
+        headers: {
+          Authorization: "Bearer " + e.token,
+          Accept: "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28",
+          ...n.headers ?? {}
+        }
+      });
+      if (!s.ok) {
+        const o = await s.text().catch(() => "");
+        throw new Error(`GitHub request failed: ${s.status} ${s.statusText} ${o}`);
+      }
+      return s.json();
+    };
+    this.MergeRequests = new me(t), this.RepositoryFiles = new ge(e.baseUrl, e.token);
+  }
+}
+function L(i) {
+  try {
+    if (i === null)
+      return { kind: "primitive", text: "null" };
+    if (i === void 0)
+      return { kind: "primitive", text: "undefined" };
+    const e = typeof i;
+    if (e === "string" || e === "number" || e === "boolean" || e === "bigint" || e === "symbol")
+      return { kind: "primitive", text: String(i) };
+    if (e === "function")
+      return {
+        kind: "tagged",
+        tag: "[object Function]",
+        text: `[function ${i.name || "anonymous"}]`
+      };
+    const t = Object.prototype.toString.call(i);
+    if (i instanceof Error) {
+      const n = i.message ? `${i.name}: ${i.message}` : i.name;
+      return { kind: "tagged", tag: t, text: n };
+    }
+    const r = _e(i);
+    return r ? { kind: "tagged", tag: t, text: `${t} ${r}` } : { kind: "tagged", tag: t, text: t };
+  } catch (e) {
+    return {
+      kind: "tagged",
+      tag: "[object Unserializable]",
+      text: `[unserializable: ${String(e)}]`
+    };
+  }
+}
+function _e(i) {
+  const e = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(i, (r, n) => {
+      if (typeof n == "bigint")
+        return `${n.toString()}n`;
+      if (typeof n == "symbol")
+        return n.toString();
+      if (typeof n == "function")
+        return `[function ${n.name || "anonymous"}]`;
+      if (n && typeof n == "object") {
+        if (e.has(n))
+          return "[circular]";
+        e.add(n);
+      }
+      return n;
+    }) ?? null;
+  } catch {
+    return null;
+  }
+}
+const O = ["log", "info", "warn", "error", "debug"], ye = 5e3, P = /* @__PURE__ */ new WeakMap(), C = globalThis;
+function be(i, e) {
+  we(i, e);
+  const t = P.get(i);
+  if (t)
+    return t.duplicateConnectWarned || (t.duplicateConnectWarned = !0, t.originals.warn(
+      "[remoteConsoleClient.connect] [connected → connected] Duplicate connect ignored for existing target"
+    )), t.runtime;
+  const r = ve(i), s = {
+    disconnect: async () => {
+      const a = P.get(i);
+      a && await k(a, !1);
+    }
+  }, o = {
+    url: e.url,
+    tabId: e.tabId,
+    branch: e.branch,
+    consoleTarget: i,
+    originals: r,
+    queue: [],
+    flushInFlight: !1,
+    transportFailureNotified: !1,
+    duplicateConnectWarned: !1,
+    shutdownStarted: !1,
+    intervalId: null,
+    pagehideListener: () => {
+      k(o, !0);
+    },
+    beforeunloadListener: () => {
+      k(o, !0);
+    },
+    runtime: s
+  };
+  return Ie(o), Se(o), xe(o), o.intervalId = setInterval(() => {
+    ee(o, !1);
+  }, ye), i.__remote__ = s, P.set(i, o), s;
+}
+const bt = {
+  connect: be
+};
+function we(i, e) {
+  try {
+    new URL(e.url);
+  } catch (t) {
+    throw new Error("[remoteConsoleClient.connect] Invalid config.url: expected absolute URL", {
+      cause: t
+    });
+  }
+  for (const t of O)
+    if (typeof i[t] != "function")
+      throw new Error(`[remoteConsoleClient.connect] Missing console method: ${t}`);
+}
+function ve(i) {
+  return {
+    log: i.log.bind(i),
+    info: i.info.bind(i),
+    warn: i.warn.bind(i),
+    error: i.error.bind(i),
+    debug: i.debug.bind(i)
+  };
+}
+function Ie(i) {
+  for (const e of O) {
+    const t = i.originals[e];
+    i.consoleTarget[e] = (...r) => {
+      t(...r), !i.shutdownStarted && i.queue.push({
+        level: e,
+        timestamp: Date.now(),
+        args: r.map((n) => L(n)),
+        tabId: i.tabId,
+        branch: i.branch
+      });
+    };
+  }
+}
+function Se(i) {
+  i.queue.push({
+    level: "info",
+    timestamp: Date.now(),
+    args: [
+      L("[remote-console] connected"),
+      L(`tabId=${i.tabId ?? "unknown"}`),
+      L(`branch=${i.branch ?? "unknown"}`)
+    ],
+    tabId: i.tabId,
+    branch: i.branch
+  });
+}
+function Ce(i) {
+  for (const e of O)
+    i.consoleTarget[e] = i.originals[e];
+  delete i.consoleTarget.__remote__;
+}
+function xe(i) {
+  typeof C.addEventListener == "function" && (C.addEventListener("pagehide", i.pagehideListener), C.addEventListener("beforeunload", i.beforeunloadListener));
+}
+function Re(i) {
+  typeof C.removeEventListener == "function" && (C.removeEventListener("pagehide", i.pagehideListener), C.removeEventListener("beforeunload", i.beforeunloadListener));
+}
+async function k(i, e) {
+  if (!i.shutdownStarted) {
+    i.shutdownStarted = !0, i.intervalId && (clearInterval(i.intervalId), i.intervalId = null), Re(i);
+    try {
+      await ee(i, e);
+      try {
+        await te(i, { type: "disconnect", tabId: i.tabId }, e);
+      } catch {
+      }
+    } finally {
+      Ce(i), P.delete(i.consoleTarget);
+    }
+  }
+}
+async function ee(i, e) {
+  if (i.flushInFlight || i.queue.length === 0)
+    return;
+  i.flushInFlight = !0;
+  const t = i.queue.splice(0, i.queue.length);
+  try {
+    await te(i, { type: "logs", tabId: i.tabId, items: t }, e);
+  } catch (r) {
+    i.transportFailureNotified || (i.transportFailureNotified = !0, i.originals.error(
+      "[remoteConsoleClient.connect] [streaming → degraded] Remote sink became unavailable; local console remains active",
+      { cause: r }
+    ));
+  } finally {
+    i.flushInFlight = !1;
+  }
+}
+async function te(i, e, t) {
+  if (t) {
+    await Ee(i.url, e);
+    return;
+  }
+  const r = await fetch(i.url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(e)
+  });
+  if (!r.ok)
+    throw new Error(`[remoteConsoleClient.connect] Unexpected response status: ${r.status}`);
+}
+async function Ee(i, e) {
+  const t = JSON.stringify(e), r = new Blob([t], { type: "application/json" }), n = C.navigator?.sendBeacon;
+  if (!(typeof n == "function" && n.call(C.navigator, i, r)))
+    try {
+      await fetch(i, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: t,
+        keepalive: !0
+      });
+    } catch {
+    }
+}
+class $e {
+  /** @purpose Stores low-level line sink used to emit already-rendered stdout entries. */
+  _writeLine;
+  /**
+   * @purpose Configures writer with injected sink or defaults to process.stdout line output.
+   * @param [writeLine] Optional custom line writer function.
+   */
+  constructor(e) {
+    this._writeLine = e ?? ((t) => process.stdout.write(`${t}
+`));
+  }
+  /**
+   * @purpose Prints ordered log entries as one normalized line per entry.
+   * @param items Parsed log entry list from command envelope payload.
+   * @sideEffect IO: writes rendered lines into stdout stream (or injected writer).
+   */
+  write(e) {
+    for (const t of e) {
+      const r = this.render(t);
+      this._writeLine(r);
+    }
+  }
+  /**
+   * @purpose Creates stable text format independent from platform util.inspect behavior.
+   * @param item Single remote log entry with serialized args.
+   * @returns Flat line in format `[console.<level>] <arg1> <arg2> ...`.
+   */
+  render(e) {
+    const t = e.args.map((r) => r.text).join(" ").trim();
+    return t ? `[console.${e.level}] ${t}` : `[console.${e.level}]`;
+  }
+}
+const ne = "/";
+async function wt(i) {
+  Ae(i);
+  const e = i.host ?? "127.0.0.1", t = new $e(i.stdoutWrite), r = new Le(
+    i.exitCode ?? 0,
+    i.exit
+  ), n = ie((o, a) => {
+    Te(o, a, t, r, n).catch(
+      () => {
+        a.writableEnded || v(a, 500, { ok: !1, error: "runtime_failure" });
+      }
+    );
+  });
+  await new Promise((o, a) => {
+    n.once("error", a), n.listen(i.port, e, () => {
+      n.off("error", a), o();
+    });
+  });
+  const s = n.address();
+  if (!s || typeof s == "string")
+    throw new Error("[startRemoteConsoleServer] Failed to resolve runtime endpoint address");
+  return {
+    url: `http://${e}:${s.port}${ne}`,
+    close: async () => {
+      await re(n);
+    }
+  };
+}
+function Ae(i) {
+  if (!Number.isInteger(i.port) || i.port < 0 || i.port > 65535)
+    throw new Error("[startRemoteConsoleServer] Invalid port: expected integer in range 0..65535");
+}
+async function Te(i, e, t, r, n) {
+  try {
+    if (i.url !== ne) {
+      v(e, 404, { ok: !1, error: "not_found" });
+      return;
+    }
+    if (i.method !== "POST") {
+      v(e, 405, { ok: !1, error: "method_not_allowed" });
+      return;
+    }
+    const s = await Me(i);
+    let o;
+    try {
+      o = JSON.parse(s);
+    } catch {
+      v(e, 400, { ok: !1, error: "invalid_json" });
+      return;
+    }
+    if (!Ne(o)) {
+      v(e, 400, { ok: !1, error: "invalid_envelope" });
+      return;
+    }
+    if (o.type === "logs") {
+      if (!Array.isArray(o.items) || o.items.length === 0) {
+        v(e, 400, { ok: !1, error: "invalid_logs_payload" });
+        return;
+      }
+      t.write(o.items), v(e, 202, { ok: !0 });
+      return;
+    }
+    if (o.type === "disconnect") {
+      v(e, 202, { ok: !0 }), await r.begin(n);
+      return;
+    }
+    v(e, 400, { ok: !1, error: "unsupported_command" });
+  } catch {
+    e.writableEnded || v(e, 500, { ok: !1, error: "runtime_failure" });
+  }
+}
+function Ne(i) {
+  if (!i || typeof i != "object")
+    return !1;
+  const e = i.type;
+  return e === "disconnect" ? !0 : e === "logs" ? Array.isArray(i.items) : !1;
+}
+async function Me(i) {
+  let e = "";
+  for await (const t of i)
+    e += t.toString();
+  return e;
+}
+function v(i, e, t) {
+  i.statusCode = e, i.setHeader("content-type", "application/json"), i.end(JSON.stringify(t));
+}
+async function re(i) {
+  await new Promise((e, t) => {
+    i.close((r) => {
+      if (r) {
+        t(r);
+        return;
+      }
+      e();
+    });
+  });
+}
+class Le {
+  /** @purpose Stores configured exit code used after controlled socket shutdown completes. */
+  _exitCode;
+  /** @purpose Stores process-exit strategy (real exit in prod, spy callback in tests). */
+  _exit;
+  /** @purpose Prevents duplicate shutdown orchestration across repeated disconnect signals. */
+  _started = !1;
+  /** @purpose Initializes controller with deterministic exit behavior for runtime or test harnesses. */
+  constructor(e, t) {
+    this._exitCode = e, this._exit = t ?? ((r) => process.exit(r));
+  }
+  /**
+   * @purpose Starts shutdown exactly once: close server socket first, then trigger configured exit strategy.
+   * @param server Active server runtime instance.
+   * @sideEffect Network: stops accepting incoming HTTP connections.
+   * @sideEffect Process: triggers exit callback with configured exit code.
+   */
+  async begin(e) {
+    if (!this._started) {
+      this._started = !0;
+      try {
+        await re(e);
+      } finally {
+        this._exit(this._exitCode);
+      }
+    }
+  }
+}
+const j = "ERR_DBC_PURPOSE_CONFLICT", Pe = "ERR_DBC_ORDER", ke = "ERR_DBC_PARAM_NAME_MISSING", De = "ERR_DBC_SEE_FORMAT_INVALID", Oe = [
+  "implements",
+  "invariant",
+  "pre",
+  "param",
+  "throws",
+  "returns",
+  "post",
+  "sideEffect"
+], Fe = new Map(
+  Oe.map((i, e) => [i, e])
+);
+class vt {
+  /**
+   * @param inputContract Raw contract text to parse.
+   * @returns Parsed DBC schema with entries and format metadata.
+   * @see {DbcParser#parse} in ../../dbc-parser.types.ts
+   */
+  parse(e) {
+    const t = [];
+    let n = e.trim();
+    n.startsWith("/**") && (n = n.slice(3)), n.endsWith("*/") && (n = n.slice(0, -2)), n = n.trim();
+    const s = n.includes(`
+`) ? "multi-line" : "single-line", o = e.split(/\r?\n/u);
+    let a, c = !1;
+    const d = [];
+    for (let u = 0; u < o.length; u += 1) {
+      const h = u + 1, p = this.normalizeLine(o[u] ?? "");
+      if (p.length !== 0) {
+        if (p.startsWith("@")) {
+          !c && d.length > 0 && (t.push({
+            type: "description",
+            value: d.join(`
+`),
+            issues: [],
+            line: 1
+          }), d.length = 0), c = !0;
+          const f = this.parseTagLine(p, h);
+          if (!f)
+            continue;
+          t.push(f), a = f;
+          continue;
+        }
+        if (!c) {
+          d.push(p);
+          continue;
+        }
+        a && (a.value = a.value.length > 0 ? `${a.value}
+${p}` : p);
+      }
+    }
+    !c && d.length > 0 && t.push({
+      type: "description",
+      value: d.join(`
+`),
+      issues: [],
+      line: 1
+    }), this.validatePurposeConflict(t), this.validateContractOrder(t), this.validateParamSpecifier(t), this.validateSeeSpecifier(t);
+    let l;
+    if (s === "single-line" && t.length > 0) {
+      const u = t[0];
+      if (u && u.value.includes(" | @")) {
+        const h = u.value.split(" | @");
+        u.value = (h[0] ?? "").trim();
+        const p = [];
+        for (let f = 1; f < h.length; f += 1) {
+          const m = `@${h[f] ?? ""}`, _ = this.parseTagLine(m, u.line);
+          _ && p.push(_);
+        }
+        p.length > 0 && (l = p);
+      }
+    }
+    return {
+      entries: t.map(({ line: u, ...h }, p) => p === 0 && l ? {
+        ...h,
+        inline: l.map(({ line: f, ...m }) => m)
+      } : h),
+      format: s
+    };
+  }
+  /**
+   * @purpose Normalizes a raw source line by stripping JSDoc framing tokens and edge whitespace.
+   * @param sourceLine Raw line from the input contract.
+   * @returns Line prepared for tag and multiline-value parsing.
+   */
+  normalizeLine(e) {
+    let t = e.trimStart();
+    return t.startsWith("*/") ? "" : (t.startsWith("/**") && (t = t.slice(3)), t = t.trimStart(), t.startsWith("*") && (t = t.slice(1).trimStart()), t.endsWith("*/") && (t = t.slice(0, -2).trimEnd()), t.trim());
+  }
+  /**
+   * @purpose Parses a normalized tag line into an entry object with a source line reference.
+   * @param tagLine Normalized line starting with `@`.
+   * @param line One-based source line number.
+   * @returns Parsed entry or undefined when the tag name is missing.
+   */
+  parseTagLine(e, t) {
+    const r = /^@(\S+)(?:\s+([\s\S]*))?$/u.exec(e);
+    if (!r)
+      return;
+    const n = r[1]?.trim();
+    if (!n)
+      return;
+    const s = (r[2] ?? "").trim();
+    return n === "param" ? this.parseParamTag(n, s, t) : n === "see" ? this.parseSeeTag(n, s, t) : n === "implements" ? this.parseImplementsTag(n, s, t) : n === "returns" || n === "throws" ? this.parseTagWithOptionalDataType(n, s, t) : n === "description" ? {
+      type: "description",
+      value: s,
+      issues: [],
+      line: t
+    } : {
+      type: n,
+      value: s,
+      issues: [],
+      line: t
+    };
+  }
+  /**
+   * @purpose Parses tags where `{dataType}` is optional and the remainder is a plain value.
+   * @param type Tag type.
+   * @param tail Content after the tag name.
+   * @param line One-based source line number.
+   * @returns Parsed entry.
+   */
+  parseTagWithOptionalDataType(e, t, r) {
+    const n = /^\{([^}]+)\}\s*(.*)$/u.exec(t);
+    return n ? {
+      type: e,
+      dataType: n[1]?.trim(),
+      value: (n[2] ?? "").trim(),
+      issues: [],
+      line: r
+    } : {
+      type: e,
+      value: t,
+      issues: [],
+      line: r
+    };
+  }
+  /**
+   * @purpose Parses `@param` into `dataType`, optional `specifier`, `optional`, and value fields.
+   * @param type Tag type.
+   * @param tail Content after `@param`.
+   * @param line One-based source line number.
+   * @returns Parsed entry.
+   */
+  parseParamTag(e, t, r) {
+    const n = {
+      type: e,
+      value: "",
+      issues: [],
+      line: r
+    };
+    let s = t;
+    const o = /^\{([^}]+)\}\s*(.*)$/u.exec(s);
+    if (o && (n.dataType = o[1]?.trim(), s = (o[2] ?? "").trim()), s.length === 0)
+      return n;
+    const a = /^(\[[^\]]+\]|\S+)(?:\s+([\s\S]*))?$/u.exec(s);
+    if (!a)
+      return n.value = s, n;
+    const c = a[1] ?? "";
+    return c.startsWith("[") && c.endsWith("]") ? (n.optional = !0, n.specifier = c.slice(1, -1).trim()) : n.specifier = c.trim(), n.value = (a[2] ?? "").trim(), n;
+  }
+  /**
+   * @purpose Parses `@see` into required `{specifier}` and optional trailing value.
+   * @param type Tag type.
+   * @param tail Content after `@see`.
+   * @param line Source line number.
+   * @returns Parsed entry.
+   */
+  parseSeeTag(e, t, r) {
+    const n = {
+      type: e,
+      value: "",
+      issues: [],
+      line: r
+    }, s = /^\{([^}]+)\}\s*(.*)$/u.exec(t);
+    return s ? (n.specifier = s[1]?.trim(), n.value = (s[2] ?? "").trim(), n) : (n.value = t, n);
+  }
+  /**
+   * @purpose Parses `@implements` into required `{ContractName}` and optional trailing value.
+   * @param type Tag type.
+   * @param tail Content after `@implements`.
+   * @param line One-based source line number.
+   * @returns Parsed entry.
+   */
+  parseImplementsTag(e, t, r) {
+    const n = {
+      type: e,
+      value: "",
+      issues: [],
+      line: r
+    }, s = /^\{([^}]+)\}\s*(.*)$/u.exec(t);
+    return s ? (n.specifier = s[1]?.trim(), n.value = (s[2] ?? "").trim(), n) : (n.value = t, n);
+  }
+  /**
+   * @purpose Emits a conflict issue when `purpose` and `see` are both present in the parsed entries.
+   * @param entries Parsed entries with source lines.
+   */
+  validatePurposeConflict(e) {
+    let t = !1, r = !1;
+    for (const n of e) {
+      if (n.type === "purpose") {
+        r && this.attachIssue(n, j), t = !0;
+        continue;
+      }
+      n.type === "see" && (t && this.attachIssue(n, j), r = !0);
+    }
+  }
+  /**
+   * @purpose Verifies that contract tags follow the strict sequence required by the DBC standard.
+   * @param entries Parsed entries with source lines.
+   */
+  validateContractOrder(e) {
+    let t = -1;
+    for (const r of e) {
+      const n = Fe.get(r.type);
+      n !== void 0 && (n < t && this.attachIssue(r, Pe), t = Math.max(t, n));
+    }
+  }
+  /**
+   * @purpose Emits missing-parameter-name issues for `@param` entries without a non-empty specifier.
+   * @param entries Parsed entries with source lines.
+   */
+  validateParamSpecifier(e) {
+    for (const t of e)
+      t.type === "param" && (!t.specifier || t.specifier.trim().length === 0) && this.attachIssue(t, ke);
+  }
+  /**
+   * @purpose Emits invalid-see-format issues for `@see` entries.
+   * @param entries Parsed entries to validate.
+   */
+  validateSeeSpecifier(e) {
+    for (const t of e)
+      t.type === "see" && (!t.specifier || t.specifier.trim().length === 0) && this.attachIssue(t, De);
+  }
+  /**
+   * @purpose Adds an issue to a specific entry and preserves the entry start line in diagnostics.
+   * @param entry Parsed entry with source line.
+   * @param code Stable parser issue code.
+   */
+  attachIssue(e, t) {
+    e.issues.push({
+      code: t,
+      line: e.line
+    });
+  }
+}
+const W = "ERR_DBC_LINT_MISSING_CONTRACT", N = "ERR_DBC_LINT_PARSE_FAILED", Ue = "ERR_DBC_LINT_PARAM_MISSING", J = "ERR_DBC_LINT_PARAM_EXTRA", Be = "ERR_DBC_LINT_PARAM_ORDER", G = "ERR_DBC_LINT_RETURNS_MISSING", z = "ERR_DBC_LINT_RETURNS_UNEXPECTED", je = "ERR_DBC_LINT_TYPE_REDUNDANT", H = "ERR_DBC_LINT_PARAM_OPTIONAL_MISMATCH", F = /* @__PURE__ */ new Set([
+  "function",
+  "method",
+  "interface-method",
+  "constructor",
+  "export-default"
+]), U = /* @__PURE__ */ new Set([
+  "function",
+  "method",
+  "interface-method",
+  "export-default"
+]), se = /* @__PURE__ */ new Set(["getter"]), B = /* @__PURE__ */ new Set([
+  "constructor",
+  "setter",
+  "field",
+  "interface-property",
+  "const",
+  "type",
+  "enum",
+  "enum-member",
+  "class",
+  "interface"
+]), We = /* @__PURE__ */ new Set([
+  ...F,
+  ...U,
+  ...se,
+  ...B,
+  "export-default"
+]);
+function x(i) {
+  let e = i;
+  return e.startsWith("...") && (e = e.slice(3)), e.startsWith("[") && e.endsWith("]") && (e = e.slice(1, -1)), e;
+}
+function y(i, e) {
+  return {
+    file: "",
+    line: 1,
+    col: 1,
+    severity: "error",
+    code: i,
+    message: e
+  };
+}
+function Je(i, e, t) {
+  if (!We.has(t))
+    return [];
+  const r = [], n = i.filter((l) => l.type === "param"), s = i.find((l) => l.type === "returns"), o = F.has(t), a = U.has(t), c = se.has(t), d = B.has(t);
+  if (o) {
+    const l = e.params.map((p) => p.name), u = n.map((p) => x(p.specifier ?? ""));
+    for (const p of l)
+      u.includes(p) || r.push(
+        y(Ue, `Parameter '${p}' is missing from contract`)
+      );
+    for (let p = 0; p < n.length; p += 1) {
+      const f = u[p];
+      l.includes(f) || r.push(
+        y(
+          J,
+          `Extra @param '${n[p].specifier ?? ""}' not in signature`
+        )
+      );
+    }
+    const h = new Map(e.params.map((p) => [p.name, p]));
+    for (const p of n) {
+      const f = x(p.specifier ?? ""), m = h.get(f);
+      m && !m.isRest && (m.optional && !p.optional ? r.push(
+        y(
+          H,
+          `Parameter '${f}' is optional in signature but missing brackets in contract`
+        )
+      ) : !m.optional && p.optional && r.push(
+        y(
+          H,
+          `Parameter '${f}' is not optional in signature but has brackets in contract`
+        )
+      ));
+    }
+    if (l.length === u.length && l.every((p) => u.includes(p))) {
+      let p = 0, f = !1;
+      for (const m of u) {
+        const _ = l.indexOf(m);
+        if (_ >= 0) {
+          if (_ < p) {
+            f = !0;
+            break;
+          }
+          p = _;
+        }
+      }
+      f && r.push(y(Be, "@param order does not match signature"));
+    }
+  } else
+    for (let l = 0; l < n.length; l += 1)
+      r.push(y(J, `@param not applicable for kind '${t}'`));
+  c ? s || r.push(y(G, `Missing @returns for kind '${t}'`)) : a ? (e.returnType !== "void" && !s && r.push(
+    y(
+      G,
+      `Missing @returns for non-void return type '${e.returnType}'`
+    )
+  ), e.returnType === "void" && s && r.push(
+    y(z, "Unexpected @returns for void return type")
+  )) : d && s && r.push(
+    y(z, `@returns not applicable for kind '${t}'`)
+  );
+  for (const l of i)
+    (l.type === "param" || l.type === "returns") && l.dataType && r.push(
+      y(je, `Redundant {${l.dataType}} in @${l.type}`)
+    );
+  return r;
+}
+function R(i) {
+  return i.map((e) => `${e.file}:${e.line}:${e.col}: ${e.severity}: ${e.code}: ${e.message}`).join(`
+`);
+}
+class It {
+  /** @purpose DBC parser for parsing contract text */
+  _parser;
+  /** @purpose AST adapter for parsing TypeScript source files */
+  _astAdapter;
+  /**
+   * @purpose Construct a linter with injected parser and AST adapter.
+   * @param parser DbcParser instance for contract parsing.
+   * @param astAdapter DbcAstAdapter instance for source file parsing.
+   */
+  constructor(e, t) {
+    this._parser = e, this._astAdapter = t;
+  }
+  /**
+   * @param filePath Path to the source file to check.
+   * @param [options] Optional lint configuration.
+   * @returns Full lint report with errors and a formatting function.
+   * @see {DbcLinter#lint} in ../../dbc-linter.types.ts
+   */
+  async lint(e, t) {
+    g.debug(`[DbcTsLinter#lint] [idle → parsing] ${e}`);
+    try {
+      const r = await this._astAdapter.parseFile(
+        e,
+        t?.content
+      );
+      if (!r.ok) {
+        const s = {
+          file: e,
+          line: 1,
+          col: 1,
+          severity: "error",
+          code: N,
+          message: r.error
+        };
+        return g.warn(`[DbcTsLinter#lint] [parsing → parse-failed] ${e}`), { errors: [s], format: () => R([s]) };
+      }
+      const n = this._lintEntities(r.exported, e);
+      return g.info(`[DbcTsLinter#lint] [parsing → linted] ${e} (${n.length} errors)`), {
+        errors: n,
+        format: () => R(n)
+      };
+    } catch (r) {
+      const n = new Error(`[DbcTsLinter#lint] Lint failed for ${e}`, { cause: r });
+      g.error(`[DbcTsLinter#lint] [parsing → failed] ${e}`, {
+        error: n
+      });
+      const s = {
+        file: e,
+        line: 1,
+        col: 1,
+        severity: "error",
+        code: N,
+        message: `Unexpected error: ${String(r)}`
+      };
+      return { errors: [s], format: () => R([s]) };
+    }
+  }
+  /**
+   * @param filePath Path to the source file to check.
+   * @param [options] Optional lint configuration.
+   * @returns Combined report with errors and count of auto-fixed issues.
+   * @see {DbcLinter#lintAndFix} in ../../dbc-linter.types.ts
+   */
+  async lintAndFix(e, t) {
+    g.debug(`[DbcTsLinter#lintAndFix] [idle → linting] ${e}`);
+    try {
+      const r = await this.lint(e, t), n = r.errors.length, s = await this._astAdapter.parseFile(e, t?.content);
+      if (!s.ok)
+        return {
+          errors: r.errors,
+          autoFixed: 0,
+          format: () => R(r.errors)
+        };
+      let o = t?.content ?? A(e, "utf8");
+      const a = this._collectContracts(s.exported);
+      let c = !1;
+      for (const h of a) {
+        const p = h.text;
+        let f = p;
+        if (f = this._expandToMultiline(f, h.kind), f = this._removeRedundantTypes(f), f = this._normalizeParamBrackets(f, h.signature), f = this._removeExtraParams(f, h.signature), f = this._removeUnexpectedReturns(f, h.kind, h.signature), f = this._reorderParams(f, h.signature), f = this._reorderTags(f), f = this._normalizeMultiLine(f), f !== p) {
+          let m = f;
+          if (f.includes(`
+`) && !p.includes(`
+`)) {
+            const _ = o.indexOf(p), w = _ > 0 ? o.lastIndexOf(`
+`, _ - 1) : -1, I = o.slice(w + 1, _), b = f.split(`
+`);
+            for (let T = 1; T < b.length; T += 1)
+              b[T] = I + " " + b[T].trimStart();
+            b[b.length - 1] = I + "*/", m = b.join(`
+`);
+          }
+          o = o.replace(p, m), c = !0;
+        }
+      }
+      c ? (oe(e, o, "utf8"), g.info(`[DbcTsLinter#lintAndFix] [fixing → written] ${e}`)) : g.info(`[DbcTsLinter#lintAndFix] [linting → clean] ${e} (nothing to fix)`);
+      const d = c ? await this.lint(e, { strategy: "full" }) : r, l = d.errors.length, u = n - l;
+      return g.info(`[DbcTsLinter#lintAndFix] [written → done] ${e} (autoFixed=${u})`), {
+        errors: d.errors,
+        autoFixed: u >= 0 ? u : 0,
+        format: () => R(d.errors)
+      };
+    } catch (r) {
+      const n = new Error(`[DbcTsLinter#lintAndFix] Fix failed for ${e}`, { cause: r });
+      return g.error(`[DbcTsLinter#lintAndFix] [linting → failed] ${e}`, { error: n }), {
+        errors: [
+          {
+            file: e,
+            line: 1,
+            col: 1,
+            severity: "error",
+            code: N,
+            message: `Autofix error: ${String(r)}`
+          }
+        ],
+        autoFixed: 0,
+        format: () => R([
+          {
+            file: e,
+            line: 1,
+            col: 1,
+            severity: "error",
+            code: N,
+            message: `Autofix error: ${String(r)}`
+          }
+        ])
+      };
+    }
+  }
+  // #region START_LINT_HELPERS
+  /**
+   * @purpose Walk all exported entities and their members, collecting lint errors.
+   * @param entities Exported entities from AST parse result.
+   * @param filePath Source file path for error attribution.
+   * @returns Array of lint errors collected from entities and members.
+   */
+  _lintEntities(e, t) {
+    const r = [];
+    for (const n of e) {
+      if (!n.contract)
+        r.push(
+          y(
+            W,
+            `Entity '${n.name}' (${n.kind}) is missing a DBC contract`
+          )
+        );
+      else {
+        const s = this._validateContract(
+          n.contract.text,
+          n.signature,
+          n.kind,
+          t,
+          n.contract.startLine,
+          n.contract.startCol
+        );
+        r.push(...s);
+      }
+      for (const s of n.members)
+        if (!s.contract)
+          r.push(
+            y(
+              W,
+              `Member '${s.name}' (${s.kind}) of '${n.name}' is missing a DBC contract`
+            )
+          );
+        else {
+          const o = this._validateContract(
+            s.contract.text,
+            s.signature,
+            s.kind,
+            t,
+            s.contract.startLine,
+            s.contract.startCol
+          );
+          r.push(...o);
+        }
+    }
+    return r.map((n, s) => ({
+      ...n,
+      file: t || n.file,
+      line: n.line > 1 ? n.line : s + 1
+    }));
+  }
+  /**
+   * @purpose Parse a contract text and validate it, returning both parser issues
+   * (translated per FR-23) and structural mismatches via DbcContractMatchValidator.
+   * @param contractText Raw JSDoc contract text to parse and validate.
+   * @param signature Signature info from AST for parameter/returns matching.
+   * @param kind Entity or member kind for validation matrix lookup.
+   * @param filePath Source file path for error attribution.
+   * @param startLine Contract start line in source for error position.
+   * @param startCol Contract start column in source for error position.
+   * @returns Array of lint errors from parser issues and structural mismatches.
+   */
+  _validateContract(e, t, r, n, s, o) {
+    const a = [], c = this._parser.parse(e), d = [];
+    for (const u of c.entries)
+      if (d.push(u), u.inline)
+        for (const h of u.inline)
+          d.push(h);
+    for (const u of d)
+      for (const h of u.issues) {
+        const p = s + (h.line ?? 1) - 1;
+        a.push({
+          file: n,
+          line: p > 0 ? p : s,
+          col: o,
+          severity: "error",
+          code: h.code,
+          message: `Parser issue in contract: ${h.code}`
+        });
+      }
+    const l = Je(d, t, r);
+    for (const u of l)
+      a.push({
+        ...u,
+        file: n,
+        line: s,
+        col: o
+      });
+    return a;
+  }
+  // #endregion END_LINT_HELPERS
+  // #region START_AUTOFIX_COLLECT
+  /** @purpose Internal record of a contract block with context for autofix. */
+  _ContractBlock = class {
+    text;
+    kind;
+    signature;
+    constructor(e, t, r) {
+      this.text = e, this.kind = t, this.signature = r;
+    }
+  };
+  /**
+   * @purpose Walk entities and members, collecting all JSDoc contract blocks
+   * with their associated kind and signature for autofix processing.
+   * @param entities Exported entities from AST parse result.
+   * @returns Array of contract blocks with kind and signature context.
+   */
+  _collectContracts(e) {
+    const t = [];
+    for (const r of e) {
+      r.contract && t.push(new this._ContractBlock(r.contract.text, r.kind, r.signature));
+      for (const n of r.members)
+        n.contract && t.push(new this._ContractBlock(n.contract.text, n.kind, n.signature));
+    }
+    return t;
+  }
+  // #endregion END_AUTOFIX_COLLECT
+  // #region START_AUTOFIX_CHAIN_METHODS
+  /**
+   * @purpose Expand single-line pipe contracts to multi-line for callable kinds or >3 tags.
+   * @param jsdocText Raw JSDoc comment text.
+   * @param [kind] Entity kind — callable kinds or pipe with >3 tags are expanded.
+   * @returns JSDoc text in multi-line format if applicable.
+   */
+  _expandToMultiline(e, t) {
+    if (e.includes(`
+`) || !e.includes(" | @")) return e;
+    const n = e.replace(/^\s*\/\*\*\s*/, "").replace(/\s*\*\/\s*$/, "").split(" | @");
+    if (n.length === 0 || n.length <= 3 && !F.has(t ?? "")) return e;
+    const o = e.match(/^(\s*)/), a = o ? o[1] : "", c = a + " ", d = [a + "/**"];
+    d.push(c + "* " + (n[0] ?? "").trim());
+    for (let l = 1; l < n.length; l += 1)
+      d.push(c + "* @" + (n[l] ?? "").trim());
+    return d.push(a + " */"), d.join(`
+`);
+  }
+  /**
+   * @purpose Remove redundant `{dataType}` annotations from @param and @returns tags.
+   * @param jsdocText Raw JSDoc comment text.
+   * @returns JSDoc text with types stripped.
+   */
+  _removeRedundantTypes(e) {
+    return e.replace(/(\*?\s*)@(param|returns)\s+\{[^}]*\}\s+/g, "$1@$2 ");
+  }
+  /**
+   * @purpose Adjust @param specifiers to wrap optional params in `[brackets]` and remove brackets from required params.
+   * @param jsdocText Raw JSDoc comment text.
+   * @param signature Signature with optionality flags.
+   * @returns JSDoc text with normalized brackets.
+   */
+  _normalizeParamBrackets(e, t) {
+    const r = new Map(t.params.map((o) => [o.name, o]));
+    if (!e.includes(`
+`)) {
+      const o = e.match(/^(\s*)/), a = o ? o[1] : "", l = e.replace(/^\s*\/\*\*\s*/, "").replace(/\s*\*\/\s*$/, "").split(" | ").map((u) => {
+        const h = u.trim();
+        if (!/^@param\s/.test(h)) return u;
+        const p = this._extractParamSpecifier(h), f = x(p), m = r.get(f);
+        if (!m || m.isRest) return u;
+        const _ = m.optional, w = p.startsWith("[") && p.endsWith("]");
+        if (_ === w) return u;
+        let I;
+        _ ? I = p.startsWith("...") ? "[..." + f + "]" : "[" + f + "]" : I = p.startsWith("...") ? "..." + f : f;
+        const b = p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return u.replace(
+          new RegExp(`(@param\\s+(?:\\{[^}]*\\}\\s+)?)${b}`),
+          `$1${I}`
+        );
+      });
+      return a + "/** " + l.join(" | ") + " */";
+    }
+    const n = e.split(`
+`), s = [];
+    for (const o of n) {
+      let a = o.trim();
+      if (a.startsWith("* ") ? a = a.slice(2).trimStart() : a.startsWith("*") && (a = a.slice(1).trimStart()), !/^@param\s/.test(a)) {
+        s.push(o);
+        continue;
+      }
+      const c = this._extractParamSpecifier(a), d = x(c), l = r.get(d);
+      if (!l || l.isRest) {
+        s.push(o);
+        continue;
+      }
+      const u = l.optional, h = c.startsWith("[") && c.endsWith("]");
+      if (u === h) {
+        s.push(o);
+        continue;
+      }
+      let p;
+      u ? p = c.startsWith("...") ? "[..." + d + "]" : "[" + d + "]" : p = c.startsWith("...") ? "..." + d : d;
+      const f = c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), m = o.replace(
+        new RegExp(`(@param\\s+(?:\\{[^}]*\\}\\s+)?)${f}`),
+        `$1${p}`
+      );
+      s.push(m);
+    }
+    return s.join(`
+`);
+  }
+  /**
+   * @purpose Remove @param entries whose specifier does not match any signature parameter. | Handles both multi-line and single-line contracts.
+   * @param jsdocText Raw JSDoc comment text.
+   * @param signature Signature to match against.
+   * @returns JSDoc text with extra params removed.
+   */
+  _removeExtraParams(e, t) {
+    const r = new Set(t.params.map((a) => a.name)), n = e.split(`
+`), s = [];
+    let o = !1;
+    for (const a of n) {
+      let c = a.trim();
+      if (c === "*/" || c === "*/ ") {
+        o = !1, s.push(a);
+        continue;
+      }
+      if (c.startsWith("* ") ? c = c.slice(2).trimStart() : c.startsWith("*") && (c = c.slice(1).trimStart()), /^@param\s/.test(c)) {
+        const d = this._extractParamSpecifier(c), l = x(d);
+        r.has(l) ? (o = !1, s.push(a)) : o = !0;
+      } else /^@\w/.test(c) ? (o = !1, s.push(a)) : o || s.push(a);
+    }
+    return s.join(`
+`);
+  }
+  /**
+   * @purpose Remove @returns tag when the kind does not allow it or return type is void.
+   * @param jsdocText Raw JSDoc comment text.
+   * @param kind Entity or member kind.
+   * @param [signature] Optional signature info to check void return type.
+   * @returns JSDoc text with unexpected @returns removed.
+   */
+  _removeUnexpectedReturns(e, t, r) {
+    if (!(B.has(t) || U.has(t) && r?.returnType === "void"))
+      return e;
+    const s = e.split(`
+`), o = [];
+    let a = !1;
+    for (const c of s) {
+      let d = c.trim();
+      if (d === "*/" || d === "*/ ") {
+        a = !1, o.push(c);
+        continue;
+      }
+      d.startsWith("* ") ? d = d.slice(2).trimStart() : d.startsWith("*") && (d = d.slice(1).trimStart()), /^@returns\b/.test(d) ? a = !0 : /^@\w/.test(d) ? (a = !1, o.push(c)) : a || o.push(c);
+    }
+    return o.join(`
+`);
+  }
+  /**
+   * @purpose Reorder @param entries to match the signature parameter order.
+   * @param jsdocText Raw JSDoc comment text.
+   * @param signature Signature with desired parameter order.
+   * @returns JSDoc text with params reordered.
+   */
+  _reorderParams(e, t) {
+    if (t.params.length === 0)
+      return e;
+    const r = t.params.map((f) => f.name), n = e.split(`
+`), s = [], o = [], a = [];
+    let c = !1, d = !1, l = null;
+    for (const f of n) {
+      let m = f.trim();
+      if (m.startsWith("* ") ? m = m.slice(2).trimStart() : m.startsWith("*") && (m = m.slice(1).trimStart()), !c && !d && /^@param\s/.test(m) && (c = !0), !c && !d) {
+        if (o.push(f), /^@param\s/.test(m)) {
+          c = !0;
+          const _ = this._extractParamSpecifier(m);
+          l = {
+            name: x(_),
+            lines: [f]
+          };
+        }
+        continue;
+      }
+      if (c)
+        if (/^@param\s/.test(m)) {
+          l && s.push(l);
+          const _ = this._extractParamSpecifier(m);
+          l = {
+            name: x(_),
+            lines: [f]
+          };
+        } else /^@\w/.test(m) ? (l && (s.push(l), l = null), c = !1, d = !0, a.push(f)) : l && l.lines.push(f);
+      else d && a.push(f);
+    }
+    l && s.push(l);
+    const u = /* @__PURE__ */ new Map();
+    for (const f of s)
+      u.set(f.name, f);
+    const h = [];
+    for (const f of r) {
+      const m = u.get(f);
+      m && (h.push(m), u.delete(f));
+    }
+    for (const [, f] of u)
+      h.push(f);
+    const p = [...o];
+    for (const f of h)
+      p.push(...f.lines);
+    return p.push(...a), p.join(`
+`);
+  }
+  /**
+   * @purpose Reorder contract tags to canonical DBC order. | Order: description → purpose → implements → invariant → pre → param(*) → | throws → returns → post → sideEffect → other tags.
+   * @param jsdocText Raw JSDoc comment text.
+   * @returns JSDoc text with tags in canonical order.
+   */
+  _reorderTags(e) {
+    const t = /* @__PURE__ */ new Map([
+      ["purpose", 0],
+      ["implements", 1],
+      ["invariant", 2],
+      ["pre", 3],
+      ["param", 4],
+      ["throws", 5],
+      ["returns", 6],
+      ["post", 7],
+      ["sideEffect", 8],
+      ["see", 9],
+      ["consumer", 9],
+      ["consumers", 9],
+      ["author", 9],
+      ["deprecated", 9]
+    ]), r = e.split(`
+`), n = [], s = [];
+    let o = null, a = !1, c = null;
+    for (const u of r) {
+      let h = u.trim();
+      if (h === "*/" || h === "*/ ") {
+        c = u;
+        continue;
+      }
+      h.startsWith("* ") ? h = h.slice(2).trimStart() : h.startsWith("*") && (h = h.slice(1).trimStart());
+      const p = h.match(/^@(\w+)/);
+      if (!a && !p)
+        n.push(u);
+      else if (p) {
+        a = !0;
+        const f = p[1];
+        o && s.push(o), o = {
+          tag: f,
+          order: t.get(f) ?? 99,
+          lines: [u]
+        };
+      } else a && o ? o.lines.push(u) : n.push(u);
+    }
+    o && s.push(o);
+    const d = s.map((u, h) => ({ ...u, origIdx: h }));
+    d.sort((u, h) => u.order !== h.order ? u.order - h.order : u.origIdx - h.origIdx);
+    const l = [...n];
+    for (const u of d)
+      l.push(...u.lines);
+    return c !== null && l.push(c), l.join(`
+`);
+  }
+  /**
+   * @purpose Normalize multi-line JSDoc format: ensure closing marker is on its own line | and opening marker is bare (no content after it). | Preserves original indentation by patching specific format issues | rather than reconstructing the entire block.
+   * @invariant Single-line contracts pass through unchanged.
+   * @param jsdocText Raw JSDoc comment text.
+   * @returns Normalized JSDoc text.
+   */
+  _normalizeMultiLine(e) {
+    if (!e.includes(`
+`))
+      return e;
+    const t = e.split(`
+`), n = t[0].match(/^(\s*\/\*\*)\s+(.+)/);
+    if (n) {
+      t[0] = n[1];
+      const c = this._detectContentIndent(t);
+      t.splice(1, 0, c + "* " + n[2]);
+    }
+    const s = t.length - 1, a = t[s].match(/^(\s*)\*\s+(.+?)\s*\*\/\s*$/);
+    if (a) {
+      const c = a[1];
+      t[s] = c + "* " + a[2];
+      const d = c.length > 0 ? c.slice(0, -1) : "";
+      t.push(d + " */");
+    }
+    for (let c = 1; c < t.length - 1; c += 1) {
+      const d = t[c];
+      if (d.trim() !== "" && !/^\s*\*\s/.test(d)) {
+        const l = d.match(/^(\s*)/), u = l ? l[1] : "";
+        t[c] = u + "* " + d.trimStart();
+      }
+    }
+    return t.join(`
+`);
+  }
+  /**
+   * @purpose Detect the indentation pattern used by content lines. | Returns the whitespace prefix before `*` on the first content line, | or the indent of the opening line as fallback.
+   * @param lines All lines of the JSDoc block (may be mutated by Step 1).
+   * @returns Indent string for `*`-prefixed content lines.
+   */
+  _detectContentIndent(e) {
+    for (let r = 1; r < e.length - 1; r += 1) {
+      const n = e[r].match(/^(\s*)\*\s/);
+      if (n)
+        return n[1];
+    }
+    return (e[0].match(/^(\s*)/)?.[1] ?? "") + " ";
+  }
+  /**
+   * @purpose Attempt to convert a multi-line JSDoc comment to single-line format. | Inlines only single-tag contracts (1 @tag); multi-tag contracts stay multi-line. | Performs a dry-run through the parser: if the inline version introduces new | parse errors, the original multi-line text is returned unchanged.
+   * @param jsdocText Raw JSDoc comment text.
+   * @returns Inline text if safe, otherwise the original text.
+   */
+  _inlineIfSafe(e) {
+    if (!e.includes(`
+`))
+      return e;
+    const t = e.replace(/^\/\*\*\s*/, "").replace(/\s*\*\/\s*$/, "").split(`
+`).map((d) => d.replace(/^\s*\*\s?/, "").trim()).filter((d) => d.length > 0);
+    if (t.length === 0 || t.filter((d) => /^@\w/.test(d)).length > 1)
+      return e;
+    const n = e.match(/^(\s*)/), o = (n ? n[1] : "") + "/** " + t.join(" | ") + " */";
+    return this._parser.parse(o).entries.some((d) => d.issues.length > 0) ? e : o;
+  }
+  /**
+   * @purpose Extract the specifier (parameter name) from a @param tag line. | Example: `@param userId Description` → `userId`
+   * @param line Trimmed line content starting with `@param`.
+   * @returns The specifier or empty string.
+   */
+  _extractParamSpecifier(e) {
+    const n = e.replace(/^(\*?\s*)?@param\s+/, "").replace(/^\{[^}]*\}\s+/, "").match(/^(\S+)/);
+    return n ? n[1] : "";
+  }
+  // #endregion END_AUTOFIX_CHAIN_METHODS
+}
+class St {
+  /** @purpose Lazy-initialized tree-sitter parser instance */
+  _parser;
+  /**
+   * @param filePath Absolute path to the TypeScript source file.
+   * @param [content] Optional pre-loaded file content, bypasses disk read.
+   * @returns Parse result with exported entities or an error.
+   * @see {DbcAstAdapter#parseFile} in ../../dbc-ast-adapter.types.ts
+   */
+  async parseFile(e, t) {
+    try {
+      g.debug(`[DbcTsAstAdapter#parseFile] [idle → reading] ${e}`);
+      const r = t ?? A(e, "utf8"), s = (await this._initializeParser()).parse(r);
+      if (s.rootNode.hasError) {
+        const c = this._findErrorNode(s.rootNode), d = c ? ` at line ${c.startPosition.row + 1}` : "";
+        return g.warn(`[DbcTsAstAdapter#parseFile] [reading → parse-failed] ${e}${d}`), { ok: !1, error: `Syntax error in ${e}${d}` };
+      }
+      const a = this._extractExported(s.rootNode, r);
+      return g.info(
+        `[DbcTsAstAdapter#parseFile] [reading → parsed] ${e} (${a.length} entities)`
+      ), { ok: !0, exported: a };
+    } catch (r) {
+      if (r instanceof Error && "code" in r && r.code === "ENOENT")
+        return g.warn(`[DbcTsAstAdapter#parseFile] [reading → not-found] ${e}`), { ok: !1, error: `File not found: ${e}` };
+      const s = new Error(`[DbcTsAstAdapter#parseFile] Parse failed for ${e}`, {
+        cause: r
+      });
+      return g.error(`[DbcTsAstAdapter#parseFile] [reading → failed] ${e}`, { error: s }), { ok: !1, error: `Failed to parse ${e}: ${String(r)}` };
+    }
+  }
+  /**
+   * @purpose Lazy-initializes the tree-sitter Parser with the TypeScript grammar.
+   * Uses dynamic import so tree-sitter is only loaded when the adapter is actually used.
+   * @returns Configured Parser instance.
+   */
+  async _initializeParser() {
+    if (!this._parser) {
+      const [e, t] = await Promise.all([
+        import("tree-sitter"),
+        import("./index-DAU6h0aT.js").then((o) => o.i)
+      ]), r = e.default, n = t.default;
+      this._parser = new r();
+      const s = n.tsx ?? n;
+      this._parser.setLanguage(s);
+    }
+    return this._parser;
+  }
+  /**
+   * @purpose Walks the root AST node and extracts all exported entities,
+   * skipping re-exports.
+   * @param root Root CST node.
+   * @param source Full source text for slicing.
+   * @returns Array of exported entities.
+   */
+  _extractExported(e, t) {
+    const r = [];
+    let n;
+    for (let s = 0; s < e.childCount; s += 1) {
+      const o = e.child(s);
+      if (o) {
+        if (o.type === "comment") {
+          const a = t.slice(o.startIndex, o.endIndex);
+          a.startsWith("/**") ? n = {
+            text: a,
+            startLine: o.startPosition.row + 1,
+            startCol: o.startPosition.column + 1
+          } : n = void 0;
+          continue;
+        }
+        if (o.type === "export_statement") {
+          const a = this._extractExportEntity(o, t, n);
+          a && r.push(a), n = void 0;
+          continue;
+        }
+        o.type !== "comment" && (n = void 0);
+      }
+    }
+    return r;
+  }
+  /**
+   * @purpose Extracts a single exported entity from an export_statement node.
+   * Skips re-exports.
+   * @param node export_statement node.
+   * @param source Full source text.
+   * @param pendingContract JSDoc contract that precedes this export, if any.
+   * @returns Exported entity or undefined for re-exports.
+   */
+  _extractExportEntity(e, t, r) {
+    if (this._isReExport(e))
+      return;
+    let n = !1, s = null;
+    for (let h = 0; h < e.childCount; h += 1) {
+      const p = e.child(h);
+      if (p) {
+        if (p.type === "default") {
+          n = !0;
+          continue;
+        }
+        p.type === "export" || p.type === ";" || !s && p.type !== "export" && p.type !== ";" && (s = p);
+      }
+    }
+    if (!s)
+      return;
+    const o = this._mapKind(s.type, n), a = this._extractName(s, t, n), c = this._extractSignature(s, t), d = this._extractMembers(s, t, o), l = o === "class" ? this._hasImplements(s) : void 0, u = r ? {
+      text: r.text,
+      startLine: r.startLine,
+      startCol: r.startCol
+    } : void 0;
+    return {
+      name: a,
+      kind: o,
+      members: d,
+      contract: u,
+      signature: c,
+      implementsInterfaces: l
+    };
+  }
+  /**
+   * @purpose Determines whether an export_statement is a re-export.
+   * @param node export_statement node.
+   * @returns True if the export is a re-export that should be skipped.
+   */
+  _isReExport(e) {
+    for (let t = 0; t < e.childCount; t += 1) {
+      const r = e.child(t);
+      if (r && (r.type === "export_clause" || r.type === "*"))
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * @purpose Maps a declaration node type to an entity kind string.
+   * @param nodeType tree-sitter node type.
+   * @param isDefault Whether this is a default export.
+   * @returns Entity kind.
+   */
+  _mapKind(e, t) {
+    switch (e) {
+      case "function_declaration":
+      case "generator_function_declaration":
+        return "function";
+      case "class_declaration":
+        return "class";
+      case "interface_declaration":
+        return "interface";
+      case "type_alias_declaration":
+        return "type";
+      case "enum_declaration":
+        return "enum";
+      case "lexical_declaration":
+      case "variable_declaration":
+        return "const";
+      default:
+        return t ? "export-default" : e;
+    }
+  }
+  /**
+   * @purpose Extracts the entity name from a declaration node.
+   * @param node Declaration node.
+   * @param source Full source text.
+   * @param isDefault Whether this is a default export.
+   * @returns Entity name.
+   */
+  _extractName(e, t, r) {
+    const n = e.childForFieldName?.("name") ?? null;
+    if (n)
+      return t.slice(n.startIndex, n.endIndex);
+    for (let s = 0; s < e.childCount; s += 1) {
+      const o = e.child(s);
+      if (o) {
+        if (o.type === "variable_declarator") {
+          const a = o.child(0);
+          if (a)
+            return t.slice(a.startIndex, a.endIndex);
+        }
+        if (o.type === "identifier" && r)
+          return t.slice(o.startIndex, o.endIndex);
+      }
+    }
+    return r ? "_default" : "unknown";
+  }
+  /**
+   * @purpose Extracts signature info (params + returnType) from a callable declaration.
+   * @param node Declaration node.
+   * @param source Full source text.
+   * @returns Signature info with empty arrays for non-callable entities.
+   */
+  _extractSignature(e, t) {
+    const r = [];
+    let n = "void";
+    const s = this._findChild(e, "formal_parameters");
+    if (s)
+      for (let a = 0; a < s.childCount; a += 1) {
+        const c = s.child(a);
+        c && (c.type === "required_parameter" || c.type === "optional_parameter") && r.push(this._extractParam(c, t));
+      }
+    if (e.type === "function_type") {
+      const a = [];
+      for (let d = 0; d < e.childCount; d += 1) {
+        const l = e.child(d);
+        l && a.push(l);
+      }
+      const c = a.findIndex((d) => d.type === "=>");
+      return c >= 0 && c + 1 < a.length && (n = t.slice(a[c + 1].startIndex, a[c + 1].endIndex).trim(), n || (n = "unknown")), { params: r, returnType: n };
+    }
+    const o = e.childForFieldName?.("return_type") ?? null;
+    return o && (n = t.slice(o.startIndex + 1, o.endIndex).trim(), n || (n = "unknown")), r.length === 0 && !o && (n = "void"), { params: r, returnType: n };
+  }
+  /**
+   * @purpose Extracts a single parameter (required or optional) from the formal_parameters list.
+   * @param paramNode required_parameter or optional_parameter node.
+   * @param source Full source text.
+   * @returns Parameter info.
+   */
+  _extractParam(e, t) {
+    let r = "", n = "any", s = e.type === "optional_parameter", o = !1;
+    for (let a = 0; a < e.childCount; a += 1) {
+      const c = e.child(a);
+      if (c) {
+        if (c.type === "rest_pattern") {
+          o = !0;
+          for (let d = 0; d < c.childCount; d += 1) {
+            const l = c.child(d);
+            l && (l.type === "identifier" || l.type === "object_pattern" || l.type === "array_pattern") && (r = t.slice(l.startIndex, l.endIndex));
+          }
+          continue;
+        }
+        if (c.type === "...") {
+          o = !0;
+          continue;
+        }
+        if (c.type === "?") {
+          s = !0;
+          continue;
+        }
+        if (c.type === "=") {
+          s = !0;
+          continue;
+        }
+        if (c.type === "identifier" || c.type === "object_pattern" || c.type === "array_pattern") {
+          r = t.slice(c.startIndex, c.endIndex);
+          continue;
+        }
+        if (c.type === "type_annotation") {
+          for (let d = 0; d < c.childCount; d += 1) {
+            const l = c.child(d);
+            l && l.type !== ":" && (n = t.slice(l.startIndex, l.endIndex));
+          }
+          continue;
+        }
+      }
+    }
+    return { name: r, type: n, optional: s, isRest: o };
+  }
+  /**
+   * @purpose Extracts members of a class, interface, or enum entity.
+   * @param node Declaration node.
+   * @param source Full source text.
+   * @param kind Entity kind.
+   * @returns Array of members (empty for non-collection entities).
+   */
+  _extractMembers(e, t, r) {
+    return r === "class" ? this._extractClassMembers(e, t) : r === "interface" ? this._extractInterfaceMembers(e, t) : r === "enum" ? this._extractEnumMembers(e, t) : r === "type" ? this._extractTypeAliasMembers(e, t) : [];
+  }
+  /**
+   * @purpose Extracts members from a class declaration body.
+   * @param node class_declaration node.
+   * @param source Full source text.
+   * @returns Array of class members.
+   */
+  _extractClassMembers(e, t) {
+    const r = e.childForFieldName?.("body") ?? null;
+    if (!r) return [];
+    const n = [];
+    let s;
+    for (let o = 0; o < r.childCount; o += 1) {
+      const a = r.child(o);
+      if (!a) continue;
+      if (a.type === "comment") {
+        const u = t.slice(a.startIndex, a.endIndex);
+        u.startsWith("/**") ? s = {
+          text: u,
+          startLine: a.startPosition.row + 1,
+          startCol: a.startPosition.column + 1
+        } : s = void 0;
+        continue;
+      }
+      if (a.type === "comment") {
+        s = void 0;
+        continue;
+      }
+      let c, d = "", l = null;
+      if (a.type === "method_definition" ? (d = this._extractMethodName(a, t), d === "constructor" ? c = "constructor" : this._hasToken(a, "get") ? c = "getter" : this._hasToken(a, "set") ? c = "setter" : c = "method", l = a) : a.type === "public_field_definition" && (d = this._extractFieldName(a, t), c = "field"), c && d) {
+        const u = l ? this._extractSignature(l, t) : { params: [], returnType: "void" }, h = s ? {
+          text: s.text,
+          startLine: s.startLine,
+          startCol: s.startCol
+        } : void 0;
+        n.push({ name: d, kind: c, contract: h, signature: u }), s = void 0;
+      } else
+        s = void 0;
+    }
+    return n;
+  }
+  /**
+   * @purpose Extracts members from an interface declaration body.
+   * @param node interface_declaration node.
+   * @param source Full source text.
+   * @returns Array of interface members.
+   */
+  _extractInterfaceMembers(e, t) {
+    const r = e.childForFieldName?.("body") ?? null;
+    return r ? this._extractObjectTypeMembers(r, t) : [];
+  }
+  /**
+   * @purpose Extracts members from a type alias with an object type literal body.
+   * Delegates to the same logic as interface members since object_type ≡ interface body.
+   * @param node type_alias_declaration node.
+   * @param source Full source text.
+   * @returns Array of object type members.
+   */
+  _extractTypeAliasMembers(e, t) {
+    for (let r = 0; r < e.childCount; r += 1) {
+      const n = e.child(r);
+      if (n?.type === "object_type")
+        return this._extractObjectTypeMembers(n, t);
+    }
+    return [];
+  }
+  /**
+   * @purpose Extracts members from an object_type or interface body node.
+   * Shared by type alias (object_type) and interface declarations.
+   * @param body object_type or interface_body node.
+   * @param source Full source text.
+   * @returns Array of members.
+   */
+  _extractObjectTypeMembers(e, t) {
+    const r = [];
+    let n;
+    for (let s = 0; s < e.childCount; s += 1) {
+      const o = e.child(s);
+      if (!o) continue;
+      if (o.type === "comment") {
+        const l = t.slice(o.startIndex, o.endIndex);
+        l.startsWith("/**") ? n = {
+          text: l,
+          startLine: o.startPosition.row + 1,
+          startCol: o.startPosition.column + 1
+        } : n = void 0;
+        continue;
+      }
+      if (o.type === "{" || o.type === "}" || o.type === ";" || o.type === ",")
+        continue;
+      let a, c = "", d = null;
+      if (o.type === "method_signature") {
+        const l = o.childForFieldName?.("name") ?? null;
+        l && (c = t.slice(l.startIndex, l.endIndex)), a = "interface-method", d = o;
+      } else if (o.type === "property_signature") {
+        const l = o.childForFieldName?.("name") ?? null;
+        l && (c = t.slice(l.startIndex, l.endIndex)), this._isFunctionTypedProperty(o) ? (a = "interface-method", d = this._findFunctionTypeNode(o)) : a = "interface-property";
+      }
+      if (a && c) {
+        const l = d ? this._extractSignature(d, t) : { params: [], returnType: "void" }, u = n ? {
+          text: n.text,
+          startLine: n.startLine,
+          startCol: n.startCol
+        } : void 0;
+        r.push({ name: c, kind: a, contract: u, signature: l }), n = void 0;
+      } else
+        n = void 0;
+    }
+    return r;
+  }
+  /**
+   * @purpose Checks if a property_signature node has a function type annotation.
+   * @param node property_signature node.
+   * @returns True if the property is function-typed.
+   */
+  _isFunctionTypedProperty(e) {
+    for (let t = 0; t < e.childCount; t += 1) {
+      const r = e.child(t);
+      if (r?.type === "type_annotation") {
+        for (let n = 0; n < r.childCount; n += 1)
+          if (r.child(n)?.type === "function_type") return !0;
+      }
+    }
+    return !1;
+  }
+  /**
+   * @purpose Finds the function_type node inside a property_signature's type annotation.
+   * @param node property_signature node.
+   * @returns The function_type node, or null.
+   */
+  _findFunctionTypeNode(e) {
+    for (let t = 0; t < e.childCount; t += 1) {
+      const r = e.child(t);
+      if (r?.type === "type_annotation")
+        for (let n = 0; n < r.childCount; n += 1) {
+          const s = r.child(n);
+          if (s?.type === "function_type") return s;
+        }
+    }
+    return null;
+  }
+  /**
+   * @purpose Extracts members from an enum declaration body.
+   * @param node enum_declaration node.
+   * @param source Full source text.
+   * @returns Array of enum members.
+   */
+  _extractEnumMembers(e, t) {
+    const r = e.childForFieldName?.("body") ?? null;
+    if (!r) return [];
+    const n = [];
+    let s;
+    for (let o = 0; o < r.childCount; o += 1) {
+      const a = r.child(o);
+      if (a) {
+        if (a.type === "comment") {
+          const c = t.slice(a.startIndex, a.endIndex);
+          c.startsWith("/**") ? s = {
+            text: c,
+            startLine: a.startPosition.row + 1,
+            startCol: a.startPosition.column + 1
+          } : s = void 0;
+          continue;
+        }
+        if (a.type === "property_identifier" || a.type === "identifier" || a.type === "string" || a.type === "shorthand_property_identifier") {
+          const c = t.slice(a.startIndex, a.endIndex), d = s ? {
+            text: s.text,
+            startLine: s.startLine,
+            startCol: s.startCol
+          } : void 0;
+          n.push({
+            name: c,
+            kind: "enum-member",
+            contract: d,
+            signature: { params: [], returnType: "void" }
+          }), s = void 0;
+        } else a.type !== "," && a.type !== "{" && a.type !== "}" && (s = void 0);
+      }
+    }
+    return n;
+  }
+  /**
+   * @purpose Extracts the method name from a method_definition node,
+   * handling getter/setter property names.
+   * @param node method_definition node.
+   * @param source Full source text.
+   * @returns Method name.
+   */
+  _extractMethodName(e, t) {
+    const r = e.childForFieldName?.("name") ?? null;
+    return r ? t.slice(r.startIndex, r.endIndex) : "unknown";
+  }
+  /**
+   * @purpose Extracts the field name from a public_field_definition node.
+   * @param node public_field_definition node.
+   * @param source Full source text.
+   * @returns Field name.
+   */
+  _extractFieldName(e, t) {
+    for (let r = 0; r < e.childCount; r += 1) {
+      const n = e.child(r);
+      if (n && (n.type === "property_identifier" || n.type === "identifier"))
+        return t.slice(n.startIndex, n.endIndex);
+    }
+    return "unknown";
+  }
+  /**
+   * @purpose Checks if a method_definition has a given token (e.g., 'get', 'set').
+   * @param node method_definition node.
+   * @param token Token text to search for.
+   * @returns True if the token is present.
+   */
+  _hasToken(e, t) {
+    for (let r = 0; r < e.childCount; r += 1) {
+      const n = e.child(r);
+      if (n && n.type === t)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * @purpose Checks if a class_declaration node has an implements clause.
+   * @param node class_declaration node.
+   * @returns True if the class has `implements` clause.
+   */
+  _hasImplements(e) {
+    const t = this._findChild(e, "class_heritage");
+    return t ? this._findChild(t, "implements_clause") !== null : !1;
+  }
+  /**
+   * @purpose Finds a direct child node by type, returning first match.
+   * @param parent Parent node.
+   * @param type Child node type to find.
+   * @returns First matching child or null.
+   */
+  _findChild(e, t) {
+    for (let r = 0; r < e.childCount; r += 1) {
+      const n = e.child(r);
+      if (n && n.type === t)
+        return n;
+    }
+    return null;
+  }
+  /**
+   * @purpose Recursively searches for the first ERROR node in the tree.
+   * @param node Root node to search from.
+   * @returns First ERROR node found, or undefined.
+   */
+  _findErrorNode(e) {
+    if (e.type === "ERROR" || e.isError)
+      return e;
+    for (let t = 0; t < e.childCount; t += 1) {
+      const r = e.child(t);
+      if (!r) continue;
+      const n = this._findErrorNode(r);
+      if (n) return n;
+    }
+  }
+}
+class Ge extends Error {
+  /** @purpose The conflicting provider key */
+  key;
+  /**
+   * @purpose Construct with the duplicate key and a trace-prefixed message.
+   * @param key The provider key that is already registered.
+   */
+  constructor(e) {
+    super(`[DuplicateProviderError] Provider with key "${e}" is already registered`), this.name = "DuplicateProviderError", this.key = e;
+  }
+}
+class ze extends Error {
+  /** @purpose The missing provider key */
+  key;
+  /**
+   * @purpose Construct with the missing key and a trace-prefixed message.
+   * @param key The provider key that was not found.
+   */
+  constructor(e) {
+    super(`[ProviderNotFoundError] Provider with key "${e}" is not registered`), this.name = "ProviderNotFoundError", this.key = e;
+  }
+}
+class He {
+  /** @purpose Provider registry — maps string keys to AgentProvider instances | @invariant Empty on construction; mutated only via register/unregister */
+  _providers = /* @__PURE__ */ new Map();
+  /**
+   * @purpose Register a provider under a unique key; rejects on duplicate.
+   * @param key Unique provider identifier — non-empty string.
+   * @param provider The provider instance implementing AgentProvider.
+   * @throws {DuplicateProviderError} When key is already registered.
+   * @post Provider is stored in the registry under the given key.
+   */
+  register(e, t) {
+    if (this._providers.has(e))
+      throw new Ge(e);
+    this._providers.set(e, t), g.debug(`[AgentMonitor#register] [idle → registered] ${e}`);
+  }
+  /**
+   * @purpose Remove a provider from the registry; no-op when the key is not found.
+   * @param key Provider key to remove.
+   * @post Provider with the given key is no longer in the registry.
+   */
+  unregister(e) {
+    this._providers.delete(e), g.debug(`[AgentMonitor#unregister] [registered → removed] ${e}`);
+  }
+  /**
+   * @purpose Scan all registered providers concurrently, aggregate and sort results by startedAt descending.
+   * @invariant Graceful degradation: a failing provider returns [] and does not abort other providers.
+   * @param [opts] Optional scan filtering (since timestamp or 'today').
+   * @returns All sessions from all providers, sorted by startedAt descending.
+   * @sideEffect Calls each registered provider's scan() — may read filesystem / database.
+   */
+  async scanAll(e) {
+    g.debug(`[AgentMonitor#scanAll] [idle → scanning] providers=${this._providers.size}`);
+    const r = (await Promise.all(
+      [...this._providers.values()].map(async (n) => {
+        try {
+          return await n.scan(e);
+        } catch (s) {
+          const o = new Error(`[AgentMonitor#scanAll] Provider ${n.key} failed`, {
+            cause: s
+          });
+          return g.error(`[AgentMonitor#scanAll] [scanning → degraded] ${n.key}`, { error: o }), [];
+        }
+      })
+    )).flat().sort((n, s) => s.startedAt - n.startedAt);
+    return g.info(`[AgentMonitor#scanAll] [scanning → completed] sessions=${r.length}`), r;
+  }
+  /**
+   * @purpose Scan a single provider by key; rejects when the provider is not registered.
+   * @param key Registered provider key.
+   * @param [opts] Optional scan filtering.
+   * @throws {ProviderNotFoundError} When the key is not registered.
+   * @returns Sessions from the specified provider.
+   * @sideEffect Calls the provider's scan() — may read filesystem / database.
+   */
+  async scanOne(e, t) {
+    g.debug(`[AgentMonitor#scanOne] [idle → scanning] ${e}`);
+    const r = this._providers.get(e);
+    if (r === void 0)
+      throw new ze(e);
+    try {
+      const n = await r.scan(t);
+      return g.info(
+        `[AgentMonitor#scanOne] [scanning → completed] ${e} sessions=${n.length}`
+      ), n;
+    } catch (n) {
+      const s = new Error(`[AgentMonitor#scanOne] Provider ${e} failed`, { cause: n });
+      throw g.error(`[AgentMonitor#scanOne] [scanning → failed] ${e}`, { error: s }), s;
+    }
+  }
+}
+function Ct() {
+  return new He();
+}
+function qe(i) {
+  if (i.length === 0) return /* @__PURE__ */ new Map();
+  try {
+    const e = i.join(","), t = le(`ps -p ${e} -o pid=,pcpu=,rss=,args=`, {
+      encoding: "utf-8",
+      timeout: 5e3
+    }), r = /* @__PURE__ */ new Map(), n = t.trim().split(`
+`);
+    for (const s of n) {
+      const o = s.trim();
+      if (!o) continue;
+      const a = o.split(/\s+/);
+      if (a.length < 4) continue;
+      const c = a[0], d = a[1], l = a[2], u = a.slice(3).join(" "), h = parseInt(c, 10), p = parseFloat(d), f = parseInt(l, 10);
+      isNaN(h) || isNaN(p) || isNaN(f) || r.set(h, {
+        pid: h,
+        cpuPercent: p,
+        memoryMb: f / 1024,
+        args: u
+      });
+    }
+    return g.debug(
+      `[psInfo] [idle → completed] Batch ps: ${i.length} requested, ${r.size} alive`
+    ), r;
+  } catch (e) {
+    const t = new Error("[psInfo] Batch ps command failed", { cause: e });
+    return g.warn(`[psInfo] [idle → failed] ps command error for ${i.length} PIDs`, { error: t }), /* @__PURE__ */ new Map();
+  }
+}
+function Ve(i) {
+  const e = {}, t = i.match(/--model\s+(\S+)/);
+  t && (e.model = t[1]);
+  const r = i.match(/--effort\s+(\S+)/);
+  return r && (e.effort = r[1]), e;
+}
+function Ke(i) {
+  const e = i.match(/--allowedTools\s+([^"]*?)(?:\s+--|$)/);
+  if (!e) return;
+  const r = (e[1] ?? "").match(/Read\(\/\/(?:Users\/[^/]+\/Developer\/)?([^)]+?)(?:\/\*\*)?\)/);
+  if (!r) return;
+  const s = (r[1] ?? "").split("/");
+  return s.length <= 1 ? s[0] : s.slice(-2).join("/");
+}
+function Xe(i) {
+  try {
+    const e = A(i, "utf-8"), t = JSON.parse(e);
+    if (typeof t != "object" || t === null)
+      return g.warn(`[readSessionJson] [idle -> skipped] Not a JSON object: ${i}`), null;
+    const r = t;
+    return typeof r.pid != "number" || typeof r.sessionId != "string" || typeof r.cwd != "string" || typeof r.startedAt != "number" ? (g.warn(`[readSessionJson] [idle -> skipped] Missing required fields in: ${i}`), null) : {
+      pid: r.pid,
+      sessionId: r.sessionId,
+      cwd: r.cwd,
+      startedAt: r.startedAt
+    };
+  } catch (e) {
+    const t = new Error("[readSessionJson] Failed to parse session JSON", { cause: e });
+    return g.error(`[readSessionJson] [idle -> failed] ${i}`, { error: t }), null;
+  }
+}
+function Ye(i, e) {
+  try {
+    const t = i.replace(/\//g, "-"), r = $(D(), ".claude", "projects", t, `${e}.jsonl`);
+    if (!K(r))
+      return g.debug(`[readSessionTitle] [idle -> not-found] JSONL missing: ${r}`), "Unknown";
+    const s = A(r, "utf-8").trim().split(`
+`);
+    for (const o of s)
+      try {
+        const a = JSON.parse(o);
+        if (typeof a == "object" && a !== null && a.type === "ai-title" && typeof a.aiTitle == "string")
+          return a.aiTitle;
+      } catch {
+      }
+    for (const o of s)
+      try {
+        const a = JSON.parse(o);
+        if (typeof a == "object" && a !== null && a.type === "user") {
+          const c = a.message;
+          if (c?.content) {
+            const d = typeof c.content == "string" ? c.content : Array.isArray(c.content) && c.content.length > 0 ? String(c.content[0]?.text ?? "") : "";
+            if (d) return d;
+          }
+        }
+      } catch {
+      }
+    return "Unknown";
+  } catch (t) {
+    const r = new Error("[readSessionTitle] Failed to read session title", { cause: t });
+    return g.warn(`[readSessionTitle] [idle -> failed] cwd=${i} sessionId=${e}`, { error: r }), "Unknown";
+  }
+}
+function Qe(i) {
+  try {
+    const e = $(D(), ".claude", "tasks", i);
+    if (!K(e)) return "Unknown";
+    const t = X(e).filter((n) => n.endsWith(".json"));
+    if (t.length === 0) return "Unknown";
+    let r;
+    for (const n of t)
+      try {
+        const s = A($(e, n), "utf-8"), o = JSON.parse(s), a = o?.subject;
+        if (!a) continue;
+        if (o?.status === "in_progress") return a;
+        r = r ?? a;
+      } catch {
+      }
+    return r ?? "Unknown";
+  } catch {
+    return "Unknown";
+  }
+}
+class xt {
+  /** @see {AgentProvider#key} in ../../model/agent-provider.type.ts */
+  key = "claude";
+  /** @purpose Batch ps inspection function */
+  _psInfo;
+  /** @purpose Claude CLI argument parser */
+  _parseClaudeArgs;
+  /** @purpose Session JSON file reader */
+  _readSessionJson;
+  /** @purpose Session title extractor from JSONL */
+  _readSessionTitle;
+  /** @purpose Logger instance */
+  _logger;
+  /**
+   * @purpose Construct with optional DI overrides for testing.
+   * @param [deps] Injectable function replacements; omitted deps use real implementations.
+   */
+  constructor(e) {
+    this._psInfo = e?.psInfo ?? qe, this._parseClaudeArgs = e?.parseClaudeArgs ?? Ve, this._readSessionJson = e?.readSessionJson ?? Xe, this._readSessionTitle = e?.readSessionTitle ?? Ye, this._logger = g;
+  }
+  /**
+   * @param [opts] Optional scan filtering parameters.
+   * @returns Parsed agent sessions array.
+   * @see {AgentProvider#scan} in ../../model/agent-provider.type.ts
+   */
+  async scan(e) {
+    this._logger.debug("[ClaudeProvider#scan] [idle -> scanning]");
+    const t = $(D(), ".claude", "sessions");
+    let r;
+    try {
+      r = X(t).filter((l) => l.endsWith(".json"));
+    } catch (l) {
+      if (l.code === "ENOENT")
+        return this._logger.warn(
+          `[ClaudeProvider#scan] [scanning -> not-found] Sessions dir missing: ${t}`
+        ), [];
+      const u = new Error("[ClaudeProvider#scan] Failed to read sessions directory", { cause: l });
+      return this._logger.error("[ClaudeProvider#scan] [scanning -> failed]", { error: u }), [];
+    }
+    const n = [];
+    for (const l of r) {
+      const u = $(t, l), h = this._readSessionJson(u);
+      if (!h) continue;
+      let p = 0;
+      try {
+        p = ae(u).mtimeMs;
+      } catch {
+        p = h.startedAt;
+      }
+      n.push({
+        pid: h.pid,
+        sessionId: h.sessionId,
+        cwd: h.cwd,
+        startedAt: h.startedAt,
+        lastActivityAt: p
+      });
+    }
+    if (n.length === 0)
+      return this._logger.debug("[ClaudeProvider#scan] [scanning -> empty] No valid sessions found"), [];
+    const s = n.map((l) => l.pid), o = this._psInfo(s), a = Date.now(), c = [];
+    for (const l of n) {
+      const u = o.get(l.pid), h = u !== void 0;
+      let p, f, m;
+      h ? (u?.cpuPercent ?? 0) > 0 ? p = "active" : (p = "idle", f = l.lastActivityAt > 0 ? (a - l.lastActivityAt) / 1e3 : void 0) : (p = "completed", m = l.lastActivityAt > 0 ? l.lastActivityAt : a);
+      const _ = u ? this._parseClaudeArgs(u.args).model : void 0;
+      let w = this._readSessionTitle(l.cwd, l.sessionId);
+      if (w === "Unknown" && (w = Qe(l.sessionId)), w === "Unknown" && u) {
+        const b = Ke(u.args);
+        b ? w = `${M.basename(l.cwd)}: ${b}` : w = `[${M.basename(l.cwd)}] session`;
+      }
+      const I = (a - l.startedAt) / 1e3;
+      c.push({
+        provider: "claude",
+        pid: l.pid,
+        sessionId: l.sessionId,
+        cwd: l.cwd,
+        project: M.basename(l.cwd),
+        startedAt: l.startedAt,
+        lastActivityAt: l.lastActivityAt > 0 ? l.lastActivityAt : void 0,
+        status: p,
+        title: w,
+        model: _,
+        cpuPercent: u?.cpuPercent,
+        memoryMb: u?.memoryMb,
+        elapsedSeconds: I,
+        idleSeconds: f,
+        completedAt: m
+      });
+    }
+    let d = c;
+    if (e?.since !== void 0) {
+      const l = e.since === "today" ? Ze() : e.since;
+      d = c.filter((u) => u.startedAt >= l);
+    }
+    return this._logger.info(
+      `[ClaudeProvider#scan] [scanning -> completed] ${d.length} sessions (${c.length} total)`
+    ), d;
+  }
+}
+function Ze() {
+  const i = /* @__PURE__ */ new Date();
+  return i.setHours(0, 0, 0, 0), i.getTime();
+}
+function et(i, e) {
+  let t = "SELECT id, slug, title, directory, time_created, time_updated, agent, model, tokens_input, tokens_output, parent_id FROM session WHERE time_archived IS NULL";
+  const r = [], n = e?.since ?? Date.now() - 864e5;
+  return t += " AND time_updated >= ?", r.push(n), t += " ORDER BY time_updated DESC", i.prepare(t).all(...r);
+}
+function tt(i, e) {
+  const r = i.prepare(
+    "SELECT data FROM message WHERE session_id = ? ORDER BY time_updated DESC LIMIT 1"
+  ).get(e);
+  if (!r?.data) return null;
+  try {
+    const s = JSON.parse(r.data)?.content;
+    return typeof s == "string" ? s : Array.isArray(s) && s.length > 0 && typeof s[0]?.text == "string" ? s[0].text : null;
+  } catch {
+    return r.data;
+  }
+}
+function nt(i) {
+  if (i)
+    try {
+      return JSON.parse(i).id ?? i;
+    } catch {
+      return "unknown";
+    }
+}
+const rt = "~/.local/share/opencode/opencode.db";
+class Rt {
+  /** @purpose Provider identifier key ('opencode') */
+  key = "opencode";
+  /** @purpose Resolved dependency injection container */
+  _deps;
+  /** @purpose Logger instance for structured logging */
+  _logger = g;
+  /**
+   * @purpose Construct with optional dependency injection for testing.
+   * @param [deps] Injectable query functions and db path overrides.
+   */
+  constructor(e) {
+    this._deps = {
+      dbPath: e?.dbPath ?? rt,
+      querySessions: e?.querySessions ?? et,
+      queryLastMessage: e?.queryLastMessage ?? tt,
+      parseModelJson: e?.parseModelJson ?? nt
+    };
+  }
+  /**
+   * @param [opts] Optional scan filtering parameters.
+   * @returns Parsed agent sessions array.
+   * @see {AgentProvider#scan} in ../../model/agent-provider.type.ts
+   */
+  async scan(e) {
+    this._logger.debug("[OpenCodeProvider#scan] [idle → opening]");
+    const t = this._resolvePath(this._deps.dbPath);
+    let r;
+    try {
+      r = new de(t);
+    } catch (n) {
+      return this._logger.warn(`[OpenCodeProvider#scan] [opening → not_found] ${t}`, { cause: n }), [];
+    }
+    try {
+      const n = this._deps.querySessions(r, e), s = [];
+      for (const o of n) {
+        const a = this._deps.parseModelJson(o.model), c = this._deps.queryLastMessage(r, o.id), d = o.time_created, l = o.time_updated, u = Math.max(0, Math.round((l - d) / 1e3));
+        s.push({
+          provider: "opencode",
+          pid: null,
+          sessionId: o.slug,
+          parentId: o.parent_id ?? void 0,
+          title: o.title ?? "",
+          slug: o.slug,
+          cwd: o.directory,
+          project: o.directory.split("/").pop() ?? o.directory,
+          model: a,
+          agent: o.agent ?? void 0,
+          status: "active",
+          startedAt: d,
+          lastActivityAt: l,
+          elapsedSeconds: u,
+          tokensInput: o.tokens_input ?? void 0,
+          tokensOutput: o.tokens_output ?? void 0,
+          lastMessage: c ?? void 0
+        });
+      }
+      return this._logger.info(`[OpenCodeProvider#scan] [querying → scanned] ${s.length} sessions`), s;
+    } catch (n) {
+      const s = new Error("[OpenCodeProvider#scan] Query failed", { cause: n });
+      return this._logger.error("[OpenCodeProvider#scan] [querying → failed]", { error: s }), [];
+    } finally {
+      r.close();
+    }
+  }
+  /**
+   * @purpose Resolve tilde-prefixed path to an absolute path using the home directory.
+   * @param raw Raw path string potentially starting with ~/.
+   * @returns Absolute path with ~ resolved to os.homedir().
+   */
+  _resolvePath(e) {
+    return e.startsWith("~/") ? M.join(ce.homedir(), e.slice(2)) : e;
+  }
+}
+const st = [
+  "status",
+  "title",
+  "lastActivityAt",
+  "elapsedSeconds",
+  "idleSeconds",
+  "toolCallCount",
+  "errorCount",
+  "lastMessage",
+  "tokensInput",
+  "tokensOutput"
+];
+function it(i, e) {
+  g.debug("[diff] [idle → comparing]");
+  const t = new Map(i.map((a) => [a.sessionId, a])), r = new Map(e.map((a) => [a.sessionId, a])), n = [], s = [], o = [];
+  for (const a of e) {
+    const c = t.get(a.sessionId);
+    if (!c) {
+      n.push(a);
+      continue;
+    }
+    ot(c, a) && o.push(a);
+  }
+  for (const a of i)
+    r.has(a.sessionId) || s.push(a);
+  return g.debug(
+    `[diff] [comparing → done] added=${n.length} removed=${s.length} updated=${o.length}`
+  ), { added: n, removed: s, updated: o };
+}
+function ot(i, e) {
+  return st.some((t) => i[t] !== e[t]);
+}
+const at = 3e5, q = 100;
+function V(i, e) {
+  const t = Date.now();
+  for (const r of i)
+    r.lastActivityAt !== void 0 && t - r.lastActivityAt > e && (r.status = "idle");
+}
+function ct() {
+  return { added: [], removed: [], updated: [] };
+}
+async function* Et(i, e) {
+  if (e.interval < q)
+    throw new RangeError(
+      `[observe] interval must be >= ${q}ms, got ${e.interval}`
+    );
+  const t = e.idleThresholdMs ?? at;
+  g.debug(
+    `[observe] [idle → initializing] interval=${e.interval}ms idleThreshold=${t}ms`
+  );
+  let r;
+  try {
+    r = await i.scanAll(), V(r, t), g.debug(`[observe] [initializing → baseline] sessions=${r.length}`);
+  } catch (n) {
+    const s = new Error("[observe] Baseline scan failed", { cause: n });
+    g.error("[observe] [initializing → failed]", { error: s }), r = [];
+  }
+  for (; ; ) {
+    await new Promise((n) => setTimeout(n, e.interval));
+    try {
+      const n = await i.scanAll();
+      V(n, t);
+      const s = it(r, n);
+      g.debug(
+        `[observe] [polling → yielded] added=${s.added.length} removed=${s.removed.length} updated=${s.updated.length}`
+      ), r = n, yield s;
+    } catch (n) {
+      const s = new Error("[observe] Scan cycle failed", { cause: n });
+      g.error("[observe] [polling → degraded]", { error: s }), yield ct();
+    }
+  }
+}
+export {
+  xt as C,
+  It as D,
+  Rt as O,
+  $e as R,
+  _t as V,
+  vt as a,
+  St as b,
+  wt as c,
+  yt as d,
+  Ct as e,
+  be as f,
+  L as g,
+  g as l,
+  Et as o,
+  gt as p,
+  bt as r,
+  mt as s
+};