@rekal/mem 0.0.0

package/dist/db-BMh1OP4b.mjs

@@ -0,0 +1,294 @@
+import { t as openDatabase } from "./runtime.node-DlQPaGrV.mjs";
+//#region src/db.ts
+const SEARCH_LIMIT = 20;
+const STOPWORD_THRESHOLD = .3;
+const STOPWORD_MIN_DOCS = 10;
+const STOPWORD_LIMIT = 1e3;
+function hasEmbedding(c) {
+	return Array.isArray(c.embedding);
+}
+function assertEmbeddings(chunks) {
+	for (const c of chunks) if (!hasEmbedding(c)) throw new Error(`Chunk is missing embedding: ${JSON.stringify(c)}`);
+}
+var Db = class Db {
+	#db;
+	#vec;
+	constructor(db) {
+		this.#db = db;
+		this.init();
+	}
+	static async load(dbPath) {
+		return new Db(await openDatabase(dbPath));
+	}
+	init() {
+		this.#db.run("PRAGMA journal_mode = WAL");
+		this.#db.run("PRAGMA foreign_keys = ON");
+		this.#db.run("PRAGMA busy_timeout = 5000");
+		this.#db.run(`
+      CREATE TABLE IF NOT EXISTS docs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        path TEXT NOT NULL UNIQUE,
+        hash TEXT NOT NULL,
+        vec_hash TEXT,
+        body TEXT NOT NULL DEFAULT '',
+        description TEXT NOT NULL DEFAULT '',
+        title TEXT NOT NULL DEFAULT '',
+        tags TEXT NOT NULL DEFAULT '',
+        entities TEXT NOT NULL DEFAULT '',
+        updated_at TEXT NOT NULL,
+        synced_at TEXT,
+        deadline REAL
+      )
+    `);
+		this.#db.run(`CREATE INDEX IF NOT EXISTS idx_docs_path ON docs(path)`);
+		this.#db.run(`CREATE INDEX IF NOT EXISTS idx_docs_hash ON docs(hash)`);
+		this.#db.run(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS docs_fts USING fts5(
+        entities, tags, description, title, body,
+        content='docs',
+        content_rowid='id',
+        tokenize='porter unicode61'
+      )
+    `);
+		this.#db.run(`
+      CREATE TRIGGER IF NOT EXISTS docs_fts_insert AFTER INSERT ON docs BEGIN
+        INSERT INTO docs_fts(rowid, entities, tags, description, title, body)
+        VALUES (new.id, new.entities, new.tags, new.description, new.title, new.body);
+      END
+    `);
+		this.#db.run(`
+      CREATE TRIGGER IF NOT EXISTS docs_fts_delete AFTER DELETE ON docs BEGIN
+        INSERT INTO docs_fts(docs_fts, rowid, entities, tags, description, title, body)
+        VALUES ('delete', old.id, old.entities, old.tags, old.description, old.title, old.body);
+      END
+    `);
+		this.#db.run(`
+      CREATE TRIGGER IF NOT EXISTS docs_fts_update AFTER UPDATE ON docs
+      WHEN old.body != new.body
+        OR old.title != new.title
+        OR old.description != new.description
+        OR old.tags != new.tags
+        OR old.entities != new.entities
+      BEGIN
+        INSERT INTO docs_fts(docs_fts, rowid, entities, tags, description, title, body)
+        VALUES ('delete', old.id, old.entities, old.tags, old.description, old.title, old.body);
+        INSERT INTO docs_fts(rowid, entities, tags, description, title, body)
+        VALUES (new.id, new.entities, new.tags, new.description, new.title, new.body);
+      END
+    `);
+		this.#db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS docs_vocab USING fts5vocab('docs_fts', 'row')`);
+		this.#db.run(`
+      CREATE TABLE IF NOT EXISTS meta (
+        key TEXT PRIMARY KEY,
+        value TEXT
+      )
+    `);
+		this.#db.run(`
+      CREATE TABLE IF NOT EXISTS cache (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        accessed_at TEXT NOT NULL
+      )
+    `);
+	}
+	reset() {
+		this.#db.run(`DROP TRIGGER IF EXISTS docs_fts_insert`);
+		this.#db.run(`DROP TRIGGER IF EXISTS docs_fts_delete`);
+		this.#db.run(`DROP TRIGGER IF EXISTS docs_fts_update`);
+		this.#db.run(`DROP TABLE IF EXISTS docs_fts`);
+		this.#db.run(`DROP TABLE IF EXISTS vec`);
+		this.#db.run(`DROP TABLE IF EXISTS cache`);
+		this.#db.run(`DROP TABLE IF EXISTS docs`);
+		this.#db.run(`DROP TABLE IF EXISTS meta`);
+		this.#db.run(`VACUUM`);
+		this.#vec = { exists: false };
+		this.init();
+	}
+	initVec(dims) {
+		if (this.vec.init) return;
+		const existingDims = this.vec.dims;
+		if (existingDims && existingDims !== dims) throw new Error(`Vector dimension mismatch: existing **vec** has \`${existingDims}\` dims, but got \`${dims}\`.\nRun \`rekal reset\` and \`rekal sync\` to recreate with the correct dimensions.`);
+		this.#db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS vec USING vec0(
+        doc_id INTEGER NOT NULL,
+        seq INTEGER NOT NULL,
+        +path TEXT NOT NULL,
+        embedding float[${dims}] distance_metric=cosine
+      )`);
+		this.#vec = {
+			dims,
+			exists: true,
+			init: true
+		};
+	}
+	getDoc(from) {
+		const field = typeof from === "number" ? "id" : "path";
+		return this.#db.query(`SELECT * FROM docs WHERE ${field} = ?`).get(from);
+	}
+	getDocs(from) {
+		let ret;
+		if (!from) ret = this.#db.query(`SELECT * FROM docs`).all();
+		else {
+			const field = typeof from[0] === "number" ? "id" : "path";
+			const placeholders = from.map(() => "?").join(",");
+			ret = this.#db.query(`SELECT * FROM docs WHERE ${field} IN (${placeholders})`).all(...from);
+		}
+		return new Map(ret.map((row) => [row.id, row]));
+	}
+	addDoc(row) {
+		return this.#db.query(`INSERT INTO docs (path, hash, body, description, title, tags, entities, updated_at, synced_at)
+        VALUES($path, $hash, $body, $description, $title, $tags, $entities, $updated_at, $synced_at)
+        ON CONFLICT(path) DO UPDATE SET
+          hash = excluded.hash,
+          body = excluded.body,
+          description = excluded.description,
+          title = excluded.title,
+          tags = excluded.tags,
+          entities = excluded.entities,
+          updated_at = excluded.updated_at,
+          synced_at = excluded.synced_at
+        RETURNING id`).get(row).id;
+	}
+	deleteDoc(id, tables = {}) {
+		if (tables.vec) this.deleteEmbeddings(id);
+		if (tables.docs) this.#db.query(`DELETE FROM docs WHERE id = ?`).run(id);
+	}
+	get vec() {
+		if (this.#vec) return this.#vec;
+		const row = this.#db.query(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'vec'`).get();
+		const match = row?.sql.match(/embedding float\[(\d+)\]/);
+		this.#vec = {
+			dims: match ? parseInt(match[1]) : void 0,
+			exists: !!row?.sql
+		};
+		return this.#vec;
+	}
+	getStatus() {
+		const count = (sql) => this.#db.query(sql).get().n;
+		return {
+			cache: count(`SELECT count(*) as n FROM cache`),
+			dbSize: this.#db.query(`SELECT page_count * page_size as n FROM pragma_page_count, pragma_page_size`).get().n,
+			docs: count(`SELECT count(*) as n FROM docs`),
+			docsWithDescription: count(`SELECT count(*) as n FROM docs WHERE description != ''`),
+			lastSync: this.#db.query(`SELECT max(synced_at) as t FROM docs`).get().t,
+			unembedded: count(`SELECT count(*) as n FROM docs WHERE vec_hash IS NULL OR vec_hash != hash`),
+			vecDims: this.vec.dims,
+			vecs: this.vec.exists ? count(`SELECT count(*) as n FROM vec`) : 0,
+			vocabTerms: count(`SELECT count(DISTINCT term) as n FROM docs_vocab`)
+		};
+	}
+	transaction(fn) {
+		return this.#db.transaction(fn);
+	}
+	getUnembeddedDocs() {
+		return this.#db.query(`SELECT * FROM docs
+        WHERE vec_hash IS NULL OR vec_hash != hash
+        ORDER BY path`).all();
+	}
+	touchDoc(id) {
+		this.#db.query(`UPDATE docs SET synced_at = ? WHERE id = ?`).run((/* @__PURE__ */ new Date()).toISOString(), id);
+	}
+	markEmbedded(id, docHash) {
+		this.#db.query(`UPDATE docs SET vec_hash = ? WHERE id = ?`).run(docHash, id);
+	}
+	/** Delete docs not seen since the given sync timestamp, optionally scoped to a path prefix. */
+	deleteStaleDocs(syncedBefore, prefix) {
+		let query = `SELECT id FROM docs WHERE synced_at IS NULL OR synced_at < ?`;
+		const params = [syncedBefore];
+		if (prefix) {
+			query += ` AND path LIKE ? || '%'`;
+			params.push(prefix);
+		}
+		const stale = this.#db.query(query).all(...params);
+		for (const { id } of stale) this.deleteDoc(id, {
+			docs: true,
+			vec: true
+		});
+		return stale.length;
+	}
+	/** Scoped FTS search: only match docs whose path starts with one of the given prefixes */
+	searchFts(query, opts) {
+		if (opts?.scope?.length === 0) return [];
+		const scope = opts?.scope ?? [];
+		const scopeQuery = scope.length === 0 ? "" : `AND (${scope.map(() => `d.path LIKE ? || '%'`).join(" OR ")})`;
+		return this.#db.query(`SELECT f.rowid, bm25(docs_fts, 10, 8, 5, 3, 1) as score
+        FROM docs_fts f
+        ${scope.length > 0 ? "JOIN docs d ON d.id = f.rowid" : ""}
+        WHERE docs_fts MATCH ?
+          ${scopeQuery}
+        ORDER BY score
+        LIMIT ?`).all(query, ...scope, opts?.limit ?? SEARCH_LIMIT);
+	}
+	/** * Gets weights for high-frequency terms.
+	* Note: Truly common words will result in an IDF of 0 or less.
+	*/
+	getStopWords() {
+		const totalDocs = this.#db.query("SELECT count(*) as n FROM docs").get()?.n ?? 0;
+		if (totalDocs === 0) return /* @__PURE__ */ new Map();
+		const rows = this.#db.query(`SELECT v.term, v.doc 
+       FROM docs_vocab v
+       WHERE v.doc > ? AND v.doc > ?
+       ORDER BY v.doc DESC
+       LIMIT ?`).all(totalDocs * STOPWORD_THRESHOLD, STOPWORD_MIN_DOCS, STOPWORD_LIMIT);
+		return new Map(rows.map((r) => {
+			const idf = Math.log((totalDocs - r.doc + .5) / (r.doc + .5));
+			return [r.term, Math.max(0, idf)];
+		}));
+	}
+	getWeights(terms) {
+		if (terms.length === 0) return [];
+		const total = this.#db.query(`SELECT count(*) as n FROM docs`).get().n;
+		const placeholders = terms.map(() => "?").join(",");
+		const rows = this.#db.query(`SELECT term, doc FROM docs_vocab WHERE term IN (${placeholders})`).all(...terms);
+		const df = new Map(rows.map((r) => [r.term, r.doc]));
+		return terms.map((t) => Math.log((total - (df.get(t) ?? 0) + .5) / ((df.get(t) ?? 0) + .5)));
+	}
+	/** Insert embeddings into the vec table */
+	insertEmbeddings(chunks) {
+		assertEmbeddings(chunks);
+		if (chunks.length === 0) return;
+		this.initVec(chunks[0].embedding.length);
+		const stmt = this.#db.query(`INSERT INTO vec(doc_id, seq, path, embedding) VALUES (?, ?, ?, ?)`);
+		for (const chunk of chunks) stmt.run(chunk.doc_id, chunk.seq, chunk.doc.path, JSON.stringify(chunk.embedding));
+	}
+	/** Delete all vec entries for a doc */
+	deleteEmbeddings(docId) {
+		if (this.vec.exists) this.#db.query(`DELETE FROM vec WHERE doc_id = ?`).run(docId);
+	}
+	/** Global KNN search, returns top results across all docs */
+	searchVec(embedding, opts) {
+		if (!this.vec.exists) return [];
+		const limit = opts?.limit ?? SEARCH_LIMIT;
+		return this.#db.query(`SELECT doc_id, seq, path, distance, (1 - distance/2) as score
+        FROM vec
+        WHERE embedding MATCH ?
+          AND k = ?
+        ORDER BY distance`).all(JSON.stringify(embedding), limit);
+	}
+	setDeadline(docId, deadline) {
+		this.#db.query(`UPDATE docs SET deadline = ? WHERE id = ?`).run(deadline, docId);
+	}
+	getMeta(key) {
+		return this.#db.query(`SELECT value FROM meta WHERE key = ?`).get(key)?.value;
+	}
+	setMeta(key, value) {
+		this.#db.query(`INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?`).run(key, value, value);
+	}
+	cacheGet(key) {
+		const row = this.#db.query(`SELECT value FROM cache WHERE key = ?`).get(key);
+		if (!row) return;
+		this.#db.query(`UPDATE cache SET accessed_at = ? WHERE key = ?`).run((/* @__PURE__ */ new Date()).toISOString(), key);
+		return JSON.parse(row.value);
+	}
+	cacheSet(key, value) {
+		this.#db.query(`INSERT INTO cache (key, value, accessed_at) VALUES (?, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value, accessed_at = excluded.accessed_at`).run(key, JSON.stringify(value), (/* @__PURE__ */ new Date()).toISOString());
+		return value;
+	}
+	cachePrune(maxEntries = 1e4) {
+		this.#db.query(`DELETE FROM cache WHERE key NOT IN (
+          SELECT key FROM cache ORDER BY accessed_at DESC LIMIT ?
+        )`).run(maxEntries);
+	}
+};
+//#endregion
+export { Db };

package/dist/doc-DnYN4jAU.mjs

@@ -0,0 +1,116 @@
+import { t as astat } from "./fs-DMp26Byo.mjs";
+import { t as hash } from "./util-DNyrmcA3.mjs";
+import { a as parseMarkdown } from "./progress-B1JdNapX.mjs";
+import { r as normUri } from "./uri-CehXVDGB.mjs";
+import { readFile } from "node:fs/promises";
+import { basename, join, resolve } from "pathe";
+//#region src/doc.ts
+const INDEX = "index.md";
+const MAX_DESC_LENGTH = 120;
+var Doc = class Doc {
+	#isDir = false;
+	#name = "";
+	hash = "";
+	updated = /* @__PURE__ */ new Date(0);
+	headings = [];
+	parsed = {
+		body: "",
+		bodyOffset: 0,
+		frontmatter: {},
+		sections: [],
+		text: ""
+	};
+	constructor(uri, path) {
+		this.uri = uri;
+		this.path = path;
+		this.path = resolve(path);
+		this.#name = basename(this.path, ".md");
+	}
+	/** Full original markdown text, including frontmatter. */
+	get text() {
+		return this.parsed.text;
+	}
+	/** Markdown body without frontmatter. */
+	get body() {
+		return this.parsed.body;
+	}
+	/** Parsed frontmatter as an object. */
+	get fm() {
+		return this.parsed.frontmatter;
+	}
+	/** Name of the doc, derived from the file or folder name, without extension */
+	get name() {
+		return this.#name;
+	}
+	get $description() {
+		const ret = this.fm.description?.trim();
+		return ret?.length ? ret : void 0;
+	}
+	/** Desc from frontmatter or packed from headings. */
+	get description() {
+		const desc = this.$description;
+		if (desc || this.headings.length === 0) return desc;
+		const headings = this.headings.map((h) => ({ ...h }));
+		const minLevel = Math.min(...headings.map((h) => h.level));
+		const maxLevel = Math.max(...headings.map((h) => h.level));
+		let chars = 0;
+		for (let level = minLevel; level <= maxLevel; level++) for (const h of headings) {
+			if (h.level !== level) continue;
+			if (chars !== 0 && chars + h.text.length > MAX_DESC_LENGTH) continue;
+			h.used = true;
+			chars += h.text.length;
+		}
+		return headings.filter((h) => h.used).map((h) => h.text).join(", ").trim();
+	}
+	/** Title from fontmatter or first heading */
+	get $title() {
+		const title = this.fm.title;
+		if (typeof title === "string" && title.trim().length > 0) return title.trim();
+		return this.headings[0]?.text;
+	}
+	/** `$title` if it doesn't contain the name, otherwise `name - $title` */
+	get title() {
+		const title = this.$title;
+		if (!(title ?? "").length) return this.name;
+		return title?.toLowerCase().includes(this.name.toLowerCase()) ? title : `${this.name} - ${title}`;
+	}
+	get tags() {
+		return this.fm.tags ?? [];
+	}
+	get entities() {
+		return this.fm.entities ?? [];
+	}
+	get isDir() {
+		return this.#isDir;
+	}
+	async load() {
+		if (basename(this.path) === INDEX) throw new Error(`Doc path cannot end with \`${INDEX}\`:\n\`${this.path}\``);
+		let s = await astat(this.path);
+		let mdPath = this.path;
+		if (s?.isDirectory()) {
+			this.#isDir = true;
+			mdPath = join(this.path, INDEX);
+			s = await astat(mdPath);
+		}
+		if (!s && !this.#isDir) return;
+		this.uri = normUri(this.uri, this.isDir);
+		const text = (s ? await readFile(mdPath, "utf8") : "").replace(/\r\n/g, "\n");
+		this.updated = s?.mtime ?? /* @__PURE__ */ new Date(0);
+		this.hash = hash(text);
+		this.parsed = parseMarkdown(text);
+		this.headings = this.parsed.sections.filter((section) => section.level > 0 && section.heading.trim().length > 0).map((section) => ({
+			level: section.level,
+			text: section.heading
+		}));
+		return this;
+	}
+	static async load(uri, path) {
+		const e = typeof uri === "string" ? {
+			path,
+			uri
+		} : uri;
+		return e.path ? await new Doc(e.uri, e.path).load() : void 0;
+	}
+};
+//#endregion
+export { Doc as t };

