@stainless-code/codemap 0.1.0

package/dist/config-CsPgQWSX.mjs

@@ -0,0 +1,885 @@
+#!/usr/bin/env node
+
+import { a as LANG_MAP, i as extractMarkers, n as hashContent, r as extractCssData, t as extractFileData } from "./parser-VtP0EJiw.mjs";
+import { createRequire } from "node:module";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import fg from "fast-glob";
+import { ResolverFactory } from "oxc-resolver";
+import { cpus } from "node:os";
+import { Worker as Worker$1 } from "node:worker_threads";
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/runtime.ts
+let _config = null;
+/**
+* Store resolved config for the current process (`getProjectRoot`, `openDb`, etc.).
+* Must run before indexing or `openDb()`; typically via `createCodemap` or the CLI.
+*/
+function initCodemap(config) {
+	_config = config;
+}
+function getCodemapConfig() {
+	if (!_config) throw new Error("Codemap: not initialized — call initCodemap() after resolving config");
+	return _config;
+}
+function getProjectRoot() {
+	return getCodemapConfig().root;
+}
+function getDatabasePath() {
+	return getCodemapConfig().databasePath;
+}
+function getIncludePatterns() {
+	return getCodemapConfig().include;
+}
+function getExcludeDirNames() {
+	return getCodemapConfig().excludeDirNames;
+}
+function getTsconfigPath() {
+	return getCodemapConfig().tsconfigPath;
+}
+/** True if any path segment matches an excluded directory name (e.g. `node_modules`). */
+function isPathExcluded(relPath) {
+	const parts = relPath.split(/[/\\]/).filter(Boolean);
+	const set = getExcludeDirNames();
+	return parts.some((p) => set.has(p));
+}
+//#endregion
+//#region src/sqlite-db.ts
+const require$1 = createRequire(import.meta.url);
+/**
+* `better-sqlite3` allows only one statement per `prepare()`; `bun:sqlite` accepts several.
+* On Node we split on `;` — do not put `;` inside `--` line comments in `db.ts` SQL strings.
+*/
+function runSql(inner, sql, params) {
+	if (params !== void 0 && params.length > 0) {
+		inner.run(sql, params);
+		return;
+	}
+	if (typeof Bun !== "undefined") {
+		inner.run(sql);
+		return;
+	}
+	const parts = sql.split(";").map((s) => s.trim()).filter(Boolean);
+	if (parts.length <= 1) inner.run(sql.trim());
+	else for (const p of parts) inner.run(p);
+}
+function openRaw(path) {
+	if (typeof Bun !== "undefined") {
+		const { Database } = require$1("bun:sqlite");
+		return new Database(path, { create: true });
+	}
+	const rawDb = new (require$1("better-sqlite3"))(path);
+	return {
+		run(sql, params) {
+			const stmt = rawDb.prepare(sql);
+			if (params !== void 0 && params.length > 0) stmt.run(...params);
+			else stmt.run();
+		},
+		query(sql) {
+			const stmt = rawDb.prepare(sql);
+			return {
+				get(...params) {
+					return stmt.get(...params);
+				},
+				all(...params) {
+					return stmt.all(...params);
+				}
+			};
+		},
+		transaction(fn) {
+			return rawDb.transaction(fn);
+		},
+		close() {
+			rawDb.close();
+		}
+	};
+}
+function wrap(inner) {
+	return {
+		run(sql, params) {
+			runSql(inner, sql, params);
+		},
+		query(sql) {
+			return {
+				get(...params) {
+					return inner.query(sql).get(...params);
+				},
+				all(...params) {
+					return inner.query(sql).all(...params);
+				}
+			};
+		},
+		transaction(fn) {
+			return inner.transaction(fn);
+		},
+		close() {
+			inner.close();
+		}
+	};
+}
+function openCodemapDatabase(path) {
+	const db = wrap(openRaw(path ?? getDatabasePath()));
+	db.run("PRAGMA journal_mode = WAL");
+	db.run("PRAGMA synchronous = NORMAL");
+	db.run("PRAGMA foreign_keys = ON");
+	db.run("PRAGMA case_sensitive_like = ON");
+	db.run("PRAGMA temp_store = MEMORY");
+	db.run("PRAGMA mmap_size = 268435456");
+	db.run("PRAGMA cache_size = -16384");
+	return db;
+}
+function openDb() {
+	return openCodemapDatabase();
+}
+function closeDb(db) {
+	db.run("PRAGMA analysis_limit = 400");
+	db.run("PRAGMA optimize");
+	db.close();
+}
+function createTables(db) {
+	db.run(`
+    CREATE TABLE IF NOT EXISTS files (
+      path TEXT PRIMARY KEY,
+      content_hash TEXT NOT NULL,
+      size INTEGER,
+      line_count INTEGER,
+      language TEXT,
+      last_modified INTEGER,
+      indexed_at INTEGER
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS symbols (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      line_start INTEGER,
+      line_end INTEGER,
+      signature TEXT,
+      is_exported INTEGER DEFAULT 0,
+      is_default_export INTEGER DEFAULT 0
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS imports (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      source TEXT NOT NULL,
+      resolved_path TEXT,
+      specifiers TEXT,
+      is_type_only INTEGER DEFAULT 0,
+      line_number INTEGER
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS exports (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      kind TEXT,
+      is_default INTEGER DEFAULT 0,
+      re_export_source TEXT
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS components (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      props_type TEXT,
+      hooks_used TEXT,
+      is_default_export INTEGER DEFAULT 0
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS dependencies (
+      from_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      to_path TEXT NOT NULL,
+      PRIMARY KEY (from_path, to_path)
+    ) STRICT, WITHOUT ROWID;
+
+    CREATE TABLE IF NOT EXISTS markers (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      line_number INTEGER,
+      kind TEXT NOT NULL,
+      content TEXT
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS css_variables (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      value TEXT,
+      scope TEXT,
+      line_number INTEGER
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS css_classes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      is_module INTEGER DEFAULT 0,
+      line_number INTEGER
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS css_keyframes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      line_number INTEGER
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    ) STRICT, WITHOUT ROWID;
+  `);
+}
+function createIndexes(db) {
+	db.run(`
+    -- Covering indexes: include columns returned by common queries to avoid table lookups
+    CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name, kind, file_path, line_start, line_end, signature, is_exported);
+    CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind, is_exported, name, file_path);
+    CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_path);
+
+    -- Partial indexes: subset indexes for common filtered AI agent queries
+    CREATE INDEX IF NOT EXISTS idx_symbols_exported ON symbols(name, kind, file_path, signature)
+      WHERE is_exported = 1;
+    CREATE INDEX IF NOT EXISTS idx_symbols_functions ON symbols(name, file_path, line_start, line_end, signature)
+      WHERE kind = 'function';
+
+    CREATE INDEX IF NOT EXISTS idx_imports_source ON imports(source, file_path);
+    CREATE INDEX IF NOT EXISTS idx_imports_resolved ON imports(resolved_path, file_path);
+    CREATE INDEX IF NOT EXISTS idx_imports_file ON imports(file_path);
+
+    CREATE INDEX IF NOT EXISTS idx_exports_name ON exports(name, file_path, kind, is_default);
+    CREATE INDEX IF NOT EXISTS idx_exports_file ON exports(file_path);
+
+    CREATE INDEX IF NOT EXISTS idx_components_name ON components(name, file_path, props_type, hooks_used);
+    CREATE INDEX IF NOT EXISTS idx_components_file ON components(file_path, name);
+
+    -- WITHOUT ROWID tables already have a clustered PK — this covers reverse lookups
+    CREATE INDEX IF NOT EXISTS idx_dependencies_to ON dependencies(to_path, from_path);
+
+    CREATE INDEX IF NOT EXISTS idx_markers_kind ON markers(kind, file_path, line_number, content);
+    CREATE INDEX IF NOT EXISTS idx_markers_file ON markers(file_path);
+
+    CREATE INDEX IF NOT EXISTS idx_css_variables_name ON css_variables(name, value, scope, file_path);
+    CREATE INDEX IF NOT EXISTS idx_css_variables_file ON css_variables(file_path);
+    CREATE INDEX IF NOT EXISTS idx_css_classes_name ON css_classes(name, file_path, is_module);
+    CREATE INDEX IF NOT EXISTS idx_css_classes_file ON css_classes(file_path);
+    CREATE INDEX IF NOT EXISTS idx_css_keyframes_name ON css_keyframes(name, file_path);
+  `);
+}
+function createSchema(db) {
+	if (db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='meta'").get()) {
+		const row = db.query("SELECT value FROM meta WHERE key = ?").get("schema_version");
+		if (row && row.value !== String(1)) {
+			console.log(`  Schema version mismatch (${row.value} -> 1), rebuilding...`);
+			dropAll(db);
+		}
+	}
+	createTables(db);
+	createIndexes(db);
+	setMeta(db, "schema_version", String(1));
+}
+function dropAll(db) {
+	db.run(`
+    DROP TABLE IF EXISTS dependencies;
+    DROP TABLE IF EXISTS markers;
+    DROP TABLE IF EXISTS components;
+    DROP TABLE IF EXISTS imports;
+    DROP TABLE IF EXISTS exports;
+    DROP TABLE IF EXISTS symbols;
+    DROP TABLE IF EXISTS css_variables;
+    DROP TABLE IF EXISTS css_classes;
+    DROP TABLE IF EXISTS css_keyframes;
+    DROP TABLE IF EXISTS files;
+    DROP TABLE IF EXISTS meta;
+  `);
+}
+function getMeta(db, key) {
+	return db.query("SELECT value FROM meta WHERE key = ?").get(key)?.value;
+}
+function setMeta(db, key, value) {
+	db.run("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)", [key, value]);
+}
+function deleteFileData(db, filePath) {
+	db.run("DELETE FROM files WHERE path = ?", [filePath]);
+}
+function insertFile(db, file) {
+	db.run(`INSERT INTO files (path, content_hash, size, line_count, language, last_modified, indexed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+		file.path,
+		file.content_hash,
+		file.size,
+		file.line_count,
+		file.language,
+		file.last_modified,
+		file.indexed_at
+	]);
+}
+const BATCH_SIZE = 100;
+function batchInsert(db, items, sqlPrefix, one, extract) {
+	if (items.length === 0) return;
+	const fullPlaceholders = Array(BATCH_SIZE).fill(one).join(",");
+	for (let i = 0; i < items.length; i += BATCH_SIZE) {
+		const end = Math.min(i + BATCH_SIZE, items.length);
+		const batchLen = end - i;
+		const placeholders = batchLen === BATCH_SIZE ? fullPlaceholders : Array(batchLen).fill(one).join(",");
+		const values = [];
+		for (let j = i; j < end; j++) extract(items[j], values);
+		db.run(`${sqlPrefix} VALUES ${placeholders}`, values);
+	}
+}
+function insertSymbols(db, symbols) {
+	batchInsert(db, symbols, "INSERT INTO symbols (file_path, name, kind, line_start, line_end, signature, is_exported, is_default_export)", "(?,?,?,?,?,?,?,?)", (s, v) => v.push(s.file_path, s.name, s.kind, s.line_start, s.line_end, s.signature, s.is_exported, s.is_default_export));
+}
+function insertImports(db, imports) {
+	batchInsert(db, imports, "INSERT INTO imports (file_path, source, resolved_path, specifiers, is_type_only, line_number)", "(?,?,?,?,?,?)", (imp, v) => v.push(imp.file_path, imp.source, imp.resolved_path, imp.specifiers, imp.is_type_only, imp.line_number));
+}
+function insertExports(db, exports) {
+	batchInsert(db, exports, "INSERT INTO exports (file_path, name, kind, is_default, re_export_source)", "(?,?,?,?,?)", (e, v) => v.push(e.file_path, e.name, e.kind, e.is_default, e.re_export_source));
+}
+function insertComponents(db, components) {
+	batchInsert(db, components, "INSERT INTO components (file_path, name, props_type, hooks_used, is_default_export)", "(?,?,?,?,?)", (c, v) => v.push(c.file_path, c.name, c.props_type, c.hooks_used, c.is_default_export));
+}
+function insertDependencies(db, deps) {
+	batchInsert(db, deps, "INSERT OR IGNORE INTO dependencies (from_path, to_path)", "(?,?)", (d, v) => v.push(d.from_path, d.to_path));
+}
+function insertMarkers(db, markers) {
+	batchInsert(db, markers, "INSERT INTO markers (file_path, line_number, kind, content)", "(?,?,?,?)", (m, v) => v.push(m.file_path, m.line_number, m.kind, m.content));
+}
+function insertCssVariables(db, variables) {
+	batchInsert(db, variables, "INSERT INTO css_variables (file_path, name, value, scope, line_number)", "(?,?,?,?,?)", (cv, v) => v.push(cv.file_path, cv.name, cv.value, cv.scope, cv.line_number));
+}
+function insertCssClasses(db, classes) {
+	batchInsert(db, classes, "INSERT INTO css_classes (file_path, name, is_module, line_number)", "(?,?,?,?)", (c, v) => v.push(c.file_path, c.name, c.is_module, c.line_number));
+}
+function insertCssKeyframes(db, keyframes) {
+	batchInsert(db, keyframes, "INSERT INTO css_keyframes (file_path, name, line_number)", "(?,?,?)", (k, v) => v.push(k.file_path, k.name, k.line_number));
+}
+function getAllFileHashes(db) {
+	const rows = db.query("SELECT path, content_hash FROM files").all();
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < rows.length; i++) map.set(rows[i].path, rows[i].content_hash);
+	return map;
+}
+//#endregion
+//#region src/glob-sync.ts
+/**
+* Glob files relative to `cwd` (dotfiles included). On Bun uses `Glob` from `bun`;
+* on Node uses `fast-glob` for identical published behavior.
+*/
+function globSync(pattern, cwd) {
+	if (typeof Bun !== "undefined") {
+		const { Glob } = __require("bun");
+		const glob = new Glob(pattern);
+		return Array.from(glob.scanSync({
+			cwd,
+			dot: true
+		}));
+	}
+	return fg.sync(pattern, {
+		cwd,
+		dot: true,
+		absolute: false
+	});
+}
+//#endregion
+//#region src/resolver.ts
+let _projectRoot = null;
+let _tsconfigPath = null;
+let _resolver = null;
+/**
+* Wire oxc-resolver to the project root and optional `tsconfig.json`.
+* Call after `initCodemap()` (CLI and `createCodemap` do this for you).
+*/
+function configureResolver(projectRoot, tsconfigPath) {
+	_projectRoot = projectRoot;
+	_tsconfigPath = tsconfigPath;
+	_resolver = null;
+}
+function getResolver() {
+	if (!_projectRoot) throw new Error("Codemap: configureResolver() must run before resolving imports");
+	if (!_resolver) {
+		const options = {
+			conditionNames: ["node", "import"],
+			extensions: [
+				".ts",
+				".tsx",
+				".mts",
+				".cts",
+				".js",
+				".jsx",
+				".mjs",
+				".cjs",
+				".json",
+				".css"
+			],
+			mainFields: ["module", "main"]
+		};
+		if (_tsconfigPath) options.tsconfig = { configFile: _tsconfigPath };
+		_resolver = new ResolverFactory(options);
+	}
+	return _resolver;
+}
+/**
+* Resolve static imports, mutating each row's `resolved_path`, and collect `dependencies`
+* edges only when the target path is in `indexedPaths` (project files).
+*/
+function resolveImports(absoluteFilePath, imports, indexedPaths) {
+	const root = _projectRoot;
+	const resolver = getResolver();
+	const deps = [];
+	for (const imp of imports) try {
+		const result = resolver.resolveFileSync(absoluteFilePath, imp.source);
+		if (result.path) {
+			const resolved = result.path;
+			const relResolved = resolved.startsWith(root) ? resolved.slice(root.length + 1) : resolved;
+			imp.resolved_path = relResolved;
+			if (indexedPaths.has(relResolved)) deps.push({
+				from_path: imp.file_path,
+				to_path: relResolved
+			});
+		}
+	} catch {}
+	return deps;
+}
+//#endregion
+//#region src/worker-pool.ts
+const fromDist = basename(dirname(fileURLToPath(import.meta.url))) === "dist";
+const WORKER_URL_BUN = new URL(fromDist ? "./parse-worker.mjs" : "./parse-worker.ts", import.meta.url);
+const WORKER_URL_NODE = new URL(fromDist ? "./parse-worker-node.mjs" : "./parse-worker-node.ts", import.meta.url);
+const WORKER_COUNT = Math.max(2, Math.min(cpus().length || 4, 6));
+function parseFilesParallel(filePaths) {
+	const chunkSize = Math.ceil(filePaths.length / WORKER_COUNT);
+	const chunks = [];
+	for (let i = 0; i < filePaths.length; i += chunkSize) chunks.push(filePaths.slice(i, i + chunkSize));
+	return Promise.all(chunks.map((chunk) => new Promise((resolve, reject) => {
+		const input = {
+			files: chunk,
+			projectRoot: getProjectRoot()
+		};
+		if (typeof Bun !== "undefined") {
+			const worker = new Worker(WORKER_URL_BUN);
+			worker.onmessage = (event) => {
+				resolve(event.data.results);
+				worker.terminate();
+			};
+			worker.postMessage(input);
+			return;
+		}
+		const worker = new Worker$1(fileURLToPath(WORKER_URL_NODE), { type: "module" });
+		worker.on("message", (data) => {
+			resolve(data.results);
+			worker.terminate();
+		});
+		worker.on("error", reject);
+		worker.postMessage(input);
+	}))).then((parts) => parts.flat());
+}
+//#endregion
+//#region src/application/index-engine.ts
+const VALID_EXTENSIONS = new Set(Object.keys(LANG_MAP));
+const TS_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const CSS_EXTENSIONS = new Set([".css"]);
+function langFromExt(ext) {
+	return LANG_MAP[ext] ?? "text";
+}
+function fileCategory(path) {
+	const ext = extname(path);
+	if (TS_EXTENSIONS.has(ext)) return "ts";
+	if (CSS_EXTENSIONS.has(ext)) return "css";
+	return "text";
+}
+function collectFiles() {
+	const files = [];
+	const root = getProjectRoot();
+	for (const pattern of getIncludePatterns()) {
+		const matches = globSync(pattern, root);
+		for (const path of matches) {
+			if (isPathExcluded(path)) continue;
+			files.push(path);
+		}
+	}
+	return [...new Set(files)].sort();
+}
+function getChangedFiles(db) {
+	const lastCommit = getMeta(db, "last_indexed_commit");
+	if (!lastCommit) return null;
+	try {
+		if (spawnSync("git", [
+			"merge-base",
+			"--is-ancestor",
+			lastCommit,
+			"HEAD"
+		], { cwd: getProjectRoot() }).status !== 0) return null;
+		const diffResult = spawnSync("git", [
+			"diff",
+			"--name-only",
+			`${lastCommit}..HEAD`
+		], { cwd: getProjectRoot() });
+		const statusResult = spawnSync("git", [
+			"status",
+			"--porcelain",
+			"--no-renames"
+		], { cwd: getProjectRoot() });
+		const diffFiles = diffResult.stdout.toString().trim().split("\n").filter(Boolean);
+		const statusFiles = statusResult.stdout.toString().trim().split("\n").filter(Boolean).map((line) => line.slice(3).trim());
+		const allChanged = [...new Set([...diffFiles, ...statusFiles])].filter((f) => {
+			return extname(f) in LANG_MAP;
+		});
+		const changed = [];
+		const deleted = [];
+		for (const f of allChanged) try {
+			statSync(join(getProjectRoot(), f));
+			changed.push(f);
+		} catch {
+			deleted.push(f);
+		}
+		return {
+			changed,
+			deleted
+		};
+	} catch {
+		return null;
+	}
+}
+function getCurrentCommit() {
+	return spawnSync("git", ["rev-parse", "HEAD"], { cwd: getProjectRoot() }).stdout.toString().trim();
+}
+function insertParsedResults(db, results, indexedPaths) {
+	let indexed = 0;
+	db.transaction(() => {
+		for (const parsed of results) {
+			if (parsed.error) continue;
+			insertFile(db, parsed.fileRow);
+			try {
+				if (parsed.category === "text") {
+					if (parsed.markers?.length) insertMarkers(db, parsed.markers);
+				} else if (parsed.category === "css") {
+					if (parsed.cssVariables?.length) insertCssVariables(db, parsed.cssVariables);
+					if (parsed.cssClasses?.length) insertCssClasses(db, parsed.cssClasses);
+					if (parsed.cssKeyframes?.length) insertCssKeyframes(db, parsed.cssKeyframes);
+					if (parsed.markers?.length) insertMarkers(db, parsed.markers);
+					if (parsed.cssImportSources) for (const importSource of parsed.cssImportSources) insertImports(db, [{
+						file_path: parsed.relPath,
+						source: importSource,
+						resolved_path: null,
+						specifiers: "[]",
+						is_type_only: 0,
+						line_number: 0
+					}]);
+				} else {
+					if (parsed.symbols?.length) insertSymbols(db, parsed.symbols);
+					if (parsed.imports?.length) {
+						const deps = resolveImports(join(getProjectRoot(), parsed.relPath), parsed.imports, indexedPaths);
+						insertImports(db, parsed.imports);
+						if (deps.length) insertDependencies(db, deps);
+					}
+					if (parsed.exports?.length) insertExports(db, parsed.exports);
+					if (parsed.components?.length) insertComponents(db, parsed.components);
+					if (parsed.markers?.length) insertMarkers(db, parsed.markers);
+				}
+			} catch (err) {
+				console.error(`  Parse error in ${parsed.relPath}: ${err instanceof Error ? err.message : err}`);
+			}
+			indexed++;
+		}
+	})();
+	return indexed;
+}
+function fetchTableStats(db) {
+	return db.query(`SELECT
+        (SELECT COUNT(*) FROM files) as files,
+        (SELECT COUNT(*) FROM symbols) as symbols,
+        (SELECT COUNT(*) FROM imports) as imports,
+        (SELECT COUNT(*) FROM exports) as exports,
+        (SELECT COUNT(*) FROM components) as components,
+        (SELECT COUNT(*) FROM dependencies) as dependencies,
+        (SELECT COUNT(*) FROM markers) as markers,
+        (SELECT COUNT(*) FROM css_variables) as css_vars,
+        (SELECT COUNT(*) FROM css_classes) as css_classes,
+        (SELECT COUNT(*) FROM css_keyframes) as css_keyframes`).get();
+}
+async function indexFiles(db, filePaths, fullRebuild, knownIndexedPaths, options) {
+	const quiet = options?.quiet ?? false;
+	const startTime = performance.now();
+	if (fullRebuild) {
+		dropAll(db);
+		createTables(db);
+		db.run("PRAGMA synchronous = OFF");
+		db.run("PRAGMA foreign_keys = OFF");
+	} else createSchema(db);
+	const indexedPaths = knownIndexedPaths ?? new Set(filePaths);
+	let indexed = 0;
+	let skipped = 0;
+	if (fullRebuild) {
+		const results = await parseFilesParallel(filePaths);
+		results.sort((a, b) => a.relPath.localeCompare(b.relPath));
+		indexed = insertParsedResults(db, results, indexedPaths);
+	} else {
+		const existingHashes = getAllFileHashes(db);
+		db.transaction(() => {
+			for (const relPath of filePaths) {
+				const absPath = join(getProjectRoot(), relPath);
+				let source;
+				try {
+					source = readFileSync(absPath, "utf-8");
+				} catch {
+					deleteFileData(db, relPath);
+					continue;
+				}
+				const hash = hashContent(source);
+				if (existingHashes.get(relPath) === hash) {
+					skipped++;
+					continue;
+				}
+				deleteFileData(db, relPath);
+				const stat = statSync(absPath);
+				let lineCount = 1;
+				for (let i = 0; i < source.length; i++) if (source.charCodeAt(i) === 10) lineCount++;
+				insertFile(db, {
+					path: relPath,
+					content_hash: hash,
+					size: stat.size,
+					line_count: lineCount,
+					language: langFromExt(extname(relPath)),
+					last_modified: Math.floor(stat.mtimeMs),
+					indexed_at: Date.now()
+				});
+				try {
+					const category = fileCategory(relPath);
+					if (category === "text") {
+						const markers = extractMarkers(source, relPath);
+						if (markers.length) insertMarkers(db, markers);
+					} else if (category === "css") {
+						const cssData = extractCssData(absPath, source, relPath);
+						if (cssData.variables.length) insertCssVariables(db, cssData.variables);
+						if (cssData.classes.length) insertCssClasses(db, cssData.classes);
+						if (cssData.keyframes.length) insertCssKeyframes(db, cssData.keyframes);
+						if (cssData.markers.length) insertMarkers(db, cssData.markers);
+						for (const importSource of cssData.importSources) insertImports(db, [{
+							file_path: relPath,
+							source: importSource,
+							resolved_path: null,
+							specifiers: "[]",
+							is_type_only: 0,
+							line_number: 0
+						}]);
+					} else {
+						const data = extractFileData(absPath, source, relPath);
+						if (data.symbols.length) insertSymbols(db, data.symbols);
+						const deps = resolveImports(absPath, data.imports, indexedPaths);
+						if (data.imports.length) insertImports(db, data.imports);
+						if (deps.length) insertDependencies(db, deps);
+						if (data.exports.length) insertExports(db, data.exports);
+						if (data.components.length) insertComponents(db, data.components);
+						if (data.markers.length) insertMarkers(db, data.markers);
+					}
+				} catch (err) {
+					console.error(`  Parse error in ${relPath}: ${err instanceof Error ? err.message : err}`);
+				}
+				indexed++;
+			}
+		})();
+	}
+	if (fullRebuild) {
+		createIndexes(db);
+		db.run("PRAGMA synchronous = NORMAL");
+		db.run("PRAGMA foreign_keys = ON");
+		setMeta(db, "schema_version", String(1));
+	}
+	setMeta(db, "last_indexed_commit", getCurrentCommit());
+	setMeta(db, "indexed_at", (/* @__PURE__ */ new Date()).toISOString());
+	const fileCount = db.query("SELECT COUNT(*) as c FROM files").get().c;
+	setMeta(db, "file_count", String(fileCount));
+	setMeta(db, "project_root", getProjectRoot());
+	const elapsed = Math.round(performance.now() - startTime);
+	const stats = fetchTableStats(db);
+	if (!quiet) {
+		console.log(`\n  Codemap ${fullRebuild ? "(full rebuild)" : "(incremental)"}`);
+		console.log(`  ${indexed} files indexed, ${skipped} unchanged, ${elapsed}ms`);
+		console.log(`  ───────────────────────────────────`);
+		for (const [key, value] of Object.entries(stats)) console.log(`  ${(key + ":").padEnd(14)}${value}`);
+		console.log();
+	}
+	return {
+		indexed,
+		skipped,
+		elapsedMs: elapsed,
+		fullRebuild,
+		stats
+	};
+}
+function deleteFilesFromIndex(db, deleted, quiet) {
+	if (deleted.length === 0) return;
+	for (const f of deleted) deleteFileData(db, f);
+	if (!quiet) console.log(`  Removed ${deleted.length} deleted files from index`);
+}
+async function targetedReindex(db, targetFiles, quiet) {
+	const startTime = performance.now();
+	createSchema(db);
+	const existingPaths = new Set(getAllFileHashes(db).keys());
+	for (const f of targetFiles) existingPaths.add(f);
+	const elapsed = Math.round(performance.now() - startTime);
+	if (!quiet) console.log(`  Targeted reindex: ${targetFiles.length} files (setup ${elapsed}ms)`);
+	return indexFiles(db, targetFiles, false, existingPaths, { quiet });
+}
+/**
+* Run SQL and print results to stdout (`console.table`), or a friendly error to stderr.
+* Does not throw on invalid SQL (matches CLI `query` UX).
+*/
+function printQueryResult(sql) {
+	const db = openDb();
+	try {
+		const rows = db.query(sql).all();
+		if (rows.length === 0) console.log("(no results)");
+		else console.table(rows);
+	} catch (err) {
+		console.error(`Query error: ${err instanceof Error ? err.message : err}`);
+	} finally {
+		closeDb(db);
+	}
+}
+/**
+* Open the index, run SQL, return all rows, then close (used by the public `Codemap.query` API).
+*/
+function queryRows(sql) {
+	const db = openDb();
+	try {
+		return db.query(sql).all();
+	} finally {
+		closeDb(db);
+	}
+}
+//#endregion
+//#region src/config.ts
+async function readJsonFile(filePath) {
+	if (typeof Bun !== "undefined") return Bun.file(filePath).json();
+	const text = await readFile(filePath, "utf-8");
+	return JSON.parse(text);
+}
+/**
+* Default glob patterns for indexing (relative to project root).
+* Override with `include` in `codemap.config`.
+*/
+const DEFAULT_INCLUDE_PATTERNS = [
+	"**/*.{ts,tsx,js,jsx,cjs,mjs,mts,cts}",
+	"**/*.css",
+	"**/*.{md,mdx,mdc}",
+	"**/*.{json,yml,yaml}",
+	"**/*.sh"
+];
+/**
+* Directory **names** excluded when they appear as any path segment (not full paths).
+* Override with `excludeDirNames` in `codemap.config`.
+*/
+const DEFAULT_EXCLUDE_DIR_NAMES = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".next",
+	".output",
+	"coverage",
+	"storybook-static",
+	".turbo",
+	".cache",
+	".parcel-cache",
+	"vendor"
+];
+/**
+* Zod schema for user config (`codemap.config.*`, `defineConfig`, API).
+* Unknown keys are rejected (`.strict()`).
+*/
+const codemapUserConfigSchema = z.object({
+	root: z.string().optional().describe("Project root. Defaults via CLI `--root` or `process.cwd()`."),
+	databasePath: z.string().optional().describe("SQLite database path, relative to root or absolute. Default: `<root>/.codemap.db`."),
+	include: z.array(z.string()).optional().describe("Glob patterns relative to root; replaces default include list when set."),
+	excludeDirNames: z.array(z.string()).optional().describe("Directory name segments to skip; replaces default exclude list when set."),
+	tsconfigPath: z.union([z.string(), z.null()]).optional().describe("Path to `tsconfig.json` for import alias resolution. Use `null` to disable.")
+}).strict();
+function formatCodemapConfigError(error) {
+	return error.issues.map((issue) => {
+		return `${issue.path.length > 0 ? issue.path.map(String).join(".") : "(root)"}: ${issue.message}`;
+	}).join("; ");
+}
+/**
+* Runtime validation for {@link CodemapUserConfig} (from JSON, `defineConfig`, or API).
+*
+* @throws TypeError when the shape is invalid or unknown keys are present.
+*/
+function parseCodemapUserConfig(config) {
+	const result = codemapUserConfigSchema.safeParse(config);
+	if (!result.success) throw new TypeError(`Codemap config: ${formatCodemapConfigError(result.error)}`);
+	return result.data;
+}
+/**
+* Helper for `export default defineConfig({ ... })` in `codemap.config.ts`.
+*/
+function defineConfig(config) {
+	return parseCodemapUserConfig(config);
+}
+/**
+* Merge user config with defaults (absolute paths, default DB location, tsconfig discovery).
+*/
+function resolveCodemapConfig(root, user) {
+	const parsed = user !== void 0 ? parseCodemapUserConfig(user) : void 0;
+	const absRoot = resolve(root);
+	const databasePath = parsed?.databasePath ? resolve(absRoot, parsed.databasePath) : join(absRoot, ".codemap.db");
+	const include = parsed?.include?.length ? [...parsed.include] : [...DEFAULT_INCLUDE_PATTERNS];
+	const excludeDirNames = new Set(parsed?.excludeDirNames?.length ? parsed.excludeDirNames : DEFAULT_EXCLUDE_DIR_NAMES);
+	let tsconfigPath;
+	if (parsed?.tsconfigPath === null) tsconfigPath = null;
+	else if (parsed?.tsconfigPath) tsconfigPath = resolve(absRoot, parsed.tsconfigPath);
+	else {
+		const d = join(absRoot, "tsconfig.json");
+		tsconfigPath = existsSync(d) ? d : null;
+	}
+	return {
+		root: absRoot,
+		databasePath,
+		include,
+		excludeDirNames,
+		tsconfigPath
+	};
+}
+/**
+* Load optional `codemap.config.ts` / `codemap.config.json` from the project root,
+* or from `explicitPath` (CLI `--config`).
+*/
+async function loadUserConfig(root, explicitPath) {
+	const tryImport = async (file) => {
+		if (!existsSync(file)) return void 0;
+		const def = (await import(pathToFileURL(file).href)).default;
+		if (typeof def === "function") return await def();
+		if (def && typeof def === "object") return def;
+	};
+	if (explicitPath) {
+		if (explicitPath.endsWith(".json")) {
+			if (!existsSync(explicitPath)) return void 0;
+			return await readJsonFile(explicitPath);
+		}
+		return tryImport(explicitPath);
+	}
+	const fromTs = await tryImport(join(root, "codemap.config.ts"));
+	if (fromTs) return fromTs;
+	const jsonPath = join(root, "codemap.config.json");
+	if (existsSync(jsonPath)) return await readJsonFile(jsonPath);
+}
+//#endregion
+export { getTsconfigPath as C, getProjectRoot as S, createSchema as _, resolveCodemapConfig as a, setMeta as b, deleteFilesFromIndex as c, indexFiles as d, printQueryResult as f, closeDb as g, configureResolver as h, parseCodemapUserConfig as i, getChangedFiles as l, targetedReindex as m, defineConfig as n, VALID_EXTENSIONS as o, queryRows as p, loadUserConfig as r, collectFiles as s, codemapUserConfigSchema as t, getCurrentCommit as u, getAllFileHashes as v, initCodemap as w, getDatabasePath as x, openDb as y };