anycodex 0.0.25 → 0.0.27

package/dist/chunk-NRFXEZ7N.js

@@ -1,4479 +0,0 @@
-#!/usr/bin/env node
-import {
-  Schema_exports,
-  __callDispose,
-  __using,
-  withStatics,
-  zod_default
-} 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");
-
-// ../../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/entity.js
-var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
-function is(value, type) {
-  if (!value || typeof value !== "object") return false;
-  if (value instanceof type) return true;
-  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
-  let cls = Object.getPrototypeOf(value).constructor;
-  if (cls) while (cls) {
-    if (entityKind in cls && cls[entityKind] === type[entityKind]) return true;
-    cls = Object.getPrototypeOf(cls);
-  }
-  return false;
-}
-
-// ../../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.js
-var Column = class {
-  static [entityKind] = "Column";
-  name;
-  keyAsName;
-  primary;
-  notNull;
-  default;
-  defaultFn;
-  onUpdateFn;
-  hasDefault;
-  isUnique;
-  uniqueName;
-  uniqueType;
-  dataType;
-  columnType;
-  enumValues = void 0;
-  generated = void 0;
-  generatedIdentity = void 0;
-  length;
-  isLengthExact;
-  isAlias;
-  /** @internal */
-  config;
-  /** @internal */
-  table;
-  /** @internal */
-  onInit() {
-  }
-  constructor(table, config) {
-    this.config = config;
-    this.onInit();
-    this.table = table;
-    this.name = config.name;
-    this.isAlias = false;
-    this.keyAsName = config.keyAsName;
-    this.notNull = config.notNull;
-    this.default = config.default;
-    this.defaultFn = config.defaultFn;
-    this.onUpdateFn = config.onUpdateFn;
-    this.hasDefault = config.hasDefault;
-    this.primary = config.primaryKey;
-    this.isUnique = config.isUnique;
-    this.uniqueName = config.uniqueName;
-    this.uniqueType = config.uniqueType;
-    this.dataType = config.dataType;
-    this.columnType = config.columnType;
-    this.generated = config.generated;
-    this.generatedIdentity = config.generatedIdentity;
-    this.length = config["length"];
-    this.isLengthExact = config["isLengthExact"];
-  }
-  mapFromDriverValue(value) {
-    return value;
-  }
-  mapToDriverValue(value) {
-    return value;
-  }
-  shouldDisableInsert() {
-    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
-  }
-  /** @internal */
-  [OriginalColumn]() {
-    return this;
-  }
-};
-
-// ../../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/table.utils.js
-var TableName = /* @__PURE__ */ Symbol.for("drizzle:Name");
-
-// ../../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/table.js
-var TableSchema = /* @__PURE__ */ Symbol.for("drizzle:Schema");
-var TableColumns = /* @__PURE__ */ Symbol.for("drizzle:Columns");
-var ExtraConfigColumns = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigColumns");
-var OriginalName = /* @__PURE__ */ Symbol.for("drizzle:OriginalName");
-var BaseName = /* @__PURE__ */ Symbol.for("drizzle:BaseName");
-var IsAlias = /* @__PURE__ */ Symbol.for("drizzle:IsAlias");
-var ExtraConfigBuilder = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigBuilder");
-var IsDrizzleTable = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable");
-var Table = class {
-  static [entityKind] = "Table";
-  /** @internal */
-  static Symbol = {
-    Name: TableName,
-    Schema: TableSchema,
-    OriginalName,
-    Columns: TableColumns,
-    ExtraConfigColumns,
-    BaseName,
-    IsAlias,
-    ExtraConfigBuilder
-  };
-  /**
-  * @internal
-  * Can be changed if the table is aliased.
-  */
-  [TableName];
-  /**
-  * @internal
-  * Used to store the original name of the table, before any aliasing.
-  */
-  [OriginalName];
-  /** @internal */
-  [TableSchema];
-  /** @internal */
-  [TableColumns];
-  /** @internal */
-  [ExtraConfigColumns];
-  /**
-  *  @internal
-  * Used to store the table name before the transformation via the `tableCreator` functions.
-  */
-  [BaseName];
-  /** @internal */
-  [IsAlias] = false;
-  /** @internal */
-  [IsDrizzleTable] = true;
-  /** @internal */
-  [ExtraConfigBuilder] = void 0;
-  constructor(name, schema, baseName) {
-    this[TableName] = this[OriginalName] = name;
-    this[TableSchema] = schema;
-    this[BaseName] = baseName;
-  }
-};
-
-// ../../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/subquery.js
-var Subquery = class {
-  static [entityKind] = "Subquery";
-  constructor(sql2, fields, alias, isWith = false, usedTables = []) {
-    this._ = {
-      brand: "Subquery",
-      sql: sql2,
-      selectedFields: fields,
-      alias,
-      isWith,
-      usedTables
-    };
-  }
-};
-var WithSubquery = class extends Subquery {
-  static [entityKind] = "WithSubquery";
-};
-
-// ../../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/tracing.js
-var tracer = { startActiveSpan(name, fn) {
-  return fn();
-} };
-
-// ../../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/view-common.js
-var ViewBaseConfig = /* @__PURE__ */ Symbol.for("drizzle:ViewBaseConfig");
-
-// ../../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/sql/sql.js
-var FakePrimitiveParam = class {
-  static [entityKind] = "FakePrimitiveParam";
-};
-function isSQLWrapper(value) {
-  return value !== null && value !== void 0 && typeof value.getSQL === "function";
-}
-function mergeQueries(queries) {
-  const result = {
-    sql: "",
-    params: []
-  };
-  for (const query of queries) {
-    result.sql += query.sql;
-    result.params.push(...query.params);
-    if (query.typings?.length) {
-      if (!result.typings) result.typings = [];
-      result.typings.push(...query.typings);
-    }
-  }
-  return result;
-}
-var StringChunk = class {
-  static [entityKind] = "StringChunk";
-  value;
-  constructor(value) {
-    this.value = Array.isArray(value) ? value : [value];
-  }
-  getSQL() {
-    return new SQL([this]);
-  }
-};
-var SQL = class SQL2 {
-  static [entityKind] = "SQL";
-  /** @internal */
-  decoder = noopDecoder;
-  /** @internal */
-  shouldInlineParams = false;
-  /** @internal */
-  usedTables = [];
-  constructor(queryChunks) {
-    this.queryChunks = queryChunks;
-    for (const chunk of queryChunks) if (is(chunk, Table)) {
-      const schemaName = chunk[Table.Symbol.Schema];
-      this.usedTables.push(schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
-    }
-  }
-  append(query) {
-    this.queryChunks.push(...query.queryChunks);
-    return this;
-  }
-  toQuery(config) {
-    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
-      const query = this.buildQueryFromSourceParams(this.queryChunks, config);
-      span?.setAttributes({
-        "drizzle.query.text": query.sql,
-        "drizzle.query.params": JSON.stringify(query.params)
-      });
-      return query;
-    });
-  }
-  buildQueryFromSourceParams(chunks, _config) {
-    const config = Object.assign({}, _config, {
-      inlineParams: _config.inlineParams || this.shouldInlineParams,
-      paramStartIndex: _config.paramStartIndex || { value: 0 }
-    });
-    const { casing, escapeName, escapeParam, prepareTyping, inlineParams, paramStartIndex, invokeSource } = config;
-    return mergeQueries(chunks.map((chunk) => {
-      if (is(chunk, StringChunk)) return {
-        sql: chunk.value.join(""),
-        params: []
-      };
-      if (is(chunk, Name)) return {
-        sql: escapeName(chunk.value),
-        params: []
-      };
-      if (chunk === void 0) return {
-        sql: "",
-        params: []
-      };
-      if (Array.isArray(chunk)) {
-        const result = [new StringChunk("(")];
-        for (const [i, p] of chunk.entries()) {
-          result.push(p);
-          if (i < chunk.length - 1) result.push(new StringChunk(", "));
-        }
-        result.push(new StringChunk(")"));
-        return this.buildQueryFromSourceParams(result, config);
-      }
-      if (is(chunk, SQL2)) return this.buildQueryFromSourceParams(chunk.queryChunks, {
-        ...config,
-        inlineParams: inlineParams || chunk.shouldInlineParams
-      });
-      if (is(chunk, Table)) {
-        const schemaName = chunk[Table.Symbol.Schema];
-        const tableName = chunk[Table.Symbol.Name];
-        if (invokeSource === "mssql-view-with-schemabinding") return {
-          sql: (schemaName === void 0 ? escapeName("dbo") : escapeName(schemaName)) + "." + escapeName(tableName),
-          params: []
-        };
-        return {
-          sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
-          params: []
-        };
-      }
-      if (is(chunk, Column)) {
-        const columnName = casing.getColumnCasing(chunk);
-        if (_config.invokeSource === "indexes") return {
-          sql: escapeName(columnName),
-          params: []
-        };
-        const schemaName = invokeSource === "mssql-check" ? void 0 : chunk.table[Table.Symbol.Schema];
-        return {
-          sql: chunk.isAlias ? escapeName(chunk.name) : chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
-          params: []
-        };
-      }
-      if (is(chunk, View)) {
-        const schemaName = chunk[ViewBaseConfig].schema;
-        const viewName = chunk[ViewBaseConfig].name;
-        return {
-          sql: schemaName === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
-          params: []
-        };
-      }
-      if (is(chunk, Param)) {
-        if (is(chunk.value, Placeholder)) return {
-          sql: escapeParam(paramStartIndex.value++, chunk),
-          params: [chunk],
-          typings: ["none"]
-        };
-        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
-        if (is(mappedValue, SQL2)) return this.buildQueryFromSourceParams([mappedValue], config);
-        if (inlineParams) return {
-          sql: this.mapInlineParam(mappedValue, config),
-          params: []
-        };
-        let typings = ["none"];
-        if (prepareTyping) typings = [prepareTyping(chunk.encoder)];
-        return {
-          sql: escapeParam(paramStartIndex.value++, mappedValue),
-          params: [mappedValue],
-          typings
-        };
-      }
-      if (is(chunk, Placeholder)) return {
-        sql: escapeParam(paramStartIndex.value++, chunk),
-        params: [chunk],
-        typings: ["none"]
-      };
-      if (is(chunk, SQL2.Aliased) && chunk.fieldAlias !== void 0) return {
-        sql: (chunk.origin !== void 0 ? escapeName(chunk.origin) + "." : "") + escapeName(chunk.fieldAlias),
-        params: []
-      };
-      if (is(chunk, Subquery)) {
-        if (chunk._.isWith) return {
-          sql: escapeName(chunk._.alias),
-          params: []
-        };
-        return this.buildQueryFromSourceParams([
-          new StringChunk("("),
-          chunk._.sql,
-          new StringChunk(") "),
-          new Name(chunk._.alias)
-        ], config);
-      }
-      if (typeof chunk === "function" && "enumName" in chunk) {
-        if ("schema" in chunk && chunk.schema) return {
-          sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName),
-          params: []
-        };
-        return {
-          sql: escapeName(chunk.enumName),
-          params: []
-        };
-      }
-      if (isSQLWrapper(chunk)) {
-        if (chunk.shouldOmitSQLParens?.()) return this.buildQueryFromSourceParams([chunk.getSQL()], config);
-        return this.buildQueryFromSourceParams([
-          new StringChunk("("),
-          chunk.getSQL(),
-          new StringChunk(")")
-        ], config);
-      }
-      if (inlineParams) return {
-        sql: this.mapInlineParam(chunk, config),
-        params: []
-      };
-      return {
-        sql: escapeParam(paramStartIndex.value++, chunk),
-        params: [chunk],
-        typings: ["none"]
-      };
-    }));
-  }
-  mapInlineParam(chunk, { escapeString }) {
-    if (chunk === null) return "null";
-    if (typeof chunk === "number" || typeof chunk === "boolean" || typeof chunk === "bigint") return chunk.toString();
-    if (typeof chunk === "string") return escapeString(chunk);
-    if (typeof chunk === "object") {
-      const mappedValueAsString = chunk.toString();
-      if (mappedValueAsString === "[object Object]") return escapeString(JSON.stringify(chunk));
-      return escapeString(mappedValueAsString);
-    }
-    throw new Error("Unexpected param value: " + chunk);
-  }
-  getSQL() {
-    return this;
-  }
-  as(alias) {
-    if (alias === void 0) return this;
-    return new SQL2.Aliased(this, alias);
-  }
-  mapWith(decoder) {
-    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
-    return this;
-  }
-  inlineParams() {
-    this.shouldInlineParams = true;
-    return this;
-  }
-  /**
-  * This method is used to conditionally include a part of the query.
-  *
-  * @param condition - Condition to check
-  * @returns itself if the condition is `true`, otherwise `undefined`
-  */
-  if(condition) {
-    return condition ? this : void 0;
-  }
-};
-var Name = class {
-  static [entityKind] = "Name";
-  brand;
-  constructor(value) {
-    this.value = value;
-  }
-  getSQL() {
-    return new SQL([this]);
-  }
-};
-var noopDecoder = { mapFromDriverValue: (value) => value };
-var noopEncoder = { mapToDriverValue: (value) => value };
-var noopMapper = {
-  ...noopDecoder,
-  ...noopEncoder
-};
-var Param = class {
-  static [entityKind] = "Param";
-  brand;
-  /**
-  * @param value - Parameter value
-  * @param encoder - Encoder to convert the value to a driver parameter
-  */
-  constructor(value, encoder = noopEncoder) {
-    this.value = value;
-    this.encoder = encoder;
-  }
-  getSQL() {
-    return new SQL([this]);
-  }
-};
-function sql(strings, ...params) {
-  const queryChunks = [];
-  if (params.length > 0 || strings.length > 0 && strings[0] !== "") queryChunks.push(new StringChunk(strings[0]));
-  for (const [paramIndex, param$1] of params.entries()) queryChunks.push(param$1, new StringChunk(strings[paramIndex + 1]));
-  return new SQL(queryChunks);
-}
-(function(_sql) {
-  function empty() {
-    return new SQL([]);
-  }
-  _sql.empty = empty;
-  function fromList(list) {
-    return new SQL(list);
-  }
-  _sql.fromList = fromList;
-  function raw(str) {
-    return new SQL([new StringChunk(str)]);
-  }
-  _sql.raw = raw;
-  function join2(chunks, separator) {
-    const result = [];
-    for (const [i, chunk] of chunks.entries()) {
-      if (i > 0 && separator !== void 0) result.push(separator);
-      result.push(chunk);
-    }
-    return new SQL(result);
-  }
-  _sql.join = join2;
-  function identifier(value) {
-    return new Name(value);
-  }
-  _sql.identifier = identifier;
-  function placeholder$1(name$1) {
-    return new Placeholder(name$1);
-  }
-  _sql.placeholder = placeholder$1;
-  function param$1(value, encoder) {
-    return new Param(value, encoder);
-  }
-  _sql.param = param$1;
-})(sql || (sql = {}));
-(function(_SQL) {
-  class Aliased {
-    static [entityKind] = "SQL.Aliased";
-    /** @internal */
-    isSelectionField = false;
-    /** @internal */
-    origin;
-    constructor(sql$1, fieldAlias) {
-      this.sql = sql$1;
-      this.fieldAlias = fieldAlias;
-    }
-    getSQL() {
-      return this.sql;
-    }
-    /** @internal */
-    clone() {
-      return new Aliased(this.sql, this.fieldAlias);
-    }
-  }
-  _SQL.Aliased = Aliased;
-})(SQL || (SQL = {}));
-var Placeholder = class {
-  static [entityKind] = "Placeholder";
-  constructor(name$1) {
-    this.name = name$1;
-  }
-  getSQL() {
-    return new SQL([this]);
-  }
-};
-var IsDrizzleView = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleView");
-var View = class {
-  static [entityKind] = "View";
-  /** @internal */
-  [ViewBaseConfig];
-  /** @internal */
-  [IsDrizzleView] = true;
-  /** @internal */
-  get [TableName]() {
-    return this[ViewBaseConfig].name;
-  }
-  /** @internal */
-  get [TableSchema]() {
-    return this[ViewBaseConfig].schema;
-  }
-  /** @internal */
-  get [IsAlias]() {
-    return this[ViewBaseConfig].isAlias;
-  }
-  /** @internal */
-  get [OriginalName]() {
-    return this[ViewBaseConfig].originalName;
-  }
-  /** @internal */
-  get [TableColumns]() {
-    return this[ViewBaseConfig].selectedFields;
-  }
-  constructor({ name: name$1, schema, selectedFields, query }) {
-    this[ViewBaseConfig] = {
-      name: name$1,
-      originalName: name$1,
-      schema,
-      selectedFields,
-      query,
-      isExisting: !query,
-      isAlias: false
-    };
-  }
-};
-Column.prototype.getSQL = function() {
-  return new SQL([this]);
-};
-Subquery.prototype.getSQL = function() {
-  return new SQL([this]);
-};
-
-// ../../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-builder.js
-var ColumnBuilder = class {
-  static [entityKind] = "ColumnBuilder";
-  /** @internal */
-  config;
-  constructor(name, dataType, columnType) {
-    this.config = {
-      name,
-      keyAsName: name === "",
-      notNull: false,
-      default: void 0,
-      hasDefault: false,
-      primaryKey: false,
-      isUnique: false,
-      uniqueName: void 0,
-      uniqueType: void 0,
-      dataType,
-      columnType,
-      generated: void 0
-    };
-  }
-  /**
-  * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
-  *
-  * @example
-  * ```ts
-  * const users = pgTable('users', {
-  * 	id: integer('id').$type<UserId>().primaryKey(),
-  * 	details: json('details').$type<UserDetails>().notNull(),
-  * });
-  * ```
-  */
-  $type() {
-    return this;
-  }
-  /**
-  * Adds a `not null` clause to the column definition.
-  *
-  * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
-  */
-  notNull() {
-    this.config.notNull = true;
-    return this;
-  }
-  /**
-  * Adds a `default <value>` clause to the column definition.
-  *
-  * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
-  *
-  * If you need to set a dynamic default value, use {@link $defaultFn} instead.
-  */
-  default(value) {
-    this.config.default = value;
-    this.config.hasDefault = true;
-    return this;
-  }
-  /**
-  * Adds a dynamic default value to the column.
-  * The function will be called when the row is inserted, and the returned value will be used as the column value.
-  *
-  * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
-  */
-  $defaultFn(fn) {
-    this.config.defaultFn = fn;
-    this.config.hasDefault = true;
-    return this;
-  }
-  /**
-  * Alias for {@link $defaultFn}.
-  */
-  $default = this.$defaultFn;
-  /**
-  * Adds a dynamic update value to the column.
-  * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
-  * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
-  *
-  * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
-  */
-  $onUpdateFn(fn) {
-    this.config.onUpdateFn = fn;
-    this.config.hasDefault = true;
-    return this;
-  }
-  /**
-  * Alias for {@link $onUpdateFn}.
-  */
-  $onUpdate = this.$onUpdateFn;
-  /**
-  * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
-  *
-  * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
-  */
-  primaryKey() {
-    this.config.primaryKey = true;
-    this.config.notNull = true;
-    return this;
-  }
-  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
-  setName(name) {
-    if (this.config.name !== "") return;
-    this.config.name = name;
-  }
-};
-
-// ../../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/sqlite-core/foreign-keys.js
-var ForeignKeyBuilder = class {
-  static [entityKind] = "SQLiteForeignKeyBuilder";
-  /** @internal */
-  reference;
-  /** @internal */
-  _onUpdate;
-  /** @internal */
-  _onDelete;
-  constructor(config, actions) {
-    this.reference = () => {
-      const { name, columns, foreignColumns } = config();
-      return {
-        name,
-        columns,
-        foreignTable: foreignColumns[0].table,
-        foreignColumns
-      };
-    };
-    if (actions) {
-      this._onUpdate = actions.onUpdate;
-      this._onDelete = actions.onDelete;
-    }
-  }
-  onUpdate(action) {
-    this._onUpdate = action;
-    return this;
-  }
-  onDelete(action) {
-    this._onDelete = action;
-    return this;
-  }
-  /** @internal */
-  build(table) {
-    return new ForeignKey(table, this);
-  }
-};
-var ForeignKey = class {
-  static [entityKind] = "SQLiteForeignKey";
-  reference;
-  onUpdate;
-  onDelete;
-  constructor(table, builder) {
-    this.table = table;
-    this.reference = builder.reference;
-    this.onUpdate = builder._onUpdate;
-    this.onDelete = builder._onDelete;
-  }
-  getName() {
-    const { name, columns, foreignColumns } = this.reference();
-    const columnNames = columns.map((column) => column.name);
-    const foreignColumnNames = foreignColumns.map((column) => column.name);
-    const chunks = [
-      this.table[TableName],
-      ...columnNames,
-      foreignColumns[0].table[TableName],
-      ...foreignColumnNames
-    ];
-    return name ?? `${chunks.join("_")}_fk`;
-  }
-  isNameExplicit() {
-    return !!this.reference().name;
-  }
-};
-
-// ../../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/sqlite-core/columns/common.js
-var SQLiteColumnBuilder = class extends ColumnBuilder {
-  static [entityKind] = "SQLiteColumnBuilder";
-  foreignKeyConfigs = [];
-  references(ref, actions = {}) {
-    this.foreignKeyConfigs.push({
-      ref,
-      actions
-    });
-    return this;
-  }
-  unique(name) {
-    this.config.isUnique = true;
-    this.config.uniqueName = name;
-    return this;
-  }
-  generatedAlwaysAs(as, config) {
-    this.config.generated = {
-      as,
-      type: "always",
-      mode: config?.mode ?? "virtual"
-    };
-    return this;
-  }
-  /** @internal */
-  buildForeignKeys(column, table) {
-    return this.foreignKeyConfigs.map(({ ref, actions }) => {
-      return ((ref$1, actions$1) => {
-        const builder = new ForeignKeyBuilder(() => {
-          const foreignColumn = ref$1();
-          return {
-            columns: [column],
-            foreignColumns: [foreignColumn]
-          };
-        });
-        if (actions$1.onUpdate) builder.onUpdate(actions$1.onUpdate);
-        if (actions$1.onDelete) builder.onDelete(actions$1.onDelete);
-        return builder.build(table);
-      })(ref, actions);
-    });
-  }
-};
-var SQLiteColumn = class extends Column {
-  static [entityKind] = "SQLiteColumn";
-  /** @internal */
-  table;
-  constructor(table, config) {
-    super(table, config);
-    this.table = table;
-  }
-};
-
-// ../../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/utils.js
-function getColumnNameAndConfig(a, b) {
-  return {
-    name: typeof a === "string" && a.length > 0 ? a : "",
-    config: typeof a === "object" ? a : b
-  };
-}
-var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
-
-// ../../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/sqlite-core/columns/blob.js
-function hexToText(hexString) {
-  let result = "";
-  for (let i = 0; i < hexString.length; i += 2) {
-    const hexPair = hexString.slice(i, i + 2);
-    const decimalValue = Number.parseInt(hexPair, 16);
-    result += String.fromCodePoint(decimalValue);
-  }
-  return result;
-}
-var SQLiteBigIntBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBigIntBuilder";
-  constructor(name) {
-    super(name, "bigint int64", "SQLiteBigInt");
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteBigInt(table, this.config);
-  }
-};
-var SQLiteBigInt = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteBigInt";
-  getSQLType() {
-    return "blob";
-  }
-  mapFromDriverValue(value) {
-    if (typeof value === "string") return BigInt(hexToText(value));
-    if (typeof Buffer !== "undefined" && Buffer.from) {
-      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
-      return BigInt(buf.toString("utf8"));
-    }
-    return BigInt(textDecoder.decode(value));
-  }
-  mapToDriverValue(value) {
-    return Buffer.from(value.toString());
-  }
-};
-var SQLiteBlobJsonBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBlobJsonBuilder";
-  constructor(name) {
-    super(name, "object json", "SQLiteBlobJson");
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteBlobJson(table, this.config);
-  }
-};
-var SQLiteBlobJson = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteBlobJson";
-  getSQLType() {
-    return "blob";
-  }
-  mapFromDriverValue(value) {
-    if (typeof value === "string") return JSON.parse(hexToText(value));
-    if (typeof Buffer !== "undefined" && Buffer.from) {
-      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
-      return JSON.parse(buf.toString("utf8"));
-    }
-    return JSON.parse(textDecoder.decode(value));
-  }
-  mapToDriverValue(value) {
-    return Buffer.from(JSON.stringify(value));
-  }
-};
-var SQLiteBlobBufferBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBlobBufferBuilder";
-  constructor(name) {
-    super(name, "object buffer", "SQLiteBlobBuffer");
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteBlobBuffer(table, this.config);
-  }
-};
-var SQLiteBlobBuffer = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteBlobBuffer";
-  mapFromDriverValue(value) {
-    if (Buffer.isBuffer(value)) return value;
-    if (typeof value === "string") return Buffer.from(value, "hex");
-    return Buffer.from(value);
-  }
-  getSQLType() {
-    return "blob";
-  }
-};
-function blob(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config?.mode === "json") return new SQLiteBlobJsonBuilder(name);
-  if (config?.mode === "bigint") return new SQLiteBigIntBuilder(name);
-  return new SQLiteBlobBufferBuilder(name);
-}
-
-// ../../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/sqlite-core/columns/custom.js
-var SQLiteCustomColumnBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteCustomColumnBuilder";
-  constructor(name, fieldConfig, customTypeParams) {
-    super(name, "custom", "SQLiteCustomColumn");
-    this.config.fieldConfig = fieldConfig;
-    this.config.customTypeParams = customTypeParams;
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteCustomColumn(table, this.config);
-  }
-};
-var SQLiteCustomColumn = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteCustomColumn";
-  sqlName;
-  mapTo;
-  mapFrom;
-  mapJson;
-  forJsonSelect;
-  constructor(table, config) {
-    super(table, config);
-    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
-    this.mapTo = config.customTypeParams.toDriver;
-    this.mapFrom = config.customTypeParams.fromDriver;
-    this.mapJson = config.customTypeParams.fromJson;
-    this.forJsonSelect = config.customTypeParams.forJsonSelect;
-  }
-  getSQLType() {
-    return this.sqlName;
-  }
-  mapFromDriverValue(value) {
-    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
-  }
-  mapFromJsonValue(value) {
-    return typeof this.mapJson === "function" ? this.mapJson(value) : this.mapFromDriverValue(value);
-  }
-  jsonSelectIdentifier(identifier, sql2) {
-    if (typeof this.forJsonSelect === "function") return this.forJsonSelect(identifier, sql2);
-    const rawType = this.getSQLType().toLowerCase();
-    const parenPos = rawType.indexOf("(");
-    switch (parenPos + 1 ? rawType.slice(0, parenPos) : rawType) {
-      case "numeric":
-      case "decimal":
-      case "bigint":
-        return sql2`cast(${identifier} as text)`;
-      case "blob":
-        return sql2`hex(${identifier})`;
-      default:
-        return identifier;
-    }
-  }
-  mapToDriverValue(value) {
-    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
-  }
-};
-function customType(customTypeParams) {
-  return (a, b) => {
-    const { name, config } = getColumnNameAndConfig(a, b);
-    return new SQLiteCustomColumnBuilder(name, config, customTypeParams);
-  };
-}
-
-// ../../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/sqlite-core/columns/integer.js
-var SQLiteBaseIntegerBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteBaseIntegerBuilder";
-  constructor(name, dataType, columnType) {
-    super(name, dataType, columnType);
-    this.config.autoIncrement = false;
-  }
-  primaryKey(config) {
-    if (config?.autoIncrement) this.config.autoIncrement = true;
-    this.config.hasDefault = true;
-    return super.primaryKey();
-  }
-};
-var SQLiteBaseInteger = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteBaseInteger";
-  autoIncrement = this.config.autoIncrement;
-  getSQLType() {
-    return "integer";
-  }
-};
-var SQLiteIntegerBuilder = class extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteIntegerBuilder";
-  constructor(name) {
-    super(name, "number int53", "SQLiteInteger");
-  }
-  build(table) {
-    return new SQLiteInteger(table, this.config);
-  }
-};
-var SQLiteInteger = class extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteInteger";
-};
-var SQLiteTimestampBuilder = class extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteTimestampBuilder";
-  constructor(name, mode) {
-    super(name, "object date", "SQLiteTimestamp");
-    this.config.mode = mode;
-  }
-  /**
-  * @deprecated Use `default()` with your own expression instead.
-  *
-  * Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.
-  */
-  defaultNow() {
-    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
-  }
-  build(table) {
-    return new SQLiteTimestamp(table, this.config);
-  }
-};
-var SQLiteTimestamp = class extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteTimestamp";
-  mode = this.config.mode;
-  mapFromDriverValue(value) {
-    if (typeof value === "string") return new Date(value.replaceAll('"', ""));
-    if (this.config.mode === "timestamp") return /* @__PURE__ */ new Date(value * 1e3);
-    return new Date(value);
-  }
-  mapToDriverValue(value) {
-    if (typeof value === "number") return value;
-    const unix = value.getTime();
-    if (this.config.mode === "timestamp") return Math.floor(unix / 1e3);
-    return unix;
-  }
-};
-var SQLiteBooleanBuilder = class extends SQLiteBaseIntegerBuilder {
-  static [entityKind] = "SQLiteBooleanBuilder";
-  constructor(name, mode) {
-    super(name, "boolean", "SQLiteBoolean");
-    this.config.mode = mode;
-  }
-  build(table) {
-    return new SQLiteBoolean(table, this.config);
-  }
-};
-var SQLiteBoolean = class extends SQLiteBaseInteger {
-  static [entityKind] = "SQLiteBoolean";
-  mode = this.config.mode;
-  mapFromDriverValue(value) {
-    return Number(value) === 1;
-  }
-  mapToDriverValue(value) {
-    return value ? 1 : 0;
-  }
-};
-function integer(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") return new SQLiteTimestampBuilder(name, config.mode);
-  if (config?.mode === "boolean") return new SQLiteBooleanBuilder(name, config.mode);
-  return new SQLiteIntegerBuilder(name);
-}
-
-// ../../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/sqlite-core/columns/numeric.js
-var SQLiteNumericBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericBuilder";
-  constructor(name) {
-    super(name, "string numeric", "SQLiteNumeric");
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteNumeric(table, this.config);
-  }
-};
-var SQLiteNumeric = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumeric";
-  mapFromDriverValue(value) {
-    if (typeof value === "string") return value;
-    return String(value);
-  }
-  getSQLType() {
-    return "numeric";
-  }
-};
-var SQLiteNumericNumberBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericNumberBuilder";
-  constructor(name) {
-    super(name, "number", "SQLiteNumericNumber");
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteNumericNumber(table, this.config);
-  }
-};
-var SQLiteNumericNumber = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumericNumber";
-  mapFromDriverValue(value) {
-    if (typeof value === "number") return value;
-    return Number(value);
-  }
-  mapToDriverValue = String;
-  getSQLType() {
-    return "numeric";
-  }
-};
-var SQLiteNumericBigIntBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteNumericBigIntBuilder";
-  constructor(name) {
-    super(name, "bigint int64", "SQLiteNumericBigInt");
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteNumericBigInt(table, this.config);
-  }
-};
-var SQLiteNumericBigInt = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteNumericBigInt";
-  mapFromDriverValue = BigInt;
-  mapToDriverValue = String;
-  getSQLType() {
-    return "numeric";
-  }
-};
-function numeric(a, b) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  const mode = config?.mode;
-  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
-}
-
-// ../../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/sqlite-core/columns/real.js
-var SQLiteRealBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteRealBuilder";
-  constructor(name) {
-    super(name, "number double", "SQLiteReal");
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteReal(table, this.config);
-  }
-};
-var SQLiteReal = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteReal";
-  getSQLType() {
-    return "real";
-  }
-};
-function real(name) {
-  return new SQLiteRealBuilder(name ?? "");
-}
-
-// ../../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/sqlite-core/columns/text.js
-var SQLiteTextBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteTextBuilder";
-  constructor(name, config) {
-    super(name, config.enum?.length ? "string enum" : "string", "SQLiteText");
-    this.config.enumValues = config.enum;
-    this.config.length = config.length;
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteText(table, this.config);
-  }
-};
-var SQLiteText = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteText";
-  enumValues = this.config.enumValues;
-  constructor(table, config) {
-    super(table, config);
-  }
-  getSQLType() {
-    return `text${this.config.length ? `(${this.config.length})` : ""}`;
-  }
-};
-var SQLiteTextJsonBuilder = class extends SQLiteColumnBuilder {
-  static [entityKind] = "SQLiteTextJsonBuilder";
-  constructor(name) {
-    super(name, "object json", "SQLiteTextJson");
-  }
-  /** @internal */
-  build(table) {
-    return new SQLiteTextJson(table, this.config);
-  }
-};
-var SQLiteTextJson = class extends SQLiteColumn {
-  static [entityKind] = "SQLiteTextJson";
-  getSQLType() {
-    return "text";
-  }
-  mapFromDriverValue(value) {
-    return JSON.parse(value);
-  }
-  mapToDriverValue(value) {
-    return JSON.stringify(value);
-  }
-};
-function text(a, b = {}) {
-  const { name, config } = getColumnNameAndConfig(a, b);
-  if (config.mode === "json") return new SQLiteTextJsonBuilder(name);
-  return new SQLiteTextBuilder(name, config);
-}
-
-// ../../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/sqlite-core/indexes.js
-var IndexBuilderOn = class {
-  static [entityKind] = "SQLiteIndexBuilderOn";
-  constructor(name, unique) {
-    this.name = name;
-    this.unique = unique;
-  }
-  on(...columns) {
-    return new IndexBuilder(this.name, columns, this.unique);
-  }
-};
-var IndexBuilder = class {
-  static [entityKind] = "SQLiteIndexBuilder";
-  /** @internal */
-  config;
-  constructor(name, columns, unique) {
-    this.config = {
-      name,
-      columns,
-      unique,
-      where: void 0
-    };
-  }
-  /**
-  * Condition for partial index.
-  */
-  where(condition) {
-    this.config.where = condition;
-    return this;
-  }
-  /** @internal */
-  build(table) {
-    return new Index(this.config, table);
-  }
-};
-var Index = class {
-  static [entityKind] = "SQLiteIndex";
-  config;
-  isNameExplicit;
-  constructor(config, table) {
-    this.config = {
-      ...config,
-      table
-    };
-    this.isNameExplicit = !!config.name;
-  }
-};
-function index(name) {
-  return new IndexBuilderOn(name, false);
-}
-
-// ../../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/sqlite-core/columns/all.js
-function getSQLiteColumnBuilders() {
-  return {
-    blob,
-    customType,
-    integer,
-    numeric,
-    real,
-    text
-  };
-}
-
-// ../../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/sqlite-core/table.js
-var InlineForeignKeys = /* @__PURE__ */ Symbol.for("drizzle:SQLiteInlineForeignKeys");
-var SQLiteTable = class extends Table {
-  static [entityKind] = "SQLiteTable";
-  /** @internal */
-  static Symbol = Object.assign({}, Table.Symbol, { InlineForeignKeys });
-  /** @internal */
-  [Table.Symbol.Columns];
-  /** @internal */
-  [InlineForeignKeys] = [];
-  /** @internal */
-  [Table.Symbol.ExtraConfigBuilder] = void 0;
-};
-function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
-  const rawTable = new SQLiteTable(name, schema, baseName);
-  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
-  const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name$1, colBuilderBase]) => {
-    const colBuilder = colBuilderBase;
-    colBuilder.setName(name$1);
-    const column = colBuilder.build(rawTable);
-    rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
-    return [name$1, column];
-  }));
-  const table = Object.assign(rawTable, builtColumns);
-  table[Table.Symbol.Columns] = builtColumns;
-  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
-  if (extraConfig) table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
-  return table;
-}
-var sqliteTable = (name, columns, extraConfig) => {
-  return sqliteTableBase(name, columns, extraConfig);
-};
-
-// ../../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/sqlite-core/primary-keys.js
-function primaryKey(...config) {
-  if (config[0].columns) return new PrimaryKeyBuilder(config[0].columns, config[0].name);
-  return new PrimaryKeyBuilder(config);
-}
-var PrimaryKeyBuilder = class {
-  static [entityKind] = "SQLitePrimaryKeyBuilder";
-  /** @internal */
-  columns;
-  /** @internal */
-  name;
-  constructor(columns, name) {
-    this.columns = columns;
-    this.name = name;
-  }
-  /** @internal */
-  build(table) {
-    return new PrimaryKey(table, this.columns, this.name);
-  }
-};
-var PrimaryKey = class {
-  static [entityKind] = "SQLitePrimaryKey";
-  columns;
-  name;
-  isNameExplicit;
-  constructor(table, columns, name) {
-    this.table = table;
-    this.columns = columns;
-    this.name = name;
-    this.isNameExplicit = !!name;
-  }
-  getName() {
-    return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
-  }
-};
-
-// ../../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 escapeBraces(str) {
-  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
-}
-function unescapeBraces(str) {
-  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
-}
-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 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 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;
-    if (s === "..") {
-      if (out.length > 0 && out[out.length - 1] !== "..") {
-        out.pop();
-      } else if (!isAbs) {
-        out.push("..");
-      }
-    } else {
-      out.push(s);
-    }
-  }
-  const result = out.join("/");
-  if (isAbs) return "/" + result;
-  return result || ".";
-}
-function relative(from, to) {
-  from = normalize(from);
-  to = normalize(to);
-  if (from === to) return "";
-  const fromParts = from.split("/").filter(Boolean);
-  const toParts = to.split("/").filter(Boolean);
-  let common = 0;
-  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
-    common++;
-  }
-  const ups = fromParts.length - common;
-  const downs = toParts.slice(common);
-  const parts = [...Array(ups).fill(".."), ...downs];
-  return parts.join("/") || ".";
-}
-function resolve(...parts) {
-  let resolved = "";
-  for (let i = parts.length - 1; i >= 0; i--) {
-    const part = parts[i];
-    if (!part) continue;
-    resolved = resolved ? part + "/" + resolved : part;
-    if (isAbsolute(part)) break;
-  }
-  return normalize(resolved);
-}
-var _env = {};
-function truthy(key) {
-  const value = _env[key]?.toLowerCase();
-  return value === "true" || value === "1";
-}
-function falsy(key) {
-  const value = _env[key]?.toLowerCase();
-  return value === "false" || value === "0";
-}
-function number(key) {
-  const value = _env[key];
-  if (!value) return void 0;
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
-}
-var Flag;
-((Flag2) => {
-  function init(env) {
-    _env = env;
-    Flag2.OPENCODE_AUTO_SHARE = truthy("OPENCODE_AUTO_SHARE");
-    Flag2.OPENCODE_GIT_BASH_PATH = _env["OPENCODE_GIT_BASH_PATH"];
-    Flag2.OPENCODE_CONFIG = _env["OPENCODE_CONFIG"];
-    Flag2.OPENCODE_CONFIG_CONTENT = _env["OPENCODE_CONFIG_CONTENT"];
-    Flag2.OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE");
-    Flag2.OPENCODE_DISABLE_PRUNE = truthy("OPENCODE_DISABLE_PRUNE");
-    Flag2.OPENCODE_DISABLE_TERMINAL_TITLE = truthy("OPENCODE_DISABLE_TERMINAL_TITLE");
-    Flag2.OPENCODE_PERMISSION = _env["OPENCODE_PERMISSION"];
-    Flag2.OPENCODE_DISABLE_DEFAULT_PLUGINS = truthy("OPENCODE_DISABLE_DEFAULT_PLUGINS");
-    Flag2.OPENCODE_DISABLE_LSP_DOWNLOAD = truthy("OPENCODE_DISABLE_LSP_DOWNLOAD");
-    Flag2.OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthy("OPENCODE_ENABLE_EXPERIMENTAL_MODELS");
-    Flag2.OPENCODE_DISABLE_AUTOCOMPACT = truthy("OPENCODE_DISABLE_AUTOCOMPACT");
-    Flag2.OPENCODE_DISABLE_MODELS_FETCH = truthy("OPENCODE_DISABLE_MODELS_FETCH");
-    Flag2.OPENCODE_DISABLE_CLAUDE_CODE = truthy("OPENCODE_DISABLE_CLAUDE_CODE");
-    Flag2.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_PROMPT");
-    Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS");
-    Flag2.OPENCODE_DISABLE_EXTERNAL_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS || truthy("OPENCODE_DISABLE_EXTERNAL_SKILLS");
-    Flag2.OPENCODE_FAKE_VCS = _env["OPENCODE_FAKE_VCS"];
-    Flag2.OPENCODE_SERVER_PASSWORD = _env["OPENCODE_SERVER_PASSWORD"];
-    Flag2.OPENCODE_SERVER_USERNAME = _env["OPENCODE_SERVER_USERNAME"];
-    Flag2.OPENCODE_ENABLE_QUESTION_TOOL = truthy("OPENCODE_ENABLE_QUESTION_TOOL");
-    Flag2.OPENCODE_EXPERIMENTAL = truthy("OPENCODE_EXPERIMENTAL");
-    Flag2.OPENCODE_EXPERIMENTAL_FILEWATCHER = truthy("OPENCODE_EXPERIMENTAL_FILEWATCHER");
-    Flag2.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = truthy("OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER");
-    Flag2.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY");
-    Flag2.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = (() => {
-      const copy = _env["OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"];
-      return copy === void 0 ? false : truthy("OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT");
-    })();
-    Flag2.OPENCODE_ENABLE_EXA = truthy("OPENCODE_ENABLE_EXA") || Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_EXA");
-    Flag2.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS");
-    Flag2.OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX");
-    Flag2.OPENCODE_EXPERIMENTAL_OXFMT = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_OXFMT");
-    Flag2.OPENCODE_EXPERIMENTAL_LSP_TY = truthy("OPENCODE_EXPERIMENTAL_LSP_TY");
-    Flag2.OPENCODE_EXPERIMENTAL_LSP_TOOL = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_LSP_TOOL");
-    Flag2.OPENCODE_DISABLE_FILETIME_CHECK = truthy("OPENCODE_DISABLE_FILETIME_CHECK");
-    Flag2.OPENCODE_EXPERIMENTAL_PLAN_MODE = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE");
-    Flag2.OPENCODE_EXPERIMENTAL_WORKSPACES = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_WORKSPACES");
-    Flag2.OPENCODE_EXPERIMENTAL_MARKDOWN = !falsy("OPENCODE_EXPERIMENTAL_MARKDOWN");
-    Flag2.OPENCODE_MODELS_URL = _env["OPENCODE_MODELS_URL"];
-    Flag2.OPENCODE_MODELS_PATH = _env["OPENCODE_MODELS_PATH"];
-    Flag2.OPENCODE_DISABLE_CHANNEL_DB = truthy("OPENCODE_DISABLE_CHANNEL_DB");
-    Flag2.OPENCODE_SKIP_MIGRATIONS = truthy("OPENCODE_SKIP_MIGRATIONS");
-    Flag2.OPENCODE_STRICT_CONFIG_DEPS = truthy("OPENCODE_STRICT_CONFIG_DEPS");
-  }
-  Flag2.init = init;
-  Flag2.OPENCODE_AUTO_SHARE = false;
-  Flag2.OPENCODE_DISABLE_AUTOUPDATE = false;
-  Flag2.OPENCODE_DISABLE_PRUNE = false;
-  Flag2.OPENCODE_DISABLE_TERMINAL_TITLE = false;
-  Flag2.OPENCODE_DISABLE_DEFAULT_PLUGINS = false;
-  Flag2.OPENCODE_DISABLE_LSP_DOWNLOAD = false;
-  Flag2.OPENCODE_ENABLE_EXPERIMENTAL_MODELS = false;
-  Flag2.OPENCODE_DISABLE_AUTOCOMPACT = false;
-  Flag2.OPENCODE_DISABLE_MODELS_FETCH = false;
-  Flag2.OPENCODE_DISABLE_CLAUDE_CODE = false;
-  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = false;
-  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = false;
-  Flag2.OPENCODE_DISABLE_EXTERNAL_SKILLS = false;
-  Flag2.OPENCODE_ENABLE_QUESTION_TOOL = false;
-  Flag2.OPENCODE_EXPERIMENTAL = false;
-  Flag2.OPENCODE_EXPERIMENTAL_FILEWATCHER = false;
-  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = false;
-  Flag2.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = false;
-  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = false;
-  Flag2.OPENCODE_ENABLE_EXA = false;
-  Flag2.OPENCODE_EXPERIMENTAL_OXFMT = false;
-  Flag2.OPENCODE_EXPERIMENTAL_LSP_TY = false;
-  Flag2.OPENCODE_EXPERIMENTAL_LSP_TOOL = false;
-  Flag2.OPENCODE_DISABLE_FILETIME_CHECK = false;
-  Flag2.OPENCODE_EXPERIMENTAL_PLAN_MODE = false;
-  Flag2.OPENCODE_EXPERIMENTAL_WORKSPACES = false;
-  Flag2.OPENCODE_EXPERIMENTAL_MARKDOWN = true;
-  Flag2.OPENCODE_DISABLE_CHANNEL_DB = false;
-  Flag2.OPENCODE_SKIP_MIGRATIONS = false;
-  Flag2.OPENCODE_STRICT_CONFIG_DEPS = false;
-})(Flag || (Flag = {}));
-Object.defineProperty(Flag, "OPENCODE_DISABLE_PROJECT_CONFIG", {
-  get() {
-    return truthy("OPENCODE_DISABLE_PROJECT_CONFIG");
-  },
-  enumerable: true,
-  configurable: false
-});
-Object.defineProperty(Flag, "OPENCODE_TUI_CONFIG", {
-  get() {
-    return _env["OPENCODE_TUI_CONFIG"];
-  },
-  enumerable: true,
-  configurable: false
-});
-Object.defineProperty(Flag, "OPENCODE_CONFIG_DIR", {
-  get() {
-    return _env["OPENCODE_CONFIG_DIR"];
-  },
-  enumerable: true,
-  configurable: false
-});
-Object.defineProperty(Flag, "OPENCODE_CLIENT", {
-  get() {
-    return _env["OPENCODE_CLIENT"] ?? "cli";
-  },
-  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) => ({
-    global: schema.makeUnsafe("global"),
-    make: (id) => schema.makeUnsafe(id),
-    zod: zod_default.string().pipe(zod_default.custom())
-  }))
-);
-var ProjectTable = sqliteTable("project", {
-  id: text().$type().primaryKey(),
-  worktree: text().notNull(),
-  vcs: text(),
-  name: text(),
-  icon_url: text(),
-  icon_color: text(),
-  ...Timestamps,
-  time_initialized: integer(),
-  sandboxes: text({ mode: "json" }).notNull().$type(),
-  commands: text({ mode: "json" }).$type()
-});
-var DARWIN_HOME = [
-  "Music",
-  "Pictures",
-  "Movies",
-  "Downloads",
-  "Desktop",
-  "Documents",
-  "Public",
-  "Applications",
-  "Library"
-];
-var DARWIN_LIBRARY = [
-  "Application Support/AddressBook",
-  "Calendars",
-  "Mail",
-  "Messages",
-  "Safari",
-  "Cookies",
-  "Application Support/com.apple.TCC",
-  "PersonalizationPortrait",
-  "Metadata/CoreSpotlight",
-  "Suggestions"
-];
-var DARWIN_ROOT = ["/.DocumentRevisions-V100", "/.Spotlight-V100", "/.Trashes", "/.fseventsd"];
-var WIN32_HOME = ["AppData", "Downloads", "Desktop", "Documents", "Pictures", "Music", "Videos", "OneDrive"];
-var Protected;
-((Protected2) => {
-  function names(platform) {
-    if (platform === "darwin") return new Set(DARWIN_HOME);
-    if (platform === "win32") return new Set(WIN32_HOME);
-    return /* @__PURE__ */ new Set();
-  }
-  Protected2.names = names;
-  function paths(home, platform) {
-    if (platform === "darwin")
-      return [
-        ...DARWIN_HOME.map((n) => join(home, n)),
-        ...DARWIN_LIBRARY.map((n) => join(home, "Library", n)),
-        ...DARWIN_ROOT
-      ];
-    if (platform === "win32") return WIN32_HOME.map((n) => join(home, n));
-    return [];
-  }
-  Protected2.paths = paths;
-})(Protected || (Protected = {}));
-var FileIgnore;
-((FileIgnore2) => {
-  const FOLDERS = /* @__PURE__ */ new Set([
-    "node_modules",
-    "bower_components",
-    ".pnpm-store",
-    "vendor",
-    ".npm",
-    "dist",
-    "build",
-    "out",
-    ".next",
-    "target",
-    "bin",
-    "obj",
-    ".git",
-    ".svn",
-    ".hg",
-    ".vscode",
-    ".idea",
-    ".turbo",
-    ".output",
-    "desktop",
-    ".sst",
-    ".cache",
-    ".webkit-cache",
-    "__pycache__",
-    ".pytest_cache",
-    "mypy_cache",
-    ".history",
-    ".gradle"
-  ]);
-  const FILES = [
-    "**/*.swp",
-    "**/*.swo",
-    "**/*.pyc",
-    "**/.DS_Store",
-    "**/Thumbs.db",
-    "**/logs/**",
-    "**/tmp/**",
-    "**/temp/**",
-    "**/*.log",
-    "**/coverage/**",
-    "**/.nyc_output/**"
-  ];
-  FileIgnore2.PATTERNS = [...FILES, ...FOLDERS];
-  function match2(filepath, opts) {
-    for (const pattern of opts?.whitelist || []) {
-      if (Glob.match(pattern, filepath)) return false;
-    }
-    const parts = filepath.split(/[/\\]/);
-    for (let i = 0; i < parts.length; i++) {
-      if (FOLDERS.has(parts[i])) return true;
-    }
-    const extra = opts?.extra || [];
-    for (const pattern of [...FILES, ...extra]) {
-      if (Glob.match(pattern, filepath)) return true;
-    }
-    return false;
-  }
-  FileIgnore2.match = match2;
-})(FileIgnore || (FileIgnore = {}));
-var FileTimeService = class {
-  readTimes = {};
-  locks = /* @__PURE__ */ new Map();
-  read(sessionID, file) {
-    this.readTimes[sessionID] = this.readTimes[sessionID] || {};
-    this.readTimes[sessionID][file] = /* @__PURE__ */ new Date();
-  }
-  get(sessionID, file) {
-    return this.readTimes[sessionID]?.[file];
-  }
-  async assert(context, sessionID, filepath) {
-    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 context.fs.stat(filepath);
-    const mtimeMs = s?.mtimeMs;
-    if (mtimeMs && mtimeMs > time.getTime() + 50) {
-      const mtime = new Date(mtimeMs);
-      throw new Error(
-        `File ${filepath} has been modified since it was last read.
-Last modification: ${mtime.toISOString()}
-Last read: ${time.toISOString()}
-
-Please read the file again before modifying it.`
-      );
-    }
-  }
-  async withLock(filepath, fn) {
-    const currentLock = this.locks.get(filepath) ?? Promise.resolve();
-    let release = () => {
-    };
-    const nextLock = new Promise((resolve2) => {
-      release = resolve2;
-    });
-    const chained = currentLock.then(() => nextLock);
-    this.locks.set(filepath, chained);
-    await currentLock;
-    try {
-      return await fn();
-    } finally {
-      release();
-      if (this.locks.get(filepath) === chained) this.locks.delete(filepath);
-    }
-  }
-};
-var FileTime;
-((FileTime2) => {
-  function svc(context) {
-    if (context.fileTime) return context.fileTime;
-    return context.fileTime;
-  }
-  function state(context) {
-    const s = svc(context);
-    return { read: s.readTimes, locks: s.locks };
-  }
-  FileTime2.state = state;
-  function read(context, sessionID, file) {
-    svc(context).read(sessionID, file);
-  }
-  FileTime2.read = read;
-  function get(context, sessionID, file) {
-    return svc(context).get(sessionID, file);
-  }
-  FileTime2.get = get;
-  async function withLock(context, filepath, fn) {
-    return svc(context).withLock(filepath, fn);
-  }
-  FileTime2.withLock = withLock;
-  async function assert(context, sessionID, filepath) {
-    return svc(context).assert(context, sessionID, filepath);
-  }
-  FileTime2.assert = assert;
-})(FileTime || (FileTime = {}));
-var Project;
-((Project2) => {
-  Project2.Info = zod_default.object({
-    id: ProjectID.zod,
-    worktree: zod_default.string(),
-    vcs: zod_default.literal("git").optional(),
-    name: zod_default.string().optional(),
-    icon: zod_default.object({
-      url: zod_default.string().optional(),
-      override: zod_default.string().optional(),
-      color: zod_default.string().optional()
-    }).optional(),
-    commands: zod_default.object({
-      start: zod_default.string().optional().describe("Startup script to run when creating a new workspace (worktree)")
-    }).optional(),
-    time: zod_default.object({
-      created: zod_default.number(),
-      updated: zod_default.number(),
-      initialized: zod_default.number().optional()
-    }),
-    sandboxes: zod_default.array(zod_default.string())
-  }).meta({ ref: "Project" });
-  function fromRow(row) {
-    const icon = row.icon_url || row.icon_color ? { url: row.icon_url ?? void 0, color: row.icon_color ?? void 0 } : void 0;
-    return {
-      id: ProjectID.make(row.id),
-      worktree: row.worktree,
-      vcs: row.vcs ? Project2.Info.shape.vcs.parse(row.vcs) : void 0,
-      name: row.name ?? void 0,
-      icon,
-      time: {
-        created: row.time_created,
-        updated: row.time_updated,
-        initialized: row.time_initialized ?? void 0
-      },
-      sandboxes: row.sandboxes,
-      commands: row.commands ?? void 0
-    };
-  }
-  Project2.fromRow = fromRow;
-  function setInitialized(context, id) {
-    context.db.update("project", { op: "eq", field: "id", value: id }, { time_initialized: Date.now() });
-  }
-  Project2.setInitialized = setInitialized;
-  function list(context) {
-    return context.db.findMany("project").map((row) => fromRow(row));
-  }
-  Project2.list = list;
-  function get(context, id) {
-    const row = context.db.findOne("project", { op: "eq", field: "id", value: id });
-    if (!row) return void 0;
-    return fromRow(row);
-  }
-  Project2.get = get;
-  async function sandboxes(context, id) {
-    const row = context.db.findOne("project", { op: "eq", field: "id", value: id });
-    if (!row) return [];
-    const data = fromRow(row);
-    const valid = [];
-    for (const dir of data.sandboxes) {
-      const s = await context.fs.stat(dir);
-      if (s?.isDirectory) valid.push(dir);
-    }
-    return valid;
-  }
-  Project2.sandboxes = sandboxes;
-})(Project || (Project = {}));
-var SessionTable = sqliteTable(
-  "session",
-  {
-    id: text().$type().primaryKey(),
-    project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
-    workspace_id: text().$type(),
-    parent_id: text().$type(),
-    slug: text().notNull(),
-    directory: text().notNull(),
-    title: text().notNull(),
-    version: text().notNull(),
-    share_url: text(),
-    summary_additions: integer(),
-    summary_deletions: integer(),
-    summary_files: integer(),
-    summary_diffs: text({ mode: "json" }).$type(),
-    revert: text({ mode: "json" }).$type(),
-    ...Timestamps,
-    time_compacting: integer(),
-    time_archived: integer()
-  },
-  (table) => [
-    index("session_project_idx").on(table.project_id),
-    index("session_workspace_idx").on(table.workspace_id),
-    index("session_parent_idx").on(table.parent_id)
-  ]
-);
-var MessageTable = sqliteTable(
-  "message",
-  {
-    id: text().$type().primaryKey(),
-    session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
-    ...Timestamps,
-    data: text({ mode: "json" }).notNull().$type()
-  },
-  (table) => [index("message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id)]
-);
-var PartTable = sqliteTable(
-  "part",
-  {
-    id: text().$type().primaryKey(),
-    message_id: text().$type().notNull().references(() => MessageTable.id, { onDelete: "cascade" }),
-    session_id: text().$type().notNull(),
-    ...Timestamps,
-    data: text({ mode: "json" }).notNull().$type()
-  },
-  (table) => [
-    index("part_message_id_id_idx").on(table.message_id, table.id),
-    index("part_session_idx").on(table.session_id)
-  ]
-);
-var TodoTable = sqliteTable(
-  "todo",
-  {
-    session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
-    content: text().notNull(),
-    status: text().notNull(),
-    priority: text().notNull(),
-    position: integer().notNull(),
-    ...Timestamps
-  },
-  (table) => [
-    primaryKey({ columns: [table.session_id, table.position] }),
-    index("todo_session_idx").on(table.session_id)
-  ]
-);
-var NamedError = class _NamedError extends Error {
-  static create(name, data) {
-    const schema = zod_default.object({
-      name: zod_default.literal(name),
-      data
-    }).meta({
-      ref: name
-    });
-    const result = class extends _NamedError {
-      constructor(data2, options) {
-        super(name, options);
-        this.data = data2;
-        this.name = name;
-      }
-      static Schema = schema;
-      name = name;
-      static isInstance(input) {
-        return typeof input === "object" && "name" in input && input.name === name;
-      }
-      schema() {
-        return schema;
-      }
-      toObject() {
-        return {
-          name,
-          data: this.data
-        };
-      }
-    };
-    Object.defineProperty(result, "name", { value: name });
-    return result;
-  }
-  static Unknown = _NamedError.create(
-    "UnknownError",
-    zod_default.object({
-      message: zod_default.string()
-    })
-  );
-};
-var Lock;
-((Lock2) => {
-  const locks = /* @__PURE__ */ new Map();
-  function get(key) {
-    if (!locks.has(key)) {
-      locks.set(key, {
-        readers: 0,
-        writer: false,
-        waitingReaders: [],
-        waitingWriters: []
-      });
-    }
-    return locks.get(key);
-  }
-  function process2(key) {
-    const lock = locks.get(key);
-    if (!lock || lock.writer || lock.readers > 0) return;
-    if (lock.waitingWriters.length > 0) {
-      const nextWriter = lock.waitingWriters.shift();
-      nextWriter();
-      return;
-    }
-    while (lock.waitingReaders.length > 0) {
-      const nextReader = lock.waitingReaders.shift();
-      nextReader();
-    }
-    if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
-      locks.delete(key);
-    }
-  }
-  async function read(key) {
-    const lock = get(key);
-    return new Promise((resolve2) => {
-      if (!lock.writer && lock.waitingWriters.length === 0) {
-        lock.readers++;
-        resolve2({
-          [Symbol.dispose]: () => {
-            lock.readers--;
-            process2(key);
-          }
-        });
-      } else {
-        lock.waitingReaders.push(() => {
-          lock.readers++;
-          resolve2({
-            [Symbol.dispose]: () => {
-              lock.readers--;
-              process2(key);
-            }
-          });
-        });
-      }
-    });
-  }
-  Lock2.read = read;
-  async function write(key) {
-    const lock = get(key);
-    return new Promise((resolve2) => {
-      if (!lock.writer && lock.readers === 0) {
-        lock.writer = true;
-        resolve2({
-          [Symbol.dispose]: () => {
-            lock.writer = false;
-            process2(key);
-          }
-        });
-      } else {
-        lock.waitingWriters.push(() => {
-          lock.writer = true;
-          resolve2({
-            [Symbol.dispose]: () => {
-              lock.writer = false;
-              process2(key);
-            }
-          });
-        });
-      }
-    });
-  }
-  Lock2.write = write;
-})(Lock || (Lock = {}));
-var Timestamps = {
-  time_created: integer().notNull().$default(() => Date.now()),
-  time_updated: integer().notNull().$onUpdate(() => Date.now())
-};
-var NotFoundError = NamedError.create(
-  "NotFoundError",
-  zod_default.object({
-    message: zod_default.string()
-  })
-);
-var Database;
-((Database2) => {
-  const INITIAL_MIGRATION = `-- project table
-CREATE TABLE IF NOT EXISTS "project" (
-  "id" TEXT PRIMARY KEY NOT NULL,
-  "worktree" TEXT NOT NULL,
-  "vcs" TEXT,
-  "name" TEXT,
-  "icon_url" TEXT,
-  "icon_color" TEXT,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_initialized" INTEGER,
-  "sandboxes" TEXT NOT NULL DEFAULT '[]',
-  "commands" TEXT
-);
-
--- session table
-CREATE TABLE IF NOT EXISTS "session" (
-  "id" TEXT PRIMARY KEY NOT NULL,
-  "project_id" TEXT NOT NULL REFERENCES "project"("id") ON DELETE CASCADE,
-  "workspace_id" TEXT,
-  "parent_id" TEXT,
-  "slug" TEXT NOT NULL,
-  "directory" TEXT NOT NULL,
-  "title" TEXT NOT NULL,
-  "version" TEXT NOT NULL,
-  "share_url" TEXT,
-  "summary_additions" INTEGER,
-  "summary_deletions" INTEGER,
-  "summary_files" INTEGER,
-  "summary_diffs" TEXT,
-  "revert" TEXT,
-  "permission" TEXT,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_compacting" INTEGER,
-  "time_archived" INTEGER
-);
-CREATE INDEX IF NOT EXISTS "session_project_idx" ON "session"("project_id");
-CREATE INDEX IF NOT EXISTS "session_workspace_idx" ON "session"("workspace_id");
-CREATE INDEX IF NOT EXISTS "session_parent_idx" ON "session"("parent_id");
-
--- message table
-CREATE TABLE IF NOT EXISTS "message" (
-  "id" TEXT PRIMARY KEY NOT NULL,
-  "session_id" TEXT NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "data" TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS "message_session_time_created_id_idx" ON "message"("session_id", "time_created", "id");
-
--- part table
-CREATE TABLE IF NOT EXISTS "part" (
-  "id" TEXT PRIMARY KEY NOT NULL,
-  "message_id" TEXT NOT NULL REFERENCES "message"("id") ON DELETE CASCADE,
-  "session_id" TEXT NOT NULL,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "data" TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS "part_message_id_id_idx" ON "part"("message_id", "id");
-CREATE INDEX IF NOT EXISTS "part_session_idx" ON "part"("session_id");
-
--- todo table
-CREATE TABLE IF NOT EXISTS "todo" (
-  "session_id" TEXT NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
-  "content" TEXT NOT NULL,
-  "status" TEXT NOT NULL,
-  "priority" TEXT NOT NULL,
-  "position" INTEGER NOT NULL,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  PRIMARY KEY ("session_id", "position")
-);
-CREATE INDEX IF NOT EXISTS "todo_session_idx" ON "todo"("session_id");
-
--- permission table
-CREATE TABLE IF NOT EXISTS "permission" (
-  "project_id" TEXT PRIMARY KEY NOT NULL REFERENCES "project"("id") ON DELETE CASCADE,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "data" TEXT NOT NULL
-);
-
--- session_share table
-CREATE TABLE IF NOT EXISTS "session_share" (
-  "session_id" TEXT PRIMARY KEY NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
-  "id" TEXT NOT NULL,
-  "secret" TEXT NOT NULL,
-  "url" TEXT NOT NULL,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-);
-
--- workspace table
-CREATE TABLE IF NOT EXISTS "workspace" (
-  "id" TEXT PRIMARY KEY NOT NULL,
-  "type" TEXT NOT NULL,
-  "branch" TEXT,
-  "name" TEXT,
-  "directory" TEXT,
-  "extra" TEXT,
-  "project_id" TEXT NOT NULL REFERENCES "project"("id") ON DELETE CASCADE
-);
-
--- account table
-CREATE TABLE IF NOT EXISTS "account" (
-  "id" TEXT PRIMARY KEY NOT NULL,
-  "email" TEXT NOT NULL,
-  "url" TEXT NOT NULL,
-  "access_token" TEXT NOT NULL,
-  "refresh_token" TEXT NOT NULL,
-  "token_expiry" INTEGER,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-);
-
--- account_state table
-CREATE TABLE IF NOT EXISTS "account_state" (
-  "id" INTEGER PRIMARY KEY,
-  "active_account_id" TEXT REFERENCES "account"("id") ON DELETE SET NULL,
-  "active_org_id" TEXT
-);
-
--- control_account table (legacy)
-CREATE TABLE IF NOT EXISTS "control_account" (
-  "email" TEXT NOT NULL,
-  "url" TEXT NOT NULL,
-  "access_token" TEXT NOT NULL,
-  "refresh_token" TEXT NOT NULL,
-  "token_expiry" INTEGER,
-  "active" INTEGER NOT NULL DEFAULT 0,
-  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-  PRIMARY KEY ("email", "url")
-);`;
-  function getMigrations() {
-    const entries = [
-      { sql: INITIAL_MIGRATION, timestamp: Date.UTC(2024, 0, 1), name: "20240101000000_initial" }
-    ];
-    if (Flag.OPENCODE_SKIP_MIGRATIONS) {
-      for (const item of entries) {
-        item.sql = "select 1;";
-      }
-    }
-    return entries;
-  }
-  Database2.getMigrations = getMigrations;
-})(Database || (Database = {}));
-var Storage;
-((Storage2) => {
-  function getLog(context) {
-    return context.log.create({ service: "storage" });
-  }
-  Storage2.NotFoundError = NamedError.create(
-    "NotFoundError",
-    zod_default.object({
-      message: zod_default.string()
-    })
-  );
-  const MIGRATIONS = [
-    async (context, dir) => {
-      const project = resolve(dir, "../project");
-      if (!await context.fs.isDir(project)) return;
-      const projectDirs = await context.fs.glob("*", {
-        cwd: project,
-        nodir: false
-      });
-      for (const projectDir of projectDirs) {
-        const fullPath = join(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 context.fs.glob("storage/session/message/*/*.json", {
-            cwd: join(project, projectDir),
-            absolute: true
-          })) {
-            const json = await context.fs.readJson(msgFile);
-            worktree = json.path?.root;
-            if (worktree) break;
-          }
-          if (!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 context.fs.writeJson(join(dir, "project", projectID + ".json"), {
-            id,
-            vcs: "git",
-            worktree,
-            time: {
-              created: Date.now(),
-              initialized: Date.now()
-            }
-          });
-          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));
-            getLog(context).info("copying", {
-              sessionFile,
-              dest
-            });
-            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));
-              getLog(context).info("copying", {
-                msgFile,
-                dest: dest2
-              });
-              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 context.fs.readJson(partFile);
-                getLog(context).info("copying", {
-                  partFile,
-                  dest: dest3
-                });
-                await context.fs.writeJson(dest3, part);
-              }
-            }
-          }
-        }
-      }
-    },
-    async (context, dir) => {
-      for (const item of await context.fs.glob("session/*/*.json", {
-        cwd: dir,
-        absolute: true
-      })) {
-        const session = await context.fs.readJson(item);
-        if (!session.projectID) continue;
-        if (!session.summary?.diffs) continue;
-        const { diffs } = session.summary;
-        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),
-            deletions: diffs.reduce((sum, x) => sum + x.deletions, 0)
-          }
-        });
-      }
-    }
-  ];
-  async function getDir(context) {
-    const dir = join(context.dataPath, "storage");
-    const migration = await context.fs.readJson(join(dir, "migration")).then((x) => parseInt(x)).catch(() => 0);
-    for (let index2 = migration; index2 < MIGRATIONS.length; index2++) {
-      getLog(context).info("running migration", { index: index2 });
-      const migrationFn = MIGRATIONS[index2];
-      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;
-  }
-  async function remove(context, key) {
-    const dir = await getDir(context);
-    const target = join(dir, ...key) + ".json";
-    return withErrorHandling(async () => {
-      await fs4.unlink(target).catch(() => {
-      });
-    });
-  }
-  Storage2.remove = remove;
-  async function read(context, key) {
-    const dir = await getDir(context);
-    const target = join(dir, ...key) + ".json";
-    return withErrorHandling(async () => {
-      var _stack = [];
-      try {
-        const _ = __using(_stack, await Lock.read(target));
-        const result = await context.fs.readJson(target);
-        return result;
-      } catch (_2) {
-        var _error = _2, _hasError = true;
-      } finally {
-        __callDispose(_stack, _error, _hasError);
-      }
-    });
-  }
-  Storage2.read = read;
-  async function update(context, key, fn) {
-    const dir = await getDir(context);
-    const target = join(dir, ...key) + ".json";
-    return withErrorHandling(async () => {
-      var _stack = [];
-      try {
-        const _ = __using(_stack, await Lock.write(target));
-        const content = await context.fs.readJson(target);
-        fn(content);
-        await context.fs.writeJson(target, content);
-        return content;
-      } catch (_2) {
-        var _error = _2, _hasError = true;
-      } finally {
-        __callDispose(_stack, _error, _hasError);
-      }
-    });
-  }
-  Storage2.update = update;
-  async function write(context, key, content) {
-    const dir = await getDir(context);
-    const target = join(dir, ...key) + ".json";
-    return withErrorHandling(async () => {
-      var _stack = [];
-      try {
-        const _ = __using(_stack, await Lock.write(target));
-        await context.fs.writeJson(target, content);
-      } catch (_2) {
-        var _error = _2, _hasError = true;
-      } finally {
-        __callDispose(_stack, _error, _hasError);
-      }
-    });
-  }
-  Storage2.write = write;
-  async function withErrorHandling(body) {
-    return body().catch((e) => {
-      if (!(e instanceof Error)) throw e;
-      const errnoException = e;
-      if (errnoException.code === "ENOENT") {
-        throw new Storage2.NotFoundError({ message: `Resource not found: ${errnoException.path}` });
-      }
-      throw e;
-    });
-  }
-  async function list(context, prefix) {
-    const dir = await getDir(context);
-    try {
-      const result = await context.fs.glob("**/*", {
-        cwd: join(dir, ...prefix),
-        nodir: true
-      }).then((results) => results.map((x) => [...prefix, ...x.slice(0, -5).split(sep2)]));
-      result.sort();
-      return result;
-    } catch {
-      return [];
-    }
-  }
-  Storage2.list = list;
-})(Storage || (Storage = {}));
-
-export {
-  consoleLogger,
-  SqliteNoSqlDb,
-  NodeFS,
-  NodeSearchProvider,
-  SqlJsStorage,
-  join,
-  dirname,
-  basename,
-  extname,
-  isAbsolute,
-  relative,
-  resolve,
-  Flag,
-  ProjectID,
-  ProjectTable,
-  FileTimeService,
-  SessionTable,
-  MessageTable,
-  PartTable,
-  TodoTable,
-  NamedError,
-  Timestamps,
-  NotFoundError,
-  Database,
-  Storage
-};