package/dist/embed-rUMZxqed.mjs

@@ -0,0 +1,100 @@
+import { n as chunkMarkdown, t as Progress } from "./progress-B1JdNapX.mjs";
+import { n as parseModelUri, r as resolveModel, t as loadModel } from "./models-DFQSgBNr.mjs";
+import { availableParallelism } from "node:os";
+//#region src/embed/base.ts
+const defaults = {
+	batchSize: 0,
+	maxDims: 512,
+	maxTokens: 512,
+	useGpu: true
+};
+const backend_defaults = {
+	llama: {},
+	openai: { batchSize: 50 },
+	transformers: {}
+};
+function isChunk(input) {
+	return typeof input?.prompt === "string";
+}
+var Embedder = class {
+	#loading;
+	opts;
+	model;
+	status = new Progress("embedder");
+	#backend;
+	constructor(ctx) {
+		this.ctx = ctx;
+		const opts = ctx.opts.embedder ?? {};
+		this.model = resolveModel(opts.model);
+		const { backend } = parseModelUri(this.model.uri);
+		const base = {
+			...defaults,
+			...backend_defaults[backend]
+		};
+		this.opts = {
+			threads: Math.max(1, opts.threads ?? Math.min(8, availableParallelism() - 2)),
+			...base,
+			...opts,
+			model: this.model
+		};
+	}
+	info() {
+		return parseModelUri(this.model.uri);
+	}
+	async backend() {
+		this.#loading ??= (async () => {
+			this.status.name = `Loading model \`${this.model.uri}\``;
+			const t = setTimeout(() => {
+				this.opts.onProgress?.(this.status);
+			}, 500);
+			this.#backend = await loadModel({
+				logger: this.ctx,
+				opts: this.opts,
+				root: this.ctx.root,
+				status: this.status
+			});
+			clearTimeout(t);
+			this.opts.maxTokens = Math.min(this.opts.maxTokens, this.#backend.maxTokens);
+			this.opts.maxDims = Math.min(this.opts.maxDims, this.#backend.dims);
+			if (this.opts.batchSize === 0) this.opts.batchSize = this.#backend.device === "gpu" ? 50 : 1;
+			this.ctx.debug({
+				batchSize: this.opts.batchSize,
+				device: this.#backend.device,
+				threads: this.opts.threads,
+				useGpu: this.opts.useGpu
+			});
+			this.status.stop();
+			return this.#backend;
+		})();
+		return this.#backend ??= await this.#loading;
+	}
+	transform(input) {
+		if (isChunk(input)) return input.prompt;
+		const { prompt } = this.model;
+		return typeof input === "string" ? prompt.query(input) : prompt.document(input);
+	}
+	async embed(input) {
+		const single = !Array.isArray(input);
+		const todo = single ? [input] : input;
+		const ret = await (await this.backend()).embed(todo.map((item) => this.transform(item)));
+		return single ? ret[0] : ret;
+	}
+	async chunk(input) {
+		const backend = await this.backend();
+		const isQuery = typeof input === "string";
+		const fixed = this.transform(isQuery ? "" : {
+			text: "",
+			title: input.title
+		});
+		return chunkMarkdown(isQuery ? input : input.text, backend, this.opts.maxTokens - backend.toks(fixed)).map((text, seq) => ({
+			prompt: isQuery ? this.transform(text) : this.transform({
+				text,
+				title: input.title
+			}),
+			seq,
+			text
+		}));
+	}
+};
+//#endregion
+export { Embedder };

