anycodex 0.0.23 → 0.0.24

package/dist/{chunk-RKQHI4QK.js → chunk-NRFXEZ7N.js}

@@ -1,16 +1,576 @@
 #!/usr/bin/env node
-import {
-  Glob
-} from "./chunk-H3TAXRCT.js";
 import {
   Schema_exports,
+  __callDispose,
+  __using,
   withStatics,
   zod_default
-} from "./chunk-3KUWIT4H.js";
-import {
-  __callDispose,
-  __using
-} from "./chunk-XXVDY7BO.js";
+} from "./chunk-M6C7CWX3.js";
+
+// ../utils/dist/index.js
+import fs from "fs/promises";
+import { existsSync, statSync, readdirSync } from "fs";
+import path from "path";
+import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
+import fs2 from "fs/promises";
+import path2 from "path";
+import fs3 from "fs";
+import nodePath from "path";
+var consoleLogger = {
+  debug: console.debug.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console)
+};
+var SqliteNoSqlDb = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  insert(table, row) {
+    const cols = Object.keys(row);
+    const placeholders = cols.map(() => "?").join(", ");
+    const sql2 = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+    this.raw.run(sql2, cols.map((c) => serialize(row[c])));
+  }
+  upsert(table, row, conflictKeys, updateFields) {
+    const cols = Object.keys(row);
+    const placeholders = cols.map(() => "?").join(", ");
+    const conflict = conflictKeys.map((k) => `"${k}"`).join(", ");
+    const updates = Object.keys(updateFields).map((k) => `"${k}" = ?`).join(", ");
+    const sql2 = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders}) ON CONFLICT (${conflict}) DO UPDATE SET ${updates}`;
+    const params = [
+      ...cols.map((c) => serialize(row[c])),
+      ...Object.keys(updateFields).map((k) => serialize(updateFields[k]))
+    ];
+    this.raw.run(sql2, params);
+  }
+  findOne(table, filter2, options) {
+    const fields = options?.select?.map((f) => `"${f}"`).join(", ") ?? "*";
+    const { clause, params } = filter2 ? buildWhere(filter2) : { clause: "", params: [] };
+    const where = clause ? ` WHERE ${clause}` : "";
+    const sql2 = `SELECT ${fields} FROM "${table}"${where} LIMIT 1`;
+    const row = this.raw.get(sql2, params);
+    return row ? deserializeRow(row) : void 0;
+  }
+  findMany(table, options) {
+    const fields = options?.select?.map((f) => `"${f}"`).join(", ") ?? "*";
+    const { clause, params } = options?.filter ? buildWhere(options.filter) : { clause: "", params: [] };
+    const where = clause ? ` WHERE ${clause}` : "";
+    let orderClause = "";
+    if (options?.orderBy?.length) {
+      const parts = options.orderBy.map(
+        (o) => `"${o.field}" ${o.direction === "desc" ? "DESC" : "ASC"}`
+      );
+      orderClause = ` ORDER BY ${parts.join(", ")}`;
+    }
+    const limitClause = options?.limit != null ? ` LIMIT ${options.limit}` : "";
+    const sql2 = `SELECT ${fields} FROM "${table}"${where}${orderClause}${limitClause}`;
+    return this.raw.all(sql2, params).map(deserializeRow);
+  }
+  update(table, filter2, set) {
+    const setCols = Object.keys(set);
+    const setClause = setCols.map((k) => `"${k}" = ?`).join(", ");
+    const { clause, params } = buildWhere(filter2);
+    const sql2 = `UPDATE "${table}" SET ${setClause} WHERE ${clause} RETURNING *`;
+    const setParams = setCols.map((k) => serialize(set[k]));
+    const row = this.raw.get(sql2, [...setParams, ...params]);
+    return row ? deserializeRow(row) : void 0;
+  }
+  remove(table, filter2) {
+    const { clause, params } = buildWhere(filter2);
+    this.raw.run(`DELETE FROM "${table}" WHERE ${clause}`, params);
+  }
+  transaction(fn) {
+    this.raw.transaction(() => {
+      fn(this);
+    });
+  }
+};
+function buildWhere(filter2) {
+  switch (filter2.op) {
+    case "eq":
+      return { clause: `"${filter2.field}" = ?`, params: [serialize(filter2.value)] };
+    case "ne":
+      return { clause: `"${filter2.field}" != ?`, params: [serialize(filter2.value)] };
+    case "gt":
+      return { clause: `"${filter2.field}" > ?`, params: [serialize(filter2.value)] };
+    case "gte":
+      return { clause: `"${filter2.field}" >= ?`, params: [serialize(filter2.value)] };
+    case "lt":
+      return { clause: `"${filter2.field}" < ?`, params: [serialize(filter2.value)] };
+    case "like":
+      return { clause: `"${filter2.field}" LIKE ?`, params: [filter2.value] };
+    case "isNull":
+      return { clause: `"${filter2.field}" IS NULL`, params: [] };
+    case "in": {
+      const placeholders = filter2.values.map(() => "?").join(", ");
+      return { clause: `"${filter2.field}" IN (${placeholders})`, params: filter2.values.map(serialize) };
+    }
+    case "and": {
+      const parts = filter2.conditions.map(buildWhere);
+      return {
+        clause: parts.map((p) => `(${p.clause})`).join(" AND "),
+        params: parts.flatMap((p) => p.params)
+      };
+    }
+    case "or": {
+      const parts = filter2.conditions.map(buildWhere);
+      return {
+        clause: parts.map((p) => `(${p.clause})`).join(" OR "),
+        params: parts.flatMap((p) => p.params)
+      };
+    }
+  }
+}
+function serialize(value) {
+  if (value === void 0) return null;
+  if (value === null) return null;
+  if (typeof value === "object" && !(value instanceof Buffer) && !(value instanceof Uint8Array)) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function deserializeRow(row) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var NodeFS = class {
+  async exists(p) {
+    return existsSync(p);
+  }
+  async stat(p) {
+    try {
+      const s = statSync(p);
+      return {
+        size: typeof s.size === "bigint" ? Number(s.size) : s.size,
+        isDirectory: s.isDirectory(),
+        isFile: s.isFile(),
+        mtimeMs: s.mtimeMs
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  async isDir(p) {
+    const s = await this.stat(p);
+    return s?.isDirectory ?? false;
+  }
+  async readText(p) {
+    return fs.readFile(p, "utf-8");
+  }
+  async readBytes(p) {
+    return fs.readFile(p);
+  }
+  async readJson(p) {
+    return JSON.parse(await this.readText(p));
+  }
+  async readDir(p) {
+    const entries = readdirSync(p, { withFileTypes: true });
+    return entries.map((e) => ({
+      name: e.name,
+      isDirectory: e.isDirectory(),
+      isFile: e.isFile()
+    }));
+  }
+  async write(p, content) {
+    try {
+      await fs.writeFile(p, content);
+    } catch (e) {
+      if (e?.code === "ENOENT") {
+        await fs.mkdir(path.dirname(p), { recursive: true });
+        await fs.writeFile(p, content);
+        return;
+      }
+      throw e;
+    }
+  }
+  async writeJson(p, data) {
+    await this.write(p, JSON.stringify(data, null, 2));
+  }
+  async mkdir(p) {
+    await fs.mkdir(p, { recursive: true });
+  }
+  async remove(p) {
+    await fs.unlink(p).catch(() => {
+    });
+  }
+  async grep(pattern, searchPath, options) {
+    return new Promise((resolve2) => {
+      const args = [
+        "--json",
+        "--line-number",
+        "--column",
+        "--no-heading",
+        ...options?.maxResults ? ["--max-count", String(options.maxResults)] : [],
+        ...options?.include?.flatMap((g) => ["--glob", g]) ?? [],
+        pattern,
+        searchPath
+      ];
+      const rg = spawn("rg", args, { stdio: ["ignore", "pipe", "pipe"] });
+      let output = "";
+      rg.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      rg.on("close", () => {
+        const results = [];
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.type === "match") {
+              results.push({
+                file: parsed.data.path.text,
+                line: parsed.data.line_number,
+                column: parsed.data.submatches?.[0]?.start ?? 0,
+                content: parsed.data.lines.text.trimEnd()
+              });
+            }
+          } catch {
+          }
+        }
+        resolve2(results);
+      });
+      rg.on("error", () => resolve2([]));
+    });
+  }
+  async glob(pattern, options = {}) {
+    const searchPath = options.cwd ?? process.cwd();
+    const { glob: fsGlob } = await import("fs/promises").catch(() => ({ glob: void 0 }));
+    if (fsGlob) {
+      try {
+        const results = [];
+        for await (const entry of fsGlob(pattern, { cwd: searchPath })) {
+          if (options.absolute) {
+            results.push(path.resolve(searchPath, entry));
+          } else {
+            results.push(entry);
+          }
+        }
+        return results;
+      } catch {
+      }
+    }
+    return new Promise((resolve2) => {
+      const rg = spawn("rg", ["--files", "--glob", pattern, searchPath], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let output = "";
+      rg.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      rg.on("close", () => {
+        resolve2(
+          output.split("\n").map((l) => l.trim()).filter(Boolean)
+        );
+      });
+      rg.on("error", () => resolve2([]));
+    });
+  }
+};
+var NodeSearchProvider = class {
+  async grep(options) {
+    options.signal?.throwIfAborted();
+    return new Promise((resolve2, reject) => {
+      const args = ["-rnH", "--color=never"];
+      if (options.include) {
+        args.push(`--include=${options.include}`);
+      }
+      args.push("--exclude-dir=.git");
+      args.push("-E");
+      args.push("--", options.pattern, options.path);
+      const proc = spawn2("grep", args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        signal: options.signal
+      });
+      let output = "";
+      proc.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      proc.on("close", () => {
+        const results = [];
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          const match2 = line.match(/^(.+?):(\d+):(.*)$/);
+          if (match2) {
+            let content = match2[3];
+            if (options.maxLineLength !== void 0 && content.length > options.maxLineLength) {
+              content = content.slice(0, options.maxLineLength) + "...";
+            }
+            results.push({
+              file: match2[1],
+              line: parseInt(match2[2], 10),
+              column: 0,
+              content
+            });
+          }
+        }
+        resolve2(results);
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  async listFiles(options) {
+    options.signal?.throwIfAborted();
+    const showHidden = options.hidden === true;
+    const results = [];
+    const limit = options.limit ?? Infinity;
+    const excludePatterns = [".git"];
+    const includePatterns = [];
+    for (const g of options.glob ?? []) {
+      if (g.startsWith("!")) {
+        excludePatterns.push(g.slice(1).replace(/[/*]+$/, ""));
+      } else {
+        includePatterns.push(g);
+      }
+    }
+    const walk = async (dir, depth) => {
+      if (results.length >= limit) return;
+      if (options.maxDepth !== void 0 && depth > options.maxDepth) return;
+      options.signal?.throwIfAborted();
+      let entries;
+      try {
+        entries = await fs2.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (results.length >= limit) return;
+        const name = entry.name;
+        if (!showHidden && name.startsWith(".")) continue;
+        const fullPath = path2.join(dir, name);
+        const relativePath = path2.relative(options.cwd, fullPath);
+        if (excludePatterns.some((p) => relativePath.startsWith(p) || name === p)) continue;
+        const isDir = entry.isDirectory() || options.follow && entry.isSymbolicLink();
+        if (isDir) {
+          await walk(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          if (includePatterns.length > 0) {
+            const matches = includePatterns.some((p) => simpleGlobMatch(name, p));
+            if (!matches) continue;
+          }
+          results.push(relativePath);
+        }
+      }
+    };
+    await walk(options.cwd, 0);
+    return results;
+  }
+  async tree(options) {
+    const limit = options.limit ?? 50;
+    const files = await this.listFiles({ cwd: options.cwd, signal: options.signal });
+    function dir(node, name) {
+      const existing = node.children.get(name);
+      if (existing) return existing;
+      const next = { name, children: /* @__PURE__ */ new Map() };
+      node.children.set(name, next);
+      return next;
+    }
+    const root = { name: "", children: /* @__PURE__ */ new Map() };
+    for (const file of files) {
+      if (file.includes(".opencode")) continue;
+      const parts = file.split(/[\/\\]/);
+      if (parts.length < 2) continue;
+      let node = root;
+      for (const part of parts.slice(0, -1)) {
+        node = dir(node, part);
+      }
+    }
+    function count(node) {
+      let total2 = 0;
+      for (const child of node.children.values()) {
+        total2 += 1 + count(child);
+      }
+      return total2;
+    }
+    const total = count(root);
+    const lines = [];
+    const queue = [];
+    for (const child of Array.from(root.children.values()).sort((a, b) => a.name.localeCompare(b.name))) {
+      queue.push({ node: child, path: child.name });
+    }
+    let used = 0;
+    for (let i = 0; i < queue.length && used < limit; i++) {
+      const { node, path: p } = queue[i];
+      lines.push(p);
+      used++;
+      for (const child of Array.from(node.children.values()).sort((a, b) => a.name.localeCompare(b.name))) {
+        queue.push({ node: child, path: `${p}/${child.name}` });
+      }
+    }
+    if (total > used) lines.push(`[${total - used} truncated]`);
+    return lines.join("\n");
+  }
+};
+function simpleGlobMatch(filename, pattern) {
+  if (pattern === "*") return true;
+  if (pattern.startsWith("*.")) {
+    const ext2 = pattern.slice(1);
+    if (ext2.startsWith(".{") && ext2.endsWith("}")) {
+      const exts = ext2.slice(2, -1).split(",");
+      return exts.some((e) => filename.endsWith(`.${e}`));
+    }
+    return filename.endsWith(ext2);
+  }
+  return filename === pattern;
+}
+var SqlJsStorage = class {
+  db = null;
+  noSqlDb = null;
+  dbPath;
+  flushTimer = null;
+  constructor(dbPath) {
+    this.dbPath = dbPath ?? null;
+  }
+  async connect(migrations) {
+    if (this.noSqlDb) return this.noSqlDb;
+    const initSqlJs = (await import("sql.js")).default;
+    const SQL3 = await initSqlJs();
+    if (this.dbPath && fs3.existsSync(this.dbPath)) {
+      const buffer = fs3.readFileSync(this.dbPath);
+      this.db = new SQL3.Database(new Uint8Array(buffer));
+    } else {
+      this.db = new SQL3.Database();
+    }
+    this.db.run("PRAGMA foreign_keys = ON");
+    this.applyMigrations(migrations);
+    this.flushSync();
+    const raw = this.createRawDb();
+    this.noSqlDb = new SqliteNoSqlDb(raw);
+    return this.noSqlDb;
+  }
+  // ── Flush to disk ──────────────────────────────────────────────
+  /** Schedule an async flush (debounced 100ms). */
+  scheduleFlush() {
+    if (!this.dbPath) return;
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flushSync();
+    }, 100);
+  }
+  /** Synchronously write the entire database to disk. */
+  flushSync() {
+    if (!this.dbPath || !this.db) return;
+    const dir = nodePath.dirname(this.dbPath);
+    fs3.mkdirSync(dir, { recursive: true });
+    const data = this.db.export();
+    fs3.writeFileSync(this.dbPath, Buffer.from(data));
+  }
+  // ── RawSqliteDb wrapper ────────────────────────────────────────
+  createRawDb() {
+    const db = this.db;
+    const self = this;
+    return {
+      run(sql2, params) {
+        db.run(sql2, params);
+        self.scheduleFlush();
+      },
+      get(sql2, params) {
+        const stmt = db.prepare(sql2);
+        if (params) stmt.bind(params);
+        if (!stmt.step()) {
+          stmt.free();
+          return void 0;
+        }
+        const result = stmt.getAsObject();
+        stmt.free();
+        return result;
+      },
+      all(sql2, params) {
+        const stmt = db.prepare(sql2);
+        if (params) stmt.bind(params);
+        const results = [];
+        while (stmt.step()) {
+          results.push(stmt.getAsObject());
+        }
+        stmt.free();
+        return results;
+      },
+      transaction(fn) {
+        db.run("BEGIN TRANSACTION");
+        try {
+          fn();
+          db.run("COMMIT");
+          self.scheduleFlush();
+        } catch (e) {
+          db.run("ROLLBACK");
+          throw e;
+        }
+      }
+    };
+  }
+  // ── Migrations ─────────────────────────────────────────────────
+  applyMigrations(entries) {
+    if (!this.db) throw new Error("SqlJsStorage: db not initialized");
+    this.db.run(`
+            CREATE TABLE IF NOT EXISTS "__drizzle_migrations" (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                hash TEXT NOT NULL,
+                created_at INTEGER
+            )
+        `);
+    const applied = /* @__PURE__ */ new Set();
+    const rows = this.db.exec(`SELECT hash FROM "__drizzle_migrations"`);
+    if (rows.length > 0) {
+      for (const row of rows[0].values) {
+        applied.add(row[0]);
+      }
+    }
+    for (const entry of entries) {
+      const hash = entry.name;
+      if (applied.has(hash)) continue;
+      this.db.run(entry.sql);
+      this.db.run(
+        `INSERT INTO "__drizzle_migrations" (hash, created_at) VALUES (?, ?)`,
+        [hash, entry.timestamp]
+      );
+    }
+  }
+  /** Run raw SQL (for server-specific DDL like extra tables). */
+  exec(sql2) {
+    if (!this.db) throw new Error("SqlJsStorage: db not initialized");
+    this.db.run(sql2);
+    this.scheduleFlush();
+  }
+  /** Run a SELECT query and return rows as objects. */
+  query(sql2, params) {
+    if (!this.db) throw new Error("SqlJsStorage: db not initialized");
+    const stmt = this.db.prepare(sql2);
+    if (params) stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+      results.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return results;
+  }
+  close() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flushSync();
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.noSqlDb = null;
+  }
+};
 
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/column-common.js
 var OriginalColumn = /* @__PURE__ */ Symbol.for("drizzle:OriginalColumn");
@@ -1307,40 +1867,1580 @@ var PrimaryKey = class {
   }
 };
 
-// ../agent/dist/chunk-KXKREECS.js
-import fs from "fs/promises";
-var sep = "/";
-function join(...parts) {
-  const joined = parts.filter(Boolean).join("/");
-  return normalize(joined);
+// ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+};
+var maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+var range = (a, b, str) => {
+  let begs, beg, left, right = void 0, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== void 0)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== void 0 && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== void 0) {
+      result = [left, right];
+    }
+  }
+  return result;
+};
+
+// ../../node_modules/.pnpm/@isaacs+brace-expansion@5.0.1/node_modules/@isaacs/brace-expansion/dist/esm/index.js
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\./g;
+var EXPANSION_MAX = 1e5;
+function numeric2(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
 }
-function dirname(p) {
-  if (!p) return ".";
-  const i = p.lastIndexOf("/");
-  if (i < 0) return ".";
-  if (i === 0) return "/";
-  return p.slice(0, i);
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
 }
-function basename(p, ext) {
-  if (p.endsWith("/")) p = p.slice(0, -1);
-  const i = p.lastIndexOf("/");
-  const base = i < 0 ? p : p.slice(i + 1);
-  if (ext && base.endsWith(ext)) return base.slice(0, -ext.length);
-  return base;
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
 }
-function extname(p) {
-  const base = basename(p);
-  const i = base.lastIndexOf(".");
-  if (i <= 0) return "";
-  return base.slice(i);
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    ;
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
 }
-function isAbsolute(p) {
-  return p.startsWith("/");
+function expand(str, options = {}) {
+  if (!str) {
+    return [];
+  }
+  const { max = EXPANSION_MAX } = options;
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
 }
-function normalize(p) {
-  if (!p) return ".";
-  const isAbs = p.startsWith("/");
-  const segments = p.split("/");
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, max, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, max, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length && k < max; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str, max, true);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], max, false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric2(n[0]);
+      const y = numeric2(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric2(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x; test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], max, false));
+      }
+    }
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length && expansions.length < max; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
+}
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/assert-valid-pattern.js
+var MAX_PATTERN_LENGTH = 1024 * 64;
+var assertValidPattern = (pattern) => {
+  if (typeof pattern !== "string") {
+    throw new TypeError("invalid pattern");
+  }
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError("pattern is too long");
+  }
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/brace-expressions.js
+var posixClasses = {
+  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
+  "[:ascii:]": ["\\x00-\\x7f", false],
+  "[:blank:]": ["\\p{Zs}\\t", true],
+  "[:cntrl:]": ["\\p{Cc}", true],
+  "[:digit:]": ["\\p{Nd}", true],
+  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
+  "[:lower:]": ["\\p{Ll}", true],
+  "[:print:]": ["\\p{C}", true],
+  "[:punct:]": ["\\p{P}", true],
+  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+  "[:upper:]": ["\\p{Lu}", true],
+  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+  "[:xdigit:]": ["A-Fa-f0-9", false]
+};
+var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var rangesToString = (ranges) => ranges.join("");
+var parseClass = (glob, position) => {
+  const pos = position;
+  if (glob.charAt(pos) !== "[") {
+    throw new Error("not in a brace expression");
+  }
+  const ranges = [];
+  const negs = [];
+  let i = pos + 1;
+  let sawStart = false;
+  let uflag = false;
+  let escaping = false;
+  let negate = false;
+  let endPos = pos;
+  let rangeStart = "";
+  WHILE: while (i < glob.length) {
+    const c = glob.charAt(i);
+    if ((c === "!" || c === "^") && i === pos + 1) {
+      negate = true;
+      i++;
+      continue;
+    }
+    if (c === "]" && sawStart && !escaping) {
+      endPos = i + 1;
+      break;
+    }
+    sawStart = true;
+    if (c === "\\") {
+      if (!escaping) {
+        escaping = true;
+        i++;
+        continue;
+      }
+    }
+    if (c === "[" && !escaping) {
+      for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+        if (glob.startsWith(cls, i)) {
+          if (rangeStart) {
+            return ["$.", false, glob.length - pos, true];
+          }
+          i += cls.length;
+          if (neg)
+            negs.push(unip);
+          else
+            ranges.push(unip);
+          uflag = uflag || u;
+          continue WHILE;
+        }
+      }
+    }
+    escaping = false;
+    if (rangeStart) {
+      if (c > rangeStart) {
+        ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+      } else if (c === rangeStart) {
+        ranges.push(braceEscape(c));
+      }
+      rangeStart = "";
+      i++;
+      continue;
+    }
+    if (glob.startsWith("-]", i + 1)) {
+      ranges.push(braceEscape(c + "-"));
+      i += 2;
+      continue;
+    }
+    if (glob.startsWith("-", i + 1)) {
+      rangeStart = c;
+      i += 2;
+      continue;
+    }
+    ranges.push(braceEscape(c));
+    i++;
+  }
+  if (endPos < i) {
+    return ["", false, 0, false];
+  }
+  if (!ranges.length && !negs.length) {
+    return ["$.", false, glob.length - pos, true];
+  }
+  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
+    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+    return [regexpEscape(r), false, endPos - pos, false];
+  }
+  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
+  return [comb, uflag, endPos - pos, true];
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/unescape.js
+var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/ast.js
+var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+var isExtglobType = (c) => types.has(c);
+var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var startNoDot = "(?!\\.)";
+var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
+var justDots = /* @__PURE__ */ new Set(["..", "."]);
+var reSpecials = new Set("().*{}+?[]^$\\!");
+var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var qmark = "[^/]";
+var star = qmark + "*?";
+var starNoEmpty = qmark + "+?";
+var AST = class _AST {
+  type;
+  #root;
+  #hasMagic;
+  #uflag = false;
+  #parts = [];
+  #parent;
+  #parentIndex;
+  #negs;
+  #filledNegs = false;
+  #options;
+  #toString;
+  // set to true if it's an extglob with no children
+  // (which really means one child of '')
+  #emptyExt = false;
+  constructor(type, parent, options = {}) {
+    this.type = type;
+    if (type)
+      this.#hasMagic = true;
+    this.#parent = parent;
+    this.#root = this.#parent ? this.#parent.#root : this;
+    this.#options = this.#root === this ? options : this.#root.#options;
+    this.#negs = this.#root === this ? [] : this.#root.#negs;
+    if (type === "!" && !this.#root.#filledNegs)
+      this.#negs.push(this);
+    this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+  }
+  get hasMagic() {
+    if (this.#hasMagic !== void 0)
+      return this.#hasMagic;
+    for (const p of this.#parts) {
+      if (typeof p === "string")
+        continue;
+      if (p.type || p.hasMagic)
+        return this.#hasMagic = true;
+    }
+    return this.#hasMagic;
+  }
+  // reconstructs the pattern
+  toString() {
+    if (this.#toString !== void 0)
+      return this.#toString;
+    if (!this.type) {
+      return this.#toString = this.#parts.map((p) => String(p)).join("");
+    } else {
+      return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
+    }
+  }
+  #fillNegs() {
+    if (this !== this.#root)
+      throw new Error("should only call on root");
+    if (this.#filledNegs)
+      return this;
+    this.toString();
+    this.#filledNegs = true;
+    let n;
+    while (n = this.#negs.pop()) {
+      if (n.type !== "!")
+        continue;
+      let p = n;
+      let pp = p.#parent;
+      while (pp) {
+        for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
+          for (const part of n.#parts) {
+            if (typeof part === "string") {
+              throw new Error("string part in extglob AST??");
+            }
+            part.copyIn(pp.#parts[i]);
+          }
+        }
+        p = pp;
+        pp = p.#parent;
+      }
+    }
+    return this;
+  }
+  push(...parts) {
+    for (const p of parts) {
+      if (p === "")
+        continue;
+      if (typeof p !== "string" && !(p instanceof _AST && p.#parent === this)) {
+        throw new Error("invalid part: " + p);
+      }
+      this.#parts.push(p);
+    }
+  }
+  toJSON() {
+    const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
+    if (this.isStart() && !this.type)
+      ret.unshift([]);
+    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
+      ret.push({});
+    }
+    return ret;
+  }
+  isStart() {
+    if (this.#root === this)
+      return true;
+    if (!this.#parent?.isStart())
+      return false;
+    if (this.#parentIndex === 0)
+      return true;
+    const p = this.#parent;
+    for (let i = 0; i < this.#parentIndex; i++) {
+      const pp = p.#parts[i];
+      if (!(pp instanceof _AST && pp.type === "!")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isEnd() {
+    if (this.#root === this)
+      return true;
+    if (this.#parent?.type === "!")
+      return true;
+    if (!this.#parent?.isEnd())
+      return false;
+    if (!this.type)
+      return this.#parent?.isEnd();
+    const pl = this.#parent ? this.#parent.#parts.length : 0;
+    return this.#parentIndex === pl - 1;
+  }
+  copyIn(part) {
+    if (typeof part === "string")
+      this.push(part);
+    else
+      this.push(part.clone(this));
+  }
+  clone(parent) {
+    const c = new _AST(this.type, parent);
+    for (const p of this.#parts) {
+      c.copyIn(p);
+    }
+    return c;
+  }
+  static #parseAST(str, ast, pos, opt) {
+    let escaping = false;
+    let inBrace = false;
+    let braceStart = -1;
+    let braceNeg = false;
+    if (ast.type === null) {
+      let i2 = pos;
+      let acc2 = "";
+      while (i2 < str.length) {
+        const c = str.charAt(i2++);
+        if (escaping || c === "\\") {
+          escaping = !escaping;
+          acc2 += c;
+          continue;
+        }
+        if (inBrace) {
+          if (i2 === braceStart + 1) {
+            if (c === "^" || c === "!") {
+              braceNeg = true;
+            }
+          } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
+            inBrace = false;
+          }
+          acc2 += c;
+          continue;
+        } else if (c === "[") {
+          inBrace = true;
+          braceStart = i2;
+          braceNeg = false;
+          acc2 += c;
+          continue;
+        }
+        if (!opt.noext && isExtglobType(c) && str.charAt(i2) === "(") {
+          ast.push(acc2);
+          acc2 = "";
+          const ext2 = new _AST(c, ast);
+          i2 = _AST.#parseAST(str, ext2, i2, opt);
+          ast.push(ext2);
+          continue;
+        }
+        acc2 += c;
+      }
+      ast.push(acc2);
+      return i2;
+    }
+    let i = pos + 1;
+    let part = new _AST(null, ast);
+    const parts = [];
+    let acc = "";
+    while (i < str.length) {
+      const c = str.charAt(i++);
+      if (escaping || c === "\\") {
+        escaping = !escaping;
+        acc += c;
+        continue;
+      }
+      if (inBrace) {
+        if (i === braceStart + 1) {
+          if (c === "^" || c === "!") {
+            braceNeg = true;
+          }
+        } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
+          inBrace = false;
+        }
+        acc += c;
+        continue;
+      } else if (c === "[") {
+        inBrace = true;
+        braceStart = i;
+        braceNeg = false;
+        acc += c;
+        continue;
+      }
+      if (isExtglobType(c) && str.charAt(i) === "(") {
+        part.push(acc);
+        acc = "";
+        const ext2 = new _AST(c, part);
+        part.push(ext2);
+        i = _AST.#parseAST(str, ext2, i, opt);
+        continue;
+      }
+      if (c === "|") {
+        part.push(acc);
+        acc = "";
+        parts.push(part);
+        part = new _AST(null, ast);
+        continue;
+      }
+      if (c === ")") {
+        if (acc === "" && ast.#parts.length === 0) {
+          ast.#emptyExt = true;
+        }
+        part.push(acc);
+        acc = "";
+        ast.push(...parts, part);
+        return i;
+      }
+      acc += c;
+    }
+    ast.type = null;
+    ast.#hasMagic = void 0;
+    ast.#parts = [str.substring(pos - 1)];
+    return i;
+  }
+  static fromGlob(pattern, options = {}) {
+    const ast = new _AST(null, void 0, options);
+    _AST.#parseAST(pattern, ast, 0, options);
+    return ast;
+  }
+  // returns the regular expression if there's magic, or the unescaped
+  // string if not.
+  toMMPattern() {
+    if (this !== this.#root)
+      return this.#root.toMMPattern();
+    const glob = this.toString();
+    const [re, body, hasMagic, uflag] = this.toRegExpSource();
+    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
+    if (!anyMagic) {
+      return body;
+    }
+    const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+    return Object.assign(new RegExp(`^${re}$`, flags), {
+      _src: re,
+      _glob: glob
+    });
+  }
+  get options() {
+    return this.#options;
+  }
+  // returns the string match, the regexp source, whether there's magic
+  // in the regexp (so a regular expression is required) and whether or
+  // not the uflag is needed for the regular expression (for posix classes)
+  // TODO: instead of injecting the start/end at this point, just return
+  // the BODY of the regexp, along with the start/end portions suitable
+  // for binding the start/end in either a joined full-path makeRe context
+  // (where we bind to (^|/), or a standalone matchPart context (where
+  // we bind to ^, and not /).  Otherwise slashes get duped!
+  //
+  // In part-matching mode, the start is:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: ^(?!\.\.?$)
+  // - if dots allowed or not possible: ^
+  // - if dots possible and not allowed: ^(?!\.)
+  // end is:
+  // - if not isEnd(): nothing
+  // - else: $
+  //
+  // In full-path matching mode, we put the slash at the START of the
+  // pattern, so start is:
+  // - if first pattern: same as part-matching mode
+  // - if not isStart(): nothing
+  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+  // - if dots allowed or not possible: /
+  // - if dots possible and not allowed: /(?!\.)
+  // end is:
+  // - if last pattern, same as part-matching mode
+  // - else nothing
+  //
+  // Always put the (?:$|/) on negated tails, though, because that has to be
+  // there to bind the end of the negated pattern portion, and it's easier to
+  // just stick it in now rather than try to inject it later in the middle of
+  // the pattern.
+  //
+  // We can just always return the same end, and leave it up to the caller
+  // to know whether it's going to be used joined or in parts.
+  // And, if the start is adjusted slightly, can do the same there:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+  // - if dots allowed or not possible: (?:/|^)
+  // - if dots possible and not allowed: (?:/|^)(?!\.)
+  //
+  // But it's better to have a simpler binding without a conditional, for
+  // performance, so probably better to return both start options.
+  //
+  // Then the caller just ignores the end if it's not the first pattern,
+  // and the start always gets applied.
+  //
+  // But that's always going to be $ if it's the ending pattern, or nothing,
+  // so the caller can just attach $ at the end of the pattern when building.
+  //
+  // So the todo is:
+  // - better detect what kind of start is needed
+  // - return both flavors of starting pattern
+  // - attach $ at the end of the pattern when creating the actual RegExp
+  //
+  // Ah, but wait, no, that all only applies to the root when the first pattern
+  // is not an extglob. If the first pattern IS an extglob, then we need all
+  // that dot prevention biz to live in the extglob portions, because eg
+  // +(*|.x*) can match .xy but not .yx.
+  //
+  // So, return the two flavors if it's #root and the first child is not an
+  // AST, otherwise leave it to the child AST to handle it, and there,
+  // use the (?:^|/) style of start binding.
+  //
+  // Even simplified further:
+  // - Since the start for a join is eg /(?!\.) and the start for a part
+  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+  // or start or whatever) and prepend ^ or / at the Regexp construction.
+  toRegExpSource(allowDot) {
+    const dot = allowDot ?? !!this.#options.dot;
+    if (this.#root === this)
+      this.#fillNegs();
+    if (!this.type) {
+      const noEmpty = this.isStart() && this.isEnd();
+      const src = this.#parts.map((p) => {
+        const [re, _, hasMagic, uflag] = typeof p === "string" ? _AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        this.#hasMagic = this.#hasMagic || hasMagic;
+        this.#uflag = this.#uflag || uflag;
+        return re;
+      }).join("");
+      let start2 = "";
+      if (this.isStart()) {
+        if (typeof this.#parts[0] === "string") {
+          const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+          if (!dotTravAllowed) {
+            const aps = addPatternStart;
+            const needNoTrav = (
+              // dots are allowed, and the pattern starts with [ or .
+              dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
+              src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
+              src.startsWith("\\.\\.") && aps.has(src.charAt(4))
+            );
+            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+          }
+        }
+      }
+      let end = "";
+      if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
+        end = "(?:$|\\/)";
+      }
+      const final2 = start2 + src + end;
+      return [
+        final2,
+        unescape(src),
+        this.#hasMagic = !!this.#hasMagic,
+        this.#uflag
+      ];
+    }
+    const repeated = this.type === "*" || this.type === "+";
+    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let body = this.#partsToRegExp(dot);
+    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+      const s = this.toString();
+      this.#parts = [s];
+      this.type = null;
+      this.#hasMagic = void 0;
+      return [s, unescape(this.toString()), false, false];
+    }
+    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
+    if (bodyDotAllowed === body) {
+      bodyDotAllowed = "";
+    }
+    if (bodyDotAllowed) {
+      body = `(?:${body})(?:${bodyDotAllowed})*?`;
+    }
+    let final = "";
+    if (this.type === "!" && this.#emptyExt) {
+      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+    } else {
+      const close = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+      final = start + body + close;
+    }
+    return [
+      final,
+      unescape(body),
+      this.#hasMagic = !!this.#hasMagic,
+      this.#uflag
+    ];
+  }
+  #partsToRegExp(dot) {
+    return this.#parts.map((p) => {
+      if (typeof p === "string") {
+        throw new Error("string type in extglob ast??");
+      }
+      const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+      this.#uflag = this.#uflag || uflag;
+      return re;
+    }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+  }
+  static #parseGlob(glob, hasMagic, noEmpty = false) {
+    let escaping = false;
+    let re = "";
+    let uflag = false;
+    for (let i = 0; i < glob.length; i++) {
+      const c = glob.charAt(i);
+      if (escaping) {
+        escaping = false;
+        re += (reSpecials.has(c) ? "\\" : "") + c;
+        continue;
+      }
+      if (c === "\\") {
+        if (i === glob.length - 1) {
+          re += "\\\\";
+        } else {
+          escaping = true;
+        }
+        continue;
+      }
+      if (c === "[") {
+        const [src, needUflag, consumed, magic] = parseClass(glob, i);
+        if (consumed) {
+          re += src;
+          uflag = uflag || needUflag;
+          i += consumed - 1;
+          hasMagic = hasMagic || magic;
+          continue;
+        }
+      }
+      if (c === "*") {
+        if (noEmpty && glob === "*")
+          re += starNoEmpty;
+        else
+          re += star;
+        hasMagic = true;
+        continue;
+      }
+      if (c === "?") {
+        re += qmark;
+        hasMagic = true;
+        continue;
+      }
+      re += regExpEscape(c);
+    }
+    return [re, unescape(glob), !!hasMagic, uflag];
+  }
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/escape.js
+var escape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+
+// ../../node_modules/.pnpm/minimatch@10.0.3/node_modules/minimatch/dist/esm/index.js
+var minimatch = (p, pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (!options.nocomment && pattern.charAt(0) === "#") {
+    return false;
+  }
+  return new Minimatch(pattern, options).match(p);
+};
+var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
+var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
+var starDotExtTestNocase = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
+};
+var starDotExtTestNocaseDot = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => f.toLowerCase().endsWith(ext2);
+};
+var starDotStarRE = /^\*+\.\*+$/;
+var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
+var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
+var dotStarRE = /^\.\*+$/;
+var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
+var starRE = /^\*+$/;
+var starTest = (f) => f.length !== 0 && !f.startsWith(".");
+var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
+var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+var qmarksTestNocase = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTest = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTestNoExt = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && !f.startsWith(".");
+};
+var qmarksTestNoExtDot = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && f !== "." && f !== "..";
+};
+var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var path3 = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+};
+var sep = defaultPlatform === "win32" ? path3.win32.sep : path3.posix.sep;
+minimatch.sep = sep;
+var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+var qmark2 = "[^/]";
+var star2 = qmark2 + "*?";
+var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter;
+var ext = (a, b = {}) => Object.assign({}, a, b);
+var defaults = (def) => {
+  if (!def || typeof def !== "object" || !Object.keys(def).length) {
+    return minimatch;
+  }
+  const orig = minimatch;
+  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+  return Object.assign(m, {
+    Minimatch: class Minimatch extends orig.Minimatch {
+      constructor(pattern, options = {}) {
+        super(pattern, ext(def, options));
+      }
+      static defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
+      }
+    },
+    AST: class AST extends orig.AST {
+      /* c8 ignore start */
+      constructor(type, parent, options = {}) {
+        super(type, parent, ext(def, options));
+      }
+      /* c8 ignore stop */
+      static fromGlob(pattern, options = {}) {
+        return orig.AST.fromGlob(pattern, ext(def, options));
+      }
+    },
+    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+    defaults: (options) => orig.defaults(ext(def, options)),
+    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+    sep: orig.sep,
+    GLOBSTAR
+  });
+};
+minimatch.defaults = defaults;
+var braceExpand = (pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+    return [pattern];
+  }
+  return expand(pattern);
+};
+minimatch.braceExpand = braceExpand;
+var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe;
+var match = (list, pattern, options = {}) => {
+  const mm = new Minimatch(pattern, options);
+  list = list.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
+  }
+  return list;
+};
+minimatch.match = match;
+var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Minimatch = class {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  regexp;
+  constructor(pattern, options = {}) {
+    assertValidPattern(pattern);
+    options = options || {};
+    this.options = options;
+    this.pattern = pattern;
+    this.platform = options.platform || defaultPlatform;
+    this.isWindows = this.platform === "win32";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    if (this.windowsPathsNoEscape) {
+      this.pattern = this.pattern.replace(/\\/g, "/");
+    }
+    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+    this.regexp = null;
+    this.negate = false;
+    this.nonegate = !!options.nonegate;
+    this.comment = false;
+    this.empty = false;
+    this.partial = !!options.partial;
+    this.nocase = !!this.options.nocase;
+    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+    this.globSet = [];
+    this.globParts = [];
+    this.set = [];
+    this.make();
+  }
+  hasMagic() {
+    if (this.options.magicalBraces && this.set.length > 1) {
+      return true;
+    }
+    for (const pattern of this.set) {
+      for (const part of pattern) {
+        if (typeof part !== "string")
+          return true;
+      }
+    }
+    return false;
+  }
+  debug(..._) {
+  }
+  make() {
+    const pattern = this.pattern;
+    const options = this.options;
+    if (!options.nocomment && pattern.charAt(0) === "#") {
+      this.comment = true;
+      return;
+    }
+    if (!pattern) {
+      this.empty = true;
+      return;
+    }
+    this.parseNegate();
+    this.globSet = [...new Set(this.braceExpand())];
+    if (options.debug) {
+      this.debug = (...args) => console.error(...args);
+    }
+    this.debug(this.pattern, this.globSet);
+    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
+    this.globParts = this.preprocess(rawGlobParts);
+    this.debug(this.pattern, this.globParts);
+    let set = this.globParts.map((s, _, __) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+        const isDrive = /^[a-z]:/i.test(s[0]);
+        if (isUNC) {
+          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+        } else if (isDrive) {
+          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
+        }
+      }
+      return s.map((ss) => this.parse(ss));
+    });
+    this.debug(this.pattern, set);
+    this.set = set.filter((s) => s.indexOf(false) === -1);
+    if (this.isWindows) {
+      for (let i = 0; i < this.set.length; i++) {
+        const p = this.set[i];
+        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
+          p[2] = "?";
+        }
+      }
+    }
+    this.debug(this.pattern, this.set);
+  }
+  // various transforms to equivalent pattern sets that are
+  // faster to process in a filesystem walk.  The goal is to
+  // eliminate what we can, and push all ** patterns as far
+  // to the right as possible, even if it increases the number
+  // of patterns that we have to process.
+  preprocess(globParts) {
+    if (this.options.noglobstar) {
+      for (let i = 0; i < globParts.length; i++) {
+        for (let j = 0; j < globParts[i].length; j++) {
+          if (globParts[i][j] === "**") {
+            globParts[i][j] = "*";
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      globParts = this.firstPhasePreProcess(globParts);
+      globParts = this.secondPhasePreProcess(globParts);
+    } else if (optimizationLevel >= 1) {
+      globParts = this.levelOneOptimize(globParts);
+    } else {
+      globParts = this.adjascentGlobstarOptimize(globParts);
+    }
+    return globParts;
+  }
+  // just get rid of adjascent ** portions
+  adjascentGlobstarOptimize(globParts) {
+    return globParts.map((parts) => {
+      let gs = -1;
+      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+        let i = gs;
+        while (parts[i + 1] === "**") {
+          i++;
+        }
+        if (i !== gs) {
+          parts.splice(gs, i - gs);
+        }
+      }
+      return parts;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(globParts) {
+    return globParts.map((parts) => {
+      parts = parts.reduce((set, part) => {
+        const prev = set[set.length - 1];
+        if (part === "**" && prev === "**") {
+          return set;
+        }
+        if (part === "..") {
+          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+            set.pop();
+            return set;
+          }
+        }
+        set.push(part);
+        return set;
+      }, []);
+      return parts.length === 0 ? [""] : parts;
+    });
+  }
+  levelTwoFileOptimize(parts) {
+    if (!Array.isArray(parts)) {
+      parts = this.slashSplit(parts);
+    }
+    let didSomething = false;
+    do {
+      didSomething = false;
+      if (!this.preserveMultipleSlashes) {
+        for (let i = 1; i < parts.length - 1; i++) {
+          const p = parts[i];
+          if (i === 1 && p === "" && parts[0] === "")
+            continue;
+          if (p === "." || p === "") {
+            didSomething = true;
+            parts.splice(i, 1);
+            i--;
+          }
+        }
+        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+          didSomething = true;
+          parts.pop();
+        }
+      }
+      let dd = 0;
+      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+        const p = parts[dd - 1];
+        if (p && p !== "." && p !== ".." && p !== "**") {
+          didSomething = true;
+          parts.splice(dd - 1, 2);
+          dd -= 2;
+        }
+      }
+    } while (didSomething);
+    return parts.length === 0 ? [""] : parts;
+  }
+  // First phase: single-pattern processing
+  // <pre> is 1 or more portions
+  // <rest> is 1 or more portions
+  // <p> is any portion other than ., .., '', or **
+  // <e> is . or ''
+  //
+  // **/.. is *brutal* for filesystem walking performance, because
+  // it effectively resets the recursive walk each time it occurs,
+  // and ** cannot be reduced out by a .. pattern part like a regexp
+  // or most strings (other than .., ., and '') can be.
+  //
+  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+  // <pre>/<e>/<rest> -> <pre>/<rest>
+  // <pre>/<p>/../<rest> -> <pre>/<rest>
+  // **/**/<rest> -> **/<rest>
+  //
+  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+  // this WOULD be allowed if ** did follow symlinks, or * didn't
+  firstPhasePreProcess(globParts) {
+    let didSomething = false;
+    do {
+      didSomething = false;
+      for (let parts of globParts) {
+        let gs = -1;
+        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+          let gss = gs;
+          while (parts[gss + 1] === "**") {
+            gss++;
+          }
+          if (gss > gs) {
+            parts.splice(gs + 1, gss - gs);
+          }
+          let next = parts[gs + 1];
+          const p = parts[gs + 2];
+          const p2 = parts[gs + 3];
+          if (next !== "..")
+            continue;
+          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
+            continue;
+          }
+          didSomething = true;
+          parts.splice(gs, 1);
+          const other = parts.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
+          gs--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let i = 1; i < parts.length - 1; i++) {
+            const p = parts[i];
+            if (i === 1 && p === "" && parts[0] === "")
+              continue;
+            if (p === "." || p === "") {
+              didSomething = true;
+              parts.splice(i, 1);
+              i--;
+            }
+          }
+          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+            didSomething = true;
+            parts.pop();
+          }
+        }
+        let dd = 0;
+        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+          const p = parts[dd - 1];
+          if (p && p !== "." && p !== ".." && p !== "**") {
+            didSomething = true;
+            const needDot = dd === 1 && parts[dd + 1] === "**";
+            const splin = needDot ? ["."] : [];
+            parts.splice(dd - 1, 2, ...splin);
+            if (parts.length === 0)
+              parts.push("");
+            dd -= 2;
+          }
+        }
+      }
+    } while (didSomething);
+    return globParts;
+  }
+  // second phase: multi-pattern dedupes
+  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+  //
+  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+  // ^-- not valid because ** doens't follow symlinks
+  secondPhasePreProcess(globParts) {
+    for (let i = 0; i < globParts.length - 1; i++) {
+      for (let j = i + 1; j < globParts.length; j++) {
+        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+        if (matched) {
+          globParts[i] = [];
+          globParts[j] = matched;
+          break;
+        }
+      }
+    }
+    return globParts.filter((gs) => gs.length);
+  }
+  partsMatch(a, b, emptyGSMatch = false) {
+    let ai = 0;
+    let bi = 0;
+    let result = [];
+    let which = "";
+    while (ai < a.length && bi < b.length) {
+      if (a[ai] === b[bi]) {
+        result.push(which === "b" ? b[bi] : a[ai]);
+        ai++;
+        bi++;
+      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
+        result.push(a[ai]);
+        ai++;
+      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+        result.push(b[bi]);
+        bi++;
+      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+        if (which === "b")
+          return false;
+        which = "a";
+        result.push(a[ai]);
+        ai++;
+        bi++;
+      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+        if (which === "a")
+          return false;
+        which = "b";
+        result.push(b[bi]);
+        ai++;
+        bi++;
+      } else {
+        return false;
+      }
+    }
+    return a.length === b.length && result;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const pattern = this.pattern;
+    let negate = false;
+    let negateOffset = 0;
+    for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+      negate = !negate;
+      negateOffset++;
+    }
+    if (negateOffset)
+      this.pattern = pattern.slice(negateOffset);
+    this.negate = negate;
+  }
+  // set partial to true to test if, for example,
+  // "/a/b" matches the start of "/*/b/*/d"
+  // Partial means, if you run out of file before you run
+  // out of pattern, then that's fine, as long as all
+  // the parts match.
+  matchOne(file, pattern, partial = false) {
+    const options = this.options;
+    if (this.isWindows) {
+      const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
+      const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
+      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
+      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
+      const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
+      const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
+      if (typeof fdi === "number" && typeof pdi === "number") {
+        const [fd, pd] = [file[fdi], pattern[pdi]];
+        if (fd.toLowerCase() === pd.toLowerCase()) {
+          pattern[pdi] = fd;
+          if (pdi > fdi) {
+            pattern = pattern.slice(pdi);
+          } else if (fdi > pdi) {
+            file = file.slice(fdi);
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      file = this.levelTwoFileOptimize(file);
+    }
+    this.debug("matchOne", this, { file, pattern });
+    this.debug("matchOne", file.length, pattern.length);
+    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      var p = pattern[pi];
+      var f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false) {
+        return false;
+      }
+      if (p === GLOBSTAR) {
+        this.debug("GLOBSTAR", [pattern, p, f]);
+        var fr = fi;
+        var pr = pi + 1;
+        if (pr === pl) {
+          this.debug("** at the end");
+          for (; fi < fl; fi++) {
+            if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+              return false;
+          }
+          return true;
+        }
+        while (fr < fl) {
+          var swallowee = file[fr];
+          this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
+          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+            this.debug("globstar found match!", fr, fl, swallowee);
+            return true;
+          } else {
+            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+              this.debug("dot detected!", file, fr, pattern, pr);
+              break;
+            }
+            this.debug("globstar swallow a segment, and continue");
+            fr++;
+          }
+        }
+        if (partial) {
+          this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
+          if (fr === fl) {
+            return true;
+          }
+        }
+        return false;
+      }
+      let hit;
+      if (typeof p === "string") {
+        hit = f === p;
+        this.debug("string match", p, f, hit);
+      } else {
+        hit = p.test(f);
+        this.debug("pattern match", p, f, hit);
+      }
+      if (!hit)
+        return false;
+    }
+    if (fi === fl && pi === pl) {
+      return true;
+    } else if (fi === fl) {
+      return partial;
+    } else if (pi === pl) {
+      return fi === fl - 1 && file[fi] === "";
+    } else {
+      throw new Error("wtf?");
+    }
+  }
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
+  }
+  parse(pattern) {
+    assertValidPattern(pattern);
+    const options = this.options;
+    if (pattern === "**")
+      return GLOBSTAR;
+    if (pattern === "")
+      return "";
+    let m;
+    let fastTest = null;
+    if (m = pattern.match(starRE)) {
+      fastTest = options.dot ? starTestDot : starTest;
+    } else if (m = pattern.match(starDotExtRE)) {
+      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+    } else if (m = pattern.match(qmarksRE)) {
+      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
+    } else if (m = pattern.match(starDotStarRE)) {
+      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+    } else if (m = pattern.match(dotStarRE)) {
+      fastTest = dotStarTest;
+    }
+    const re = AST.fromGlob(pattern, this.options).toMMPattern();
+    if (fastTest && typeof re === "object") {
+      Reflect.defineProperty(re, "test", { value: fastTest });
+    }
+    return re;
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === false)
+      return this.regexp;
+    const set = this.set;
+    if (!set.length) {
+      this.regexp = false;
+      return this.regexp;
+    }
+    const options = this.options;
+    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
+    const flags = new Set(options.nocase ? ["i"] : []);
+    let re = set.map((pattern) => {
+      const pp = pattern.map((p) => {
+        if (p instanceof RegExp) {
+          for (const f of p.flags.split(""))
+            flags.add(f);
+        }
+        return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
+      });
+      pp.forEach((p, i) => {
+        const next = pp[i + 1];
+        const prev = pp[i - 1];
+        if (p !== GLOBSTAR || prev === GLOBSTAR) {
+          return;
+        }
+        if (prev === void 0) {
+          if (next !== void 0 && next !== GLOBSTAR) {
+            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+          } else {
+            pp[i] = twoStar;
+          }
+        } else if (next === void 0) {
+          pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
+        } else if (next !== GLOBSTAR) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+          pp[i + 1] = GLOBSTAR;
+        }
+      });
+      return pp.filter((p) => p !== GLOBSTAR).join("/");
+    }).join("|");
+    const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open + re + close + "$";
+    if (this.negate)
+      re = "^(?!" + re + ").+$";
+    try {
+      this.regexp = new RegExp(re, [...flags].join(""));
+    } catch (ex) {
+      this.regexp = false;
+    }
+    return this.regexp;
+  }
+  slashSplit(p) {
+    if (this.preserveMultipleSlashes) {
+      return p.split("/");
+    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+      return ["", ...p.split(/\/+/)];
+    } else {
+      return p.split(/\/+/);
+    }
+  }
+  match(f, partial = this.partial) {
+    this.debug("match", f, this.pattern);
+    if (this.comment) {
+      return false;
+    }
+    if (this.empty) {
+      return f === "";
+    }
+    if (f === "/" && partial) {
+      return true;
+    }
+    const options = this.options;
+    if (this.isWindows) {
+      f = f.split("\\").join("/");
+    }
+    const ff = this.slashSplit(f);
+    this.debug(this.pattern, "split", ff);
+    const set = this.set;
+    this.debug(this.pattern, "set", set);
+    let filename = ff[ff.length - 1];
+    if (!filename) {
+      for (let i = ff.length - 2; !filename && i >= 0; i--) {
+        filename = ff[i];
+      }
+    }
+    for (let i = 0; i < set.length; i++) {
+      const pattern = set[i];
+      let file = ff;
+      if (options.matchBase && pattern.length === 1) {
+        file = [filename];
+      }
+      const hit = this.matchOne(file, pattern, partial);
+      if (hit) {
+        if (options.flipNegate) {
+          return true;
+        }
+        return !this.negate;
+      }
+    }
+    if (options.flipNegate) {
+      return false;
+    }
+    return this.negate;
+  }
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
+  }
+};
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape;
+minimatch.unescape = unescape;
+
+// ../agent/dist/chunk-64ESYBKE.js
+import fs4 from "fs/promises";
+var sep2 = "/";
+function join(...parts) {
+  const joined = parts.filter(Boolean).join("/");
+  return normalize(joined);
+}
+function dirname(p) {
+  if (!p) return ".";
+  const i = p.lastIndexOf("/");
+  if (i < 0) return ".";
+  if (i === 0) return "/";
+  return p.slice(0, i);
+}
+function basename(p, ext2) {
+  if (p.endsWith("/")) p = p.slice(0, -1);
+  const i = p.lastIndexOf("/");
+  const base = i < 0 ? p : p.slice(i + 1);
+  if (ext2 && base.endsWith(ext2)) return base.slice(0, -ext2.length);
+  return base;
+}
+function extname(p) {
+  const base = basename(p);
+  const i = base.lastIndexOf(".");
+  if (i <= 0) return "";
+  return base.slice(i);
+}
+function isAbsolute(p) {
+  return p.startsWith("/");
+}
+function normalize(p) {
+  if (!p) return ".";
+  const isAbs = p.startsWith("/");
+  const segments = p.split("/");
   const out = [];
   for (const s of segments) {
     if (s === "" || s === ".") continue;
@@ -1383,282 +3483,6 @@ function resolve(...parts) {
   }
   return normalize(resolved);
 }
-var Filesystem;
-((Filesystem2) => {
-  async function exists(context, p) {
-    return context.fs.exists(p);
-  }
-  Filesystem2.exists = exists;
-  async function isDir(context, p) {
-    const s = await context.fs.stat(p);
-    return s?.isDirectory ?? false;
-  }
-  Filesystem2.isDir = isDir;
-  async function stat(context, p) {
-    return context.fs.stat(p);
-  }
-  Filesystem2.stat = stat;
-  async function size(context, p) {
-    const s = await context.fs.stat(p);
-    return s?.size ?? 0;
-  }
-  Filesystem2.size = size;
-  async function readText(context, p) {
-    return context.fs.readText(p);
-  }
-  Filesystem2.readText = readText;
-  async function readJson(context, p) {
-    return JSON.parse(await readText(context, p));
-  }
-  Filesystem2.readJson = readJson;
-  async function readBytes(context, p) {
-    return context.fs.readBytes(p);
-  }
-  Filesystem2.readBytes = readBytes;
-  async function readArrayBuffer(context, p) {
-    const bytes = await readBytes(context, p);
-    return bytes.buffer;
-  }
-  Filesystem2.readArrayBuffer = readArrayBuffer;
-  async function write(context, p, content) {
-    return context.fs.write(p, content);
-  }
-  Filesystem2.write = write;
-  async function writeJson(context, p, data) {
-    return write(context, p, JSON.stringify(data, null, 2));
-  }
-  Filesystem2.writeJson = writeJson;
-  async function mkdir(context, p) {
-    return context.fs.mkdir(p);
-  }
-  Filesystem2.mkdir = mkdir;
-  async function remove(context, p) {
-    return context.fs.remove(p);
-  }
-  Filesystem2.remove = remove;
-  const MIME_MAP = {
-    ".html": "text/html",
-    ".css": "text/css",
-    ".js": "application/javascript",
-    ".mjs": "application/javascript",
-    ".json": "application/json",
-    ".ts": "text/typescript",
-    ".tsx": "text/typescript",
-    ".jsx": "text/javascript",
-    ".md": "text/markdown",
-    ".txt": "text/plain",
-    ".csv": "text/csv",
-    ".xml": "application/xml",
-    ".yaml": "text/yaml",
-    ".yml": "text/yaml",
-    ".toml": "text/plain",
-    ".svg": "image/svg+xml",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".ico": "image/x-icon",
-    ".pdf": "application/pdf",
-    ".zip": "application/zip",
-    ".gz": "application/gzip",
-    ".wasm": "application/wasm",
-    ".mp4": "video/mp4",
-    ".webm": "video/webm",
-    ".mp3": "audio/mpeg",
-    ".sh": "text/x-shellscript",
-    ".py": "text/x-python",
-    ".rb": "text/x-ruby",
-    ".go": "text/x-go",
-    ".rs": "text/x-rust",
-    ".java": "text/x-java",
-    ".c": "text/x-c",
-    ".cpp": "text/x-c++",
-    ".h": "text/x-c",
-    ".hpp": "text/x-c++"
-  };
-  function mimeType(p) {
-    return MIME_MAP[extname(p).toLowerCase()] || "application/octet-stream";
-  }
-  Filesystem2.mimeType = mimeType;
-  function resolve2(p) {
-    return resolve(p);
-  }
-  Filesystem2.resolve = resolve2;
-  function overlaps(a, b) {
-    const relA = relative(a, b);
-    const relB = relative(b, a);
-    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..");
-  }
-  Filesystem2.overlaps = overlaps;
-  function contains(parent, child) {
-    return !relative(parent, child).startsWith("..");
-  }
-  Filesystem2.contains = contains;
-  async function findUp(context, target, start, stop) {
-    let current = start;
-    const result = [];
-    while (true) {
-      const search = join(current, target);
-      if (await exists(context, search)) result.push(search);
-      if (stop === current) break;
-      const parent = dirname(current);
-      if (parent === current) break;
-      current = parent;
-    }
-    return result;
-  }
-  Filesystem2.findUp = findUp;
-  async function* up(context, options) {
-    const { targets, start, stop } = options;
-    let current = start;
-    while (true) {
-      for (const target of targets) {
-        const search = join(current, target);
-        if (await exists(context, search)) yield search;
-      }
-      if (stop === current) break;
-      const parent = dirname(current);
-      if (parent === current) break;
-      current = parent;
-    }
-  }
-  Filesystem2.up = up;
-  async function globUp(context, pattern, start, stop) {
-    let current = start;
-    const result = [];
-    while (true) {
-      try {
-        const { Glob: Glob2 } = await import("./glob-RMMK6FVW-WWQVXLWS.js");
-        const matches = await Glob2.scan(context, pattern, {
-          cwd: current,
-          absolute: true,
-          include: "file",
-          dot: true
-        });
-        result.push(...matches);
-      } catch {
-      }
-      if (stop === current) break;
-      const parent = dirname(current);
-      if (parent === current) break;
-      current = parent;
-    }
-    return result;
-  }
-  Filesystem2.globUp = globUp;
-})(Filesystem || (Filesystem = {}));
-var Log;
-((Log2) => {
-  Log2.Level = zod_default.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" });
-  const levelPriority = {
-    DEBUG: 0,
-    INFO: 1,
-    WARN: 2,
-    ERROR: 3
-  };
-  let level = "INFO";
-  function shouldLog(input) {
-    return levelPriority[input] >= levelPriority[level];
-  }
-  const loggers = /* @__PURE__ */ new Map();
-  Log2.Default = create({ service: "default" });
-  let write = (msg) => {
-    console.error(msg);
-    return msg.length;
-  };
-  async function init(options) {
-    if (options.level) level = options.level;
-    if (options.writer) {
-      write = (msg) => {
-        options.writer(msg);
-        return msg.length;
-      };
-    }
-  }
-  Log2.init = init;
-  function formatError(error, depth = 0) {
-    const result = error.message;
-    return error.cause instanceof Error && depth < 10 ? result + " Caused by: " + formatError(error.cause, depth + 1) : result;
-  }
-  let last = Date.now();
-  function create(tags) {
-    tags = tags || {};
-    const service = tags["service"];
-    if (service && typeof service === "string") {
-      const cached = loggers.get(service);
-      if (cached) {
-        return cached;
-      }
-    }
-    function build(message, extra) {
-      const prefix = Object.entries({
-        ...tags,
-        ...extra
-      }).filter(([_, value]) => value !== void 0 && value !== null).map(([key, value]) => {
-        const prefix2 = `${key}=`;
-        if (value instanceof Error) return prefix2 + formatError(value);
-        if (typeof value === "object") return prefix2 + JSON.stringify(value);
-        return prefix2 + value;
-      }).join(" ");
-      const next = /* @__PURE__ */ new Date();
-      const diff = next.getTime() - last;
-      last = next.getTime();
-      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n";
-    }
-    const result = {
-      debug(message, extra) {
-        if (shouldLog("DEBUG")) {
-          write("DEBUG " + build(message, extra));
-        }
-      },
-      info(message, extra) {
-        if (shouldLog("INFO")) {
-          write("INFO  " + build(message, extra));
-        }
-      },
-      error(message, extra) {
-        if (shouldLog("ERROR")) {
-          write("ERROR " + build(message, extra));
-        }
-      },
-      warn(message, extra) {
-        if (shouldLog("WARN")) {
-          write("WARN  " + build(message, extra));
-        }
-      },
-      tag(key, value) {
-        if (tags) tags[key] = value;
-        return result;
-      },
-      clone() {
-        return Log2.create({ ...tags });
-      },
-      time(message, extra) {
-        const now = Date.now();
-        result.info(message, { status: "started", ...extra });
-        function stop() {
-          result.info(message, {
-            status: "completed",
-            duration: Date.now() - now,
-            ...extra
-          });
-        }
-        return {
-          stop,
-          [Symbol.dispose]() {
-            stop();
-          }
-        };
-      }
-    };
-    if (service && typeof service === "string") {
-      loggers.set(service, result);
-    }
-    return result;
-  }
-  Log2.create = create;
-})(Log || (Log = {}));
 var _env = {};
 function truthy(key) {
   const value = _env[key]?.toLowerCase();
@@ -1783,6 +3607,23 @@ Object.defineProperty(Flag, "OPENCODE_CLIENT", {
   enumerable: true,
   configurable: false
 });
+var Glob;
+((Glob2) => {
+  async function scan(context, pattern, options = {}) {
+    return context.fs.glob(pattern, {
+      cwd: options.cwd,
+      absolute: options.absolute,
+      dot: options.dot,
+      follow: options.symlink ?? false,
+      nodir: options.include !== "all"
+    });
+  }
+  Glob2.scan = scan;
+  function match2(pattern, filepath) {
+    return minimatch(filepath, pattern, { dot: true });
+  }
+  Glob2.match = match2;
+})(Glob || (Glob = {}));
 var projectIdSchema = Schema_exports.String.pipe(Schema_exports.brand("ProjectID"));
 var ProjectID = projectIdSchema.pipe(
   withStatics((schema) => ({
@@ -1894,7 +3735,7 @@ var FileIgnore;
     "**/.nyc_output/**"
   ];
   FileIgnore2.PATTERNS = [...FILES, ...FOLDERS];
-  function match(filepath, opts) {
+  function match2(filepath, opts) {
     for (const pattern of opts?.whitelist || []) {
       if (Glob.match(pattern, filepath)) return false;
     }
@@ -1908,14 +3749,12 @@ var FileIgnore;
     }
     return false;
   }
-  FileIgnore2.match = match;
+  FileIgnore2.match = match2;
 })(FileIgnore || (FileIgnore = {}));
 var FileTimeService = class {
-  log = Log.create({ service: "file.time" });
   readTimes = {};
   locks = /* @__PURE__ */ new Map();
   read(sessionID, file) {
-    this.log.info("read", { sessionID, file });
     this.readTimes[sessionID] = this.readTimes[sessionID] || {};
     this.readTimes[sessionID][file] = /* @__PURE__ */ new Date();
   }
@@ -1926,7 +3765,7 @@ var FileTimeService = class {
     if (Flag.OPENCODE_DISABLE_FILETIME_CHECK === true) return;
     const time = this.get(sessionID, filepath);
     if (!time) throw new Error(`You must read file ${filepath} before overwriting it. Use the Read tool first`);
-    const s = await Filesystem.stat(context, filepath);
+    const s = await context.fs.stat(filepath);
     const mtimeMs = s?.mtimeMs;
     if (mtimeMs && mtimeMs > time.getTime() + 50) {
       const mtime = new Date(mtimeMs);
@@ -1987,7 +3826,6 @@ var FileTime;
 })(FileTime || (FileTime = {}));
 var Project;
 ((Project2) => {
-  const log = Log.create({ service: "project" });
   Project2.Info = zod_default.object({
     id: ProjectID.zod,
     worktree: zod_default.string(),
@@ -2046,7 +3884,7 @@ var Project;
     const data = fromRow(row);
     const valid = [];
     for (const dir of data.sandboxes) {
-      const s = await Filesystem.stat(context, dir);
+      const s = await context.fs.stat(dir);
       if (s?.isDirectory) valid.push(dir);
     }
     return valid;
@@ -2172,7 +4010,7 @@ var Lock;
     }
     return locks.get(key);
   }
-  function process(key) {
+  function process2(key) {
     const lock = locks.get(key);
     if (!lock || lock.writer || lock.readers > 0) return;
     if (lock.waitingWriters.length > 0) {
@@ -2196,7 +4034,7 @@ var Lock;
         resolve2({
           [Symbol.dispose]: () => {
             lock.readers--;
-            process(key);
+            process2(key);
           }
         });
       } else {
@@ -2205,7 +4043,7 @@ var Lock;
           resolve2({
             [Symbol.dispose]: () => {
               lock.readers--;
-              process(key);
+              process2(key);
             }
           });
         });
@@ -2221,7 +4059,7 @@ var Lock;
         resolve2({
           [Symbol.dispose]: () => {
             lock.writer = false;
-            process(key);
+            process2(key);
           }
         });
       } else {
@@ -2230,7 +4068,7 @@ var Lock;
           resolve2({
             [Symbol.dispose]: () => {
               lock.writer = false;
-              process(key);
+              process2(key);
             }
           });
         });
@@ -2400,132 +4238,11 @@ CREATE TABLE IF NOT EXISTS "control_account" (
   }
   Database2.getMigrations = getMigrations;
 })(Database || (Database = {}));
-var SqliteNoSqlDb = class {
-  constructor(raw) {
-    this.raw = raw;
-  }
-  insert(table, row) {
-    const cols = Object.keys(row);
-    const placeholders = cols.map(() => "?").join(", ");
-    const sql2 = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
-    this.raw.run(sql2, cols.map((c) => serialize(row[c])));
-  }
-  upsert(table, row, conflictKeys, updateFields) {
-    const cols = Object.keys(row);
-    const placeholders = cols.map(() => "?").join(", ");
-    const conflict = conflictKeys.map((k) => `"${k}"`).join(", ");
-    const updates = Object.keys(updateFields).map((k) => `"${k}" = ?`).join(", ");
-    const sql2 = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders}) ON CONFLICT (${conflict}) DO UPDATE SET ${updates}`;
-    const params = [
-      ...cols.map((c) => serialize(row[c])),
-      ...Object.keys(updateFields).map((k) => serialize(updateFields[k]))
-    ];
-    this.raw.run(sql2, params);
-  }
-  findOne(table, filter, options) {
-    const fields = options?.select?.map((f) => `"${f}"`).join(", ") ?? "*";
-    const { clause, params } = filter ? buildWhere(filter) : { clause: "", params: [] };
-    const where = clause ? ` WHERE ${clause}` : "";
-    const sql2 = `SELECT ${fields} FROM "${table}"${where} LIMIT 1`;
-    const row = this.raw.get(sql2, params);
-    return row ? deserializeRow(row) : void 0;
-  }
-  findMany(table, options) {
-    const fields = options?.select?.map((f) => `"${f}"`).join(", ") ?? "*";
-    const { clause, params } = options?.filter ? buildWhere(options.filter) : { clause: "", params: [] };
-    const where = clause ? ` WHERE ${clause}` : "";
-    let orderClause = "";
-    if (options?.orderBy?.length) {
-      const parts = options.orderBy.map(
-        (o) => `"${o.field}" ${o.direction === "desc" ? "DESC" : "ASC"}`
-      );
-      orderClause = ` ORDER BY ${parts.join(", ")}`;
-    }
-    const limitClause = options?.limit != null ? ` LIMIT ${options.limit}` : "";
-    const sql2 = `SELECT ${fields} FROM "${table}"${where}${orderClause}${limitClause}`;
-    return this.raw.all(sql2, params).map(deserializeRow);
-  }
-  update(table, filter, set) {
-    const setCols = Object.keys(set);
-    const setClause = setCols.map((k) => `"${k}" = ?`).join(", ");
-    const { clause, params } = buildWhere(filter);
-    const sql2 = `UPDATE "${table}" SET ${setClause} WHERE ${clause} RETURNING *`;
-    const setParams = setCols.map((k) => serialize(set[k]));
-    const row = this.raw.get(sql2, [...setParams, ...params]);
-    return row ? deserializeRow(row) : void 0;
-  }
-  remove(table, filter) {
-    const { clause, params } = buildWhere(filter);
-    this.raw.run(`DELETE FROM "${table}" WHERE ${clause}`, params);
-  }
-  transaction(fn) {
-    this.raw.transaction(() => {
-      fn(this);
-    });
-  }
-};
-function buildWhere(filter) {
-  switch (filter.op) {
-    case "eq":
-      return { clause: `"${filter.field}" = ?`, params: [serialize(filter.value)] };
-    case "ne":
-      return { clause: `"${filter.field}" != ?`, params: [serialize(filter.value)] };
-    case "gt":
-      return { clause: `"${filter.field}" > ?`, params: [serialize(filter.value)] };
-    case "gte":
-      return { clause: `"${filter.field}" >= ?`, params: [serialize(filter.value)] };
-    case "lt":
-      return { clause: `"${filter.field}" < ?`, params: [serialize(filter.value)] };
-    case "like":
-      return { clause: `"${filter.field}" LIKE ?`, params: [filter.value] };
-    case "isNull":
-      return { clause: `"${filter.field}" IS NULL`, params: [] };
-    case "in": {
-      const placeholders = filter.values.map(() => "?").join(", ");
-      return { clause: `"${filter.field}" IN (${placeholders})`, params: filter.values.map(serialize) };
-    }
-    case "and": {
-      const parts = filter.conditions.map(buildWhere);
-      return {
-        clause: parts.map((p) => `(${p.clause})`).join(" AND "),
-        params: parts.flatMap((p) => p.params)
-      };
-    }
-    case "or": {
-      const parts = filter.conditions.map(buildWhere);
-      return {
-        clause: parts.map((p) => `(${p.clause})`).join(" OR "),
-        params: parts.flatMap((p) => p.params)
-      };
-    }
-  }
-}
-function serialize(value) {
-  if (value === void 0) return null;
-  if (value === null) return null;
-  if (typeof value === "object" && !(value instanceof Buffer) && !(value instanceof Uint8Array)) {
-    return JSON.stringify(value);
-  }
-  return value;
-}
-function deserializeRow(row) {
-  const result = {};
-  for (const [key, value] of Object.entries(row)) {
-    if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
-      try {
-        result[key] = JSON.parse(value);
-      } catch {
-        result[key] = value;
-      }
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
 var Storage;
 ((Storage2) => {
-  const log = Log.create({ service: "storage" });
+  function getLog(context) {
+    return context.log.create({ service: "storage" });
+  }
   Storage2.NotFoundError = NamedError.create(
     "NotFoundError",
     zod_default.object({
@@ -2535,36 +4252,36 @@ var Storage;
   const MIGRATIONS = [
     async (context, dir) => {
       const project = resolve(dir, "../project");
-      if (!await Filesystem.isDir(context, project)) return;
-      const projectDirs = await Glob.scan(context, "*", {
+      if (!await context.fs.isDir(project)) return;
+      const projectDirs = await context.fs.glob("*", {
         cwd: project,
-        include: "all"
+        nodir: false
       });
       for (const projectDir of projectDirs) {
         const fullPath = join(project, projectDir);
-        if (!await Filesystem.isDir(context, fullPath)) continue;
-        log.info(`migrating project ${projectDir}`);
+        if (!await context.fs.isDir(fullPath)) continue;
+        getLog(context).info(`migrating project ${projectDir}`);
         let projectID = projectDir;
         const fullProjectDir = join(project, projectDir);
         let worktree = "/";
         if (projectID !== "global") {
-          for (const msgFile of await Glob.scan(context, "storage/session/message/*/*.json", {
+          for (const msgFile of await context.fs.glob("storage/session/message/*/*.json", {
             cwd: join(project, projectDir),
             absolute: true
           })) {
-            const json = await Filesystem.readJson(context, msgFile);
+            const json = await context.fs.readJson(msgFile);
             worktree = json.path?.root;
             if (worktree) break;
           }
           if (!worktree) continue;
-          if (!await Filesystem.isDir(context, worktree)) continue;
+          if (!await context.fs.isDir(worktree)) continue;
           const result = await context.git.run(["rev-list", "--max-parents=0", "--all"], {
             cwd: worktree
           });
           const [id] = result.text().split("\n").filter(Boolean).map((x) => x.trim()).toSorted();
           if (!id) continue;
           projectID = id;
-          await Filesystem.writeJson(context, join(dir, "project", projectID + ".json"), {
+          await context.fs.writeJson(join(dir, "project", projectID + ".json"), {
             id,
             vcs: "git",
             worktree,
@@ -2573,42 +4290,42 @@ var Storage;
               initialized: Date.now()
             }
           });
-          log.info(`migrating sessions for project ${projectID}`);
-          for (const sessionFile of await Glob.scan(context, "storage/session/info/*.json", {
+          getLog(context).info(`migrating sessions for project ${projectID}`);
+          for (const sessionFile of await context.fs.glob("storage/session/info/*.json", {
             cwd: fullProjectDir,
             absolute: true
           })) {
             const dest = join(dir, "session", projectID, basename(sessionFile));
-            log.info("copying", {
+            getLog(context).info("copying", {
               sessionFile,
               dest
             });
-            const session = await Filesystem.readJson(context, sessionFile);
-            await Filesystem.writeJson(context, dest, session);
-            log.info(`migrating messages for session ${session.id}`);
-            for (const msgFile of await Glob.scan(context, `storage/session/message/${session.id}/*.json`, {
+            const session = await context.fs.readJson(sessionFile);
+            await context.fs.writeJson(dest, session);
+            getLog(context).info(`migrating messages for session ${session.id}`);
+            for (const msgFile of await context.fs.glob(`storage/session/message/${session.id}/*.json`, {
               cwd: fullProjectDir,
               absolute: true
             })) {
               const dest2 = join(dir, "message", session.id, basename(msgFile));
-              log.info("copying", {
+              getLog(context).info("copying", {
                 msgFile,
                 dest: dest2
               });
-              const message = await Filesystem.readJson(context, msgFile);
-              await Filesystem.writeJson(context, dest2, message);
-              log.info(`migrating parts for message ${message.id}`);
-              for (const partFile of await Glob.scan(context, `storage/session/part/${session.id}/${message.id}/*.json`, {
+              const message = await context.fs.readJson(msgFile);
+              await context.fs.writeJson(dest2, message);
+              getLog(context).info(`migrating parts for message ${message.id}`);
+              for (const partFile of await context.fs.glob(`storage/session/part/${session.id}/${message.id}/*.json`, {
                 cwd: fullProjectDir,
                 absolute: true
               })) {
                 const dest3 = join(dir, "part", message.id, basename(partFile));
-                const part = await Filesystem.readJson(context, partFile);
-                log.info("copying", {
+                const part = await context.fs.readJson(partFile);
+                getLog(context).info("copying", {
                   partFile,
                   dest: dest3
                 });
-                await Filesystem.writeJson(context, dest3, part);
+                await context.fs.writeJson(dest3, part);
               }
             }
           }
@@ -2616,16 +4333,16 @@ var Storage;
       }
     },
     async (context, dir) => {
-      for (const item of await Glob.scan(context, "session/*/*.json", {
+      for (const item of await context.fs.glob("session/*/*.json", {
         cwd: dir,
         absolute: true
       })) {
-        const session = await Filesystem.readJson(context, item);
+        const session = await context.fs.readJson(item);
         if (!session.projectID) continue;
         if (!session.summary?.diffs) continue;
         const { diffs } = session.summary;
-        await Filesystem.write(context, join(dir, "session_diff", session.id + ".json"), JSON.stringify(diffs));
-        await Filesystem.writeJson(context, join(dir, "session", session.projectID, session.id + ".json"), {
+        await context.fs.write(join(dir, "session_diff", session.id + ".json"), JSON.stringify(diffs));
+        await context.fs.writeJson(join(dir, "session", session.projectID, session.id + ".json"), {
           ...session,
           summary: {
             additions: diffs.reduce((sum, x) => sum + x.additions, 0),
@@ -2637,12 +4354,12 @@ var Storage;
   ];
   async function getDir(context) {
     const dir = join(context.dataPath, "storage");
-    const migration = await Filesystem.readJson(context, join(dir, "migration")).then((x) => parseInt(x)).catch(() => 0);
+    const migration = await context.fs.readJson(join(dir, "migration")).then((x) => parseInt(x)).catch(() => 0);
     for (let index2 = migration; index2 < MIGRATIONS.length; index2++) {
-      log.info("running migration", { index: index2 });
+      getLog(context).info("running migration", { index: index2 });
       const migrationFn = MIGRATIONS[index2];
-      await migrationFn(context, dir).catch(() => log.error("failed to run migration", { index: index2 }));
-      await Filesystem.write(context, join(dir, "migration"), (index2 + 1).toString());
+      await migrationFn(context, dir).catch(() => getLog(context).error("failed to run migration", { index: index2 }));
+      await context.fs.write(join(dir, "migration"), (index2 + 1).toString());
     }
     return dir;
   }
@@ -2650,7 +4367,7 @@ var Storage;
     const dir = await getDir(context);
     const target = join(dir, ...key) + ".json";
     return withErrorHandling(async () => {
-      await fs.unlink(target).catch(() => {
+      await fs4.unlink(target).catch(() => {
       });
     });
   }
@@ -2662,7 +4379,7 @@ var Storage;
       var _stack = [];
       try {
         const _ = __using(_stack, await Lock.read(target));
-        const result = await Filesystem.readJson(context, target);
+        const result = await context.fs.readJson(target);
         return result;
       } catch (_2) {
         var _error = _2, _hasError = true;
@@ -2679,9 +4396,9 @@ var Storage;
       var _stack = [];
       try {
         const _ = __using(_stack, await Lock.write(target));
-        const content = await Filesystem.readJson(context, target);
+        const content = await context.fs.readJson(target);
         fn(content);
-        await Filesystem.writeJson(context, target, content);
+        await context.fs.writeJson(target, content);
         return content;
       } catch (_2) {
         var _error = _2, _hasError = true;
@@ -2698,7 +4415,7 @@ var Storage;
       var _stack = [];
       try {
         const _ = __using(_stack, await Lock.write(target));
-        await Filesystem.writeJson(context, target, content);
+        await context.fs.writeJson(target, content);
       } catch (_2) {
         var _error = _2, _hasError = true;
       } finally {
@@ -2720,10 +4437,10 @@ var Storage;
   async function list(context, prefix) {
     const dir = await getDir(context);
     try {
-      const result = await Glob.scan(context, "**/*", {
+      const result = await context.fs.glob("**/*", {
         cwd: join(dir, ...prefix),
-        include: "file"
-      }).then((results) => results.map((x) => [...prefix, ...x.slice(0, -5).split(sep)]));
+        nodir: true
+      }).then((results) => results.map((x) => [...prefix, ...x.slice(0, -5).split(sep2)]));
       result.sort();
       return result;
     } catch {
@@ -2734,6 +4451,11 @@ var Storage;
 })(Storage || (Storage = {}));
 
 export {
+  consoleLogger,
+  SqliteNoSqlDb,
+  NodeFS,
+  NodeSearchProvider,
+  SqlJsStorage,
   join,
   dirname,
   basename,
@@ -2741,15 +4463,10 @@ export {
   isAbsolute,
   relative,
   resolve,
-  Filesystem,
-  Log,
   Flag,
   ProjectID,
   ProjectTable,
-  Protected,
-  FileIgnore,
   FileTimeService,
-  Project,
   SessionTable,
   MessageTable,
   PartTable,
@@ -2758,6 +4475,5 @@ export {
   Timestamps,
   NotFoundError,
   Database,
-  SqliteNoSqlDb,
   Storage
 };