package/dist/fs-DMp26Byo.mjs

@@ -0,0 +1,32 @@
+import { existsSync, statSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { dirname, join, resolve } from "pathe";
+import { homedir } from "node:os";
+//#region src/fs.ts
+function sstat(path) {
+	try {
+		return statSync(path);
+	} catch {}
+}
+async function astat(path) {
+	return await stat(path).catch(() => void 0);
+}
+function findUp(root, name, stop) {
+	let current = resolve(root);
+	while (true) {
+		const check = join(current, name);
+		if (sstat(check)?.isFile()) return check;
+		if (stop && existsSync(join(current, stop))) return;
+		const next = dirname(current);
+		if (next === current) break;
+		current = next;
+	}
+}
+function normPath(...paths) {
+	return resolve(...paths.map((p) => p.replace(/^~(?=\/|\\|$)/, homedir())));
+}
+function gitRoot(path) {
+	return findUp(path, ".git");
+}
+//#endregion
+export { sstat as a, normPath as i, findUp as n, gitRoot as r, astat as t };

package/dist/glob.d.mts

@@ -0,0 +1,27 @@
+import { Dirent } from "node:fs";
+
+//#region src/glob.d.ts
+type GlobSort = (a: Dirent, b: Dirent) => number;
+declare const sorters: {
+  name: (a: Dirent<string>, b: Dirent<string>) => number;
+  none: () => number;
+  type: (a: Dirent<string>, b: Dirent<string>) => number;
+};
+type GlobOptions = {
+  cwd: string | string[];
+  glob?: string | string[];
+  follow: boolean;
+  hidden: boolean;
+  ignore: boolean;
+  type?: "file" | "directory";
+  empty: boolean;
+  depth: number;
+  ignoreFiles: string[];
+  exclude: string[];
+  onVisit?: (rel: string) => void;
+  onError?: (path: string, error: Error) => void;
+  sort?: GlobSort | keyof typeof sorters;
+};
+declare function glob(opts?: Partial<GlobOptions>): AsyncGenerator<string>;
+//#endregion
+export { GlobOptions, GlobSort, glob };

package/dist/glob.mjs

@@ -0,0 +1,132 @@
+import { a as sstat, i as normPath, n as findUp } from "./fs-DMp26Byo.mjs";
+import { n as toError } from "./util-DNyrmcA3.mjs";
+import { readFileSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join } from "pathe";
+//#region src/glob.ts
+const sorters = {
+	name: (a, b) => a.name.localeCompare(b.name),
+	none: () => 0,
+	type: (a, b) => {
+		if (a.isDirectory() && !b.isDirectory()) return -1;
+		if (!a.isDirectory() && b.isDirectory()) return 1;
+		return a.name.localeCompare(b.name);
+	}
+};
+const defaults = {
+	cwd: ".",
+	depth: Infinity,
+	empty: false,
+	exclude: [".git", "node_modules/"],
+	follow: false,
+	hidden: false,
+	ignore: true,
+	ignoreFiles: [".gitignore", ".ignore"],
+	sort: "name"
+};
+var IgnoreTree = class IgnoreTree {
+	parent;
+	constructor(ig, rel = "") {
+		this.ig = ig;
+		this.rel = rel;
+	}
+	extend(ig, rel) {
+		const child = new IgnoreTree(ig, rel);
+		child.parent = this;
+		return child;
+	}
+	ignores(rel) {
+		const test = this.ig.test(rel.slice(this.rel.length));
+		if (test.ignored) return true;
+		if (test.unignored) return false;
+		return this.parent?.ignores(rel) ?? false;
+	}
+};
+async function* glob(opts = {}) {
+	if (opts.depth && opts.depth < 1) return;
+	const { default: ignore } = await import("ignore");
+	const o = {
+		...defaults,
+		...opts
+	};
+	if (Array.isArray(o.cwd)) {
+		for (const cwd of o.cwd) yield* glob({
+			...o,
+			cwd
+		});
+		return;
+	}
+	const root = normPath(o.cwd);
+	const ignoreFiles = new Set(o.ignoreFiles);
+	const rootIgnore = ignore().add([...o.exclude, ...ignoreFiles]);
+	const globIgnore = ignore().add(o.glob ?? []);
+	const sorter = (typeof o.sort === "string" ? sorters[o.sort] : o.sort) ?? sorters.name;
+	const visited = /* @__PURE__ */ new Set();
+	if (o.ignore) for (const igf of ignoreFiles) {
+		const igPath = findUp(root, igf, ".git");
+		if (igPath) rootIgnore.add(readFileSync(igPath, "utf8"));
+	}
+	async function ls(dir) {
+		if (visited.has(dir.path)) return;
+		visited.add(dir.path);
+		let entries;
+		try {
+			entries = (await readdir(dir.path, { withFileTypes: true })).toSorted(sorter).toReversed();
+		} catch (error) {
+			return o.onError?.(dir.path, toError(error));
+		}
+		let ig = dir.ignore;
+		const children = [];
+		for (const entry of entries) {
+			const path = join(entry.parentPath, entry.name);
+			if (o.ignore && entry.isFile() && ignoreFiles.has(entry.name)) {
+				const fig = ignore().add(readFileSync(path, "utf8"));
+				ig = ig ? ig.extend(fig, dir.rel) : new IgnoreTree(fig, dir.rel);
+			} else if (!o.hidden && entry.name.startsWith(".")) continue;
+			else {
+				let isDirectory = entry.isDirectory();
+				isDirectory ||= o.follow && entry.isSymbolicLink() && (sstat(path)?.isDirectory() ?? false);
+				const rel = dir.rel + entry.name + (isDirectory ? "/" : "");
+				const depth = dir.depth + 1;
+				children.push({
+					depth,
+					dir: isDirectory,
+					path,
+					rel
+				});
+			}
+		}
+		for (const child of children) {
+			o.onVisit?.(child.rel);
+			if (o.ignore && ig?.ignores(child.rel)) continue;
+			if (o.glob && !child.dir && !globIgnore.ignores(child.rel)) continue;
+			stack.push({
+				...child,
+				ignore: ig
+			});
+		}
+	}
+	const stack = [{
+		depth: 0,
+		dir: true,
+		ignore: new IgnoreTree(rootIgnore),
+		path: root,
+		rel: ""
+	}];
+	const parents = [];
+	while (stack.length > 0) {
+		const entry = stack.pop();
+		if (o.type !== "file" && entry.depth !== 0) {
+			while (!o.empty && parents.length > 0 && parents[parents.length - 1].depth >= entry.depth) parents.pop();
+			if (entry.dir && entry.depth < o.depth) parents.push(entry);
+			else {
+				for (const p of parents) yield p.rel;
+				parents.length = 0;
+				if (o.type !== "directory") yield entry.rel;
+			}
+		} else if (!entry.dir) yield entry.rel;
+		if (entry.dir && entry.depth < o.depth) await ls(entry);
+	}
+}
+//#endregion
+export { glob };