nano-git 0.3.5 → 0.3.6

package/dist/backend/sqlite-pool.d.mts

@@ -0,0 +1,20 @@
+import { Database, Statement } from "bun:sqlite";
+
+//#region src/backend/sqlite-pool.d.ts
+/** 连接池获取结果 */
+interface SqliteConnectionHandle {
+  readonly db: Database;
+  /** 释放连接（引用计数减一，归零时关闭数据库） */
+  readonly release: () => void;
+  /**
+   * 获取缓存的 prepared statement
+   *
+   * 相同 SQL 文本返回同一实例，避免重复编译。
+   * 绑定参数类型由调用方按 SQL 保证一致，此处不做泛型约束。
+   */
+  readonly prepare: <T>(sql: string) => Statement<T, any[]>;
+  /** 支持 `using` 语法自动释放 */
+  [Symbol.dispose](): void;
+}
+//#endregion
+export { SqliteConnectionHandle };

package/dist/backend/sqlite-pool.mjs

@@ -0,0 +1,95 @@
+import { Database } from "bun:sqlite";
+//#region src/backend/sqlite-pool.ts
+/**
+* SQLite 连接池（引用计数）
+*
+* 缓存 Database 实例，相同 dbPath 复用同一连接，
+* 防止反复打开同一数据库文件带来的开销。
+*
+* 每个 acquire 对应一个 release，当引用计数归零时自动关闭连接。
+* 返回的 handle 实现了 [Symbol.dispose]()，可用 `using` 语法自动释放。
+*
+* @example
+* ```ts
+* using _conn = acquireConnection("/tmp/repo.sqlite");
+* // 作用域结束时自动释放
+* ```
+*/
+const pool = /* @__PURE__ */ new Map();
+/** 构造连接句柄 */
+function makeHandle(db, stmts, onRelease) {
+	return {
+		db,
+		release: onRelease,
+		prepare(sql) {
+			let stmt = stmts.get(sql);
+			if (stmt === void 0) {
+				stmt = db.query(sql);
+				stmts.set(sql, stmt);
+			}
+			return stmt;
+		},
+		[Symbol.dispose]() {
+			onRelease();
+		}
+	};
+}
+/**
+* 从全局连接池获取或创建 SQLite 数据库连接
+*
+* 相同 dbPath 返回同一个 Database 实例，通过引用计数管理生命周期。
+* 首次打开时根据 walMode 执行 PRAGMA journal_mode = WAL。
+* 后续打开（缓存命中）忽略 walMode 参数。
+*
+* 注意：`:memory:` 和 `file:xxx?mode=memory` 等内存数据库不会被缓存，
+* 每次调用都会创建独立连接（SQLite 的 :memory: 为每个连接独立）。
+*/
+function acquireConnection(dbPath, walMode = true) {
+	if (dbPath === ":memory:" || dbPath.startsWith("file:") && dbPath.includes("mode=memory")) {
+		const db = new Database(dbPath);
+		if (walMode) db.run("PRAGMA journal_mode = WAL");
+		const localCache = /* @__PURE__ */ new Map();
+		let released = false;
+		return makeHandle(db, localCache, () => {
+			if (released) return;
+			released = true;
+			db.close();
+		});
+	}
+	const existing = pool.get(dbPath);
+	if (existing !== void 0) {
+		existing.refCount++;
+		let released = false;
+		return makeHandle(existing.db, existing.stmts, () => {
+			if (released) return;
+			released = true;
+			releaseConnection(dbPath);
+		});
+	}
+	const db = new Database(dbPath);
+	if (walMode) db.run("PRAGMA journal_mode = WAL");
+	const stmts = /* @__PURE__ */ new Map();
+	pool.set(dbPath, {
+		db,
+		refCount: 1,
+		stmts
+	});
+	let released = false;
+	return makeHandle(db, stmts, () => {
+		if (released) return;
+		released = true;
+		releaseConnection(dbPath);
+	});
+}
+/** 内部释放逻辑 */
+function releaseConnection(dbPath) {
+	const entry = pool.get(dbPath);
+	if (entry === void 0) return;
+	entry.refCount--;
+	if (entry.refCount <= 0) {
+		pool.delete(dbPath);
+		entry.db.close();
+	}
+}
+//#endregion
+export { acquireConnection };

package/dist/backend/sqlite.d.mts

@@ -19,7 +19,8 @@ interface SqliteRepositoryBackend extends RepositoryBackend {
 /**
  * 创建基于 SQLite 文件的完整仓库后端
  *
- * 内部创建 Database 实例并组合三个子 store。
+ * 内部通过连接池获取 Database 实例并组合三个子 store。
+ * 相同 dbPath 复用同一连接，引用计数归零时自动关闭。
  * 返回的 backend 实现了 [Symbol.dispose]()，可使用 `using` 语法
  * 或在不再使用时手动调用 `backend[Symbol.dispose]()`。
  *

package/dist/backend/sqlite.mjs

@@ -2,7 +2,7 @@ import { HEADS_PREFIX, HEAD_REF } from "../core/types/refs.mjs";
 import { createSqliteObjectStore } from "../odb/sqlite.mjs";
 import { createSqliteRefStore } from "../refs/sqlite.mjs";
 import { createSqliteShallowStore } from "../refs/shallow/sqlite.mjs";
-import { Database } from "bun:sqlite";
+import { acquireConnection } from "./sqlite-pool.mjs";
 //#region src/backend/sqlite.ts
 /**
 * 基于 SQLite 的仓库后端
@@ -12,11 +12,15 @@ import { Database } from "bun:sqlite";
 *
 * 支持 [Symbol.dispose]() 释放数据库连接，
 * 可使用 `using` 语法管理生命周期。
+*
+* 数据库连接通过全局连接池管理（引用计数），
+* 相同 dbPath 复用同一连接，避免反复打开同一个数据库文件。
 */
 /**
 * 创建基于 SQLite 文件的完整仓库后端
 *
-* 内部创建 Database 实例并组合三个子 store。
+* 内部通过连接池获取 Database 实例并组合三个子 store。
+* 相同 dbPath 复用同一连接，引用计数归零时自动关闭。
 * 返回的 backend 实现了 [Symbol.dispose]()，可使用 `using` 语法
 * 或在不再使用时手动调用 `backend[Symbol.dispose]()`。
 *
@@ -37,21 +41,20 @@ import { Database } from "bun:sqlite";
 * ```
 */
 function createSqliteRepositoryBackend(dbPath, options = {}) {
-	const db = new Database(dbPath);
-	if (options.walMode !== false) db.run("PRAGMA journal_mode = WAL");
-	db.run("CREATE TABLE IF NOT EXISTS objects (hash TEXT PRIMARY KEY, type TEXT NOT NULL, content BLOB NOT NULL)");
-	db.run("CREATE TABLE IF NOT EXISTS refs (name TEXT PRIMARY KEY, target TEXT NOT NULL)");
-	db.run("CREATE TABLE IF NOT EXISTS shallow (hash TEXT PRIMARY KEY)");
-	db.run("INSERT OR IGNORE INTO refs (name, target) VALUES (?, ?)", [HEAD_REF, `ref: ${HEADS_PREFIX}main`]);
+	const conn = acquireConnection(dbPath, options.walMode !== false);
+	conn.db.run("CREATE TABLE IF NOT EXISTS objects (hash TEXT PRIMARY KEY, type TEXT NOT NULL, content BLOB NOT NULL)");
+	conn.db.run("CREATE TABLE IF NOT EXISTS refs (name TEXT PRIMARY KEY, target TEXT NOT NULL)");
+	conn.db.run("CREATE TABLE IF NOT EXISTS shallow (hash TEXT PRIMARY KEY)");
+	conn.db.run("INSERT OR IGNORE INTO refs (name, target) VALUES (?, ?)", [HEAD_REF, `ref: ${HEADS_PREFIX}main`]);
 	return {
 		gitDir: dbPath,
-		objects: createSqliteObjectStore(db),
-		refs: createSqliteRefStore(db),
-		shallow: createSqliteShallowStore(db),
+		objects: createSqliteObjectStore(conn),
+		refs: createSqliteRefStore(conn),
+		shallow: createSqliteShallowStore(conn),
 		packs: null,
-		/** 释放 SQLite 数据库连接 */
+		/** 释放 SQLite 数据库连接（引用计数减一） */
 		[Symbol.dispose]() {
-			db.close();
+			conn.release();
 		}
 	};
 }

package/dist/odb/sqlite.d.mts

@@ -1,23 +1,23 @@
 import { ObjectDatabase } from "../core/types/odb.mjs";
-import { Database } from "bun:sqlite";
+import { SqliteConnectionHandle } from "../backend/sqlite-pool.mjs";
 
 //#region src/odb/sqlite.d.ts
 /**
  * 创建基于 SQLite 的对象数据库
  *
- * @param db - 已打开的 bun:sqlite Database 实例
+ * @param conn - SQLite 连接池句柄（含 statement 缓存）
  * @returns 符合 ObjectDatabase 接口的存储后端
  *
  * @example
  * ```ts
- * import { Database } from "bun:sqlite";
- * const db = new Database("/tmp/repo.sqlite");
- * const store = createSqliteObjectStore(db);
+ * import { acquireConnection } from "nano-git/backend/sqlite";
+ * using conn = acquireConnection("/tmp/repo.sqlite");
+ * const store = createSqliteObjectStore(conn);
  *
  * store.ingest(raw);
  * const obj = store.read(hash);
  * ```
  */
-declare function createSqliteObjectStore(db: Database): ObjectDatabase;
+declare function createSqliteObjectStore(conn: SqliteConnectionHandle): ObjectDatabase;
 //#endregion
 export { createSqliteObjectStore };

package/dist/odb/sqlite.mjs

@@ -14,27 +14,27 @@ import { hashObject } from "../core/hash-digest.mjs";
 /**
 * 创建基于 SQLite 的对象数据库
 *
-* @param db - 已打开的 bun:sqlite Database 实例
+* @param conn - SQLite 连接池句柄（含 statement 缓存）
 * @returns 符合 ObjectDatabase 接口的存储后端
 *
 * @example
 * ```ts
-* import { Database } from "bun:sqlite";
-* const db = new Database("/tmp/repo.sqlite");
-* const store = createSqliteObjectStore(db);
+* import { acquireConnection } from "nano-git/backend/sqlite";
+* using conn = acquireConnection("/tmp/repo.sqlite");
+* const store = createSqliteObjectStore(conn);
 *
 * store.ingest(raw);
 * const obj = store.read(hash);
 * ```
 */
-function createSqliteObjectStore(db) {
-	const selectStmt = db.query("SELECT hash, type, content FROM objects WHERE hash = ?");
-	const existsStmt = db.query("SELECT 1 FROM objects WHERE hash = ?");
-	const insertStmt = db.query("INSERT OR IGNORE INTO objects (hash, type, content) VALUES (?, ?, ?)");
-	const deleteStmt = db.query("DELETE FROM objects WHERE hash = ?");
-	const listStmt = db.query("SELECT hash FROM objects ORDER BY hash");
+function createSqliteObjectStore(conn) {
+	const selectStmt = conn.prepare("SELECT hash, type, content FROM objects WHERE hash = ?");
+	const existsStmt = conn.prepare("SELECT 1 FROM objects WHERE hash = ?");
+	const insertStmt = conn.prepare("INSERT OR IGNORE INTO objects (hash, type, content) VALUES (?, ?, ?)");
+	const deleteStmt = conn.prepare("DELETE FROM objects WHERE hash = ?");
+	const listStmt = conn.prepare("SELECT hash FROM objects ORDER BY hash");
 	/** 批量插入的事务包装 */
-	const ingestManyTx = db.transaction((objects) => {
+	const ingestManyTx = conn.db.transaction((objects) => {
 		for (const raw of objects) {
 			const expectedHash = hashObject(raw.type, raw.content);
 			if (expectedHash !== raw.hash) throw new Error(`RawGitObject hash mismatch: expected ${expectedHash}, got ${raw.hash}`);

package/dist/refs/shallow/sqlite.d.mts

@@ -1,23 +1,23 @@
 import { ShallowStore } from "../../core/types/shallow.mjs";
-import { Database } from "bun:sqlite";
+import { SqliteConnectionHandle } from "../../backend/sqlite-pool.mjs";
 
 //#region src/refs/shallow/sqlite.d.ts
 /**
  * 创建基于 SQLite 的 shallow 边界存储
  *
- * @param db - 已打开的 bun:sqlite Database 实例
+ * @param conn - SQLite 连接池句柄（含 statement 缓存）
  * @returns 符合 ShallowStore 接口的存储后端
  *
  * @example
  * ```ts
- * import { Database } from "bun:sqlite";
- * const db = new Database("/tmp/repo.sqlite");
- * const store = createSqliteShallowStore(db);
+ * import { acquireConnection } from "nano-git/backend/sqlite";
+ * using conn = acquireConnection("/tmp/repo.sqlite");
+ * const store = createSqliteShallowStore(conn);
  *
  * store.write([hashA, hashB]);
  * console.log(store.isShallow(hashA)); // true
  * ```
  */
-declare function createSqliteShallowStore(db: Database): ShallowStore;
+declare function createSqliteShallowStore(conn: SqliteConnectionHandle): ShallowStore;
 //#endregion
 export { createSqliteShallowStore };

package/dist/refs/shallow/sqlite.mjs

@@ -13,32 +13,32 @@ import { sha1 } from "../../core/types.mjs";
 /**
 * 创建基于 SQLite 的 shallow 边界存储
 *
-* @param db - 已打开的 bun:sqlite Database 实例
+* @param conn - SQLite 连接池句柄（含 statement 缓存）
 * @returns 符合 ShallowStore 接口的存储后端
 *
 * @example
 * ```ts
-* import { Database } from "bun:sqlite";
-* const db = new Database("/tmp/repo.sqlite");
-* const store = createSqliteShallowStore(db);
+* import { acquireConnection } from "nano-git/backend/sqlite";
+* using conn = acquireConnection("/tmp/repo.sqlite");
+* const store = createSqliteShallowStore(conn);
 *
 * store.write([hashA, hashB]);
 * console.log(store.isShallow(hashA)); // true
 * ```
 */
-function createSqliteShallowStore(db) {
-	const selectAllStmt = db.query("SELECT hash FROM shallow ORDER BY hash");
-	const selectExistsStmt = db.query("SELECT 1 FROM shallow WHERE hash = ?");
-	const deleteAllStmt = db.query("DELETE FROM shallow");
-	const insertStmt = db.query("INSERT OR IGNORE INTO shallow (hash) VALUES (?)");
-	const deleteOneStmt = db.query("DELETE FROM shallow WHERE hash = ?");
+function createSqliteShallowStore(conn) {
+	const selectAllStmt = conn.prepare("SELECT hash FROM shallow ORDER BY hash");
+	const selectExistsStmt = conn.prepare("SELECT 1 FROM shallow WHERE hash = ?");
+	const deleteAllStmt = conn.prepare("DELETE FROM shallow");
+	const insertStmt = conn.prepare("INSERT OR IGNORE INTO shallow (hash) VALUES (?)");
+	const deleteOneStmt = conn.prepare("DELETE FROM shallow WHERE hash = ?");
 	/** 全量替换事务 */
-	const replaceAllTx = db.transaction((boundaries) => {
+	const replaceAllTx = conn.db.transaction((boundaries) => {
 		deleteAllStmt.run();
 		for (const hash of boundaries) insertStmt.run(hash);
 	});
 	/** 增量更新事务 */
-	const applyUpdateTx = db.transaction((update) => {
+	const applyUpdateTx = conn.db.transaction((update) => {
 		for (const hash of update.unshallow) deleteOneStmt.run(hash);
 		for (const hash of update.shallow) insertStmt.run(hash);
 	});

package/dist/refs/sqlite.d.mts

@@ -1,23 +1,23 @@
 import { RefStore } from "../core/types/refs.mjs";
-import { Database } from "bun:sqlite";
+import { SqliteConnectionHandle } from "../backend/sqlite-pool.mjs";
 
 //#region src/refs/sqlite.d.ts
 /**
  * 创建基于 SQLite 的 RefStore
  *
- * @param db - 已打开的 bun:sqlite Database 实例（生命周期由调用方管理）
+ * @param conn - SQLite 连接池句柄（含 statement 缓存）
  * @returns 符合 RefStore 接口的存储后端（含事务支持）
  *
  * @example
  * ```ts
- * import { Database } from "bun:sqlite";
- * const db = new Database("/tmp/repo.sqlite");
- * const store = createSqliteRefStore(db);
+ * import { acquireConnection } from "nano-git/backend/sqlite";
+ * using conn = acquireConnection("/tmp/repo.sqlite");
+ * const store = createSqliteRefStore(conn);
  *
  * store.write("refs/heads/main", "abc123");
  * const content = store.read("refs/heads/main");
  * ```
  */
-declare function createSqliteRefStore(db: Database): RefStore;
+declare function createSqliteRefStore(conn: SqliteConnectionHandle): RefStore;
 //#endregion
 export { createSqliteRefStore };

package/dist/refs/sqlite.mjs

@@ -13,26 +13,27 @@ import { validateRefName, validateRefPrefix } from "./names.mjs";
 /**
 * 创建基于 SQLite 的 RefStore
 *
-* @param db - 已打开的 bun:sqlite Database 实例（生命周期由调用方管理）
+* @param conn - SQLite 连接池句柄（含 statement 缓存）
 * @returns 符合 RefStore 接口的存储后端（含事务支持）
 *
 * @example
 * ```ts
-* import { Database } from "bun:sqlite";
-* const db = new Database("/tmp/repo.sqlite");
-* const store = createSqliteRefStore(db);
+* import { acquireConnection } from "nano-git/backend/sqlite";
+* using conn = acquireConnection("/tmp/repo.sqlite");
+* const store = createSqliteRefStore(conn);
 *
 * store.write("refs/heads/main", "abc123");
 * const content = store.read("refs/heads/main");
 * ```
 */
-function createSqliteRefStore(db) {
-	const selectStmt = db.query("SELECT target FROM refs WHERE name = ?");
-	const selectExistsStmt = db.query("SELECT 1 FROM refs WHERE name = ?");
-	const insertStmt = db.query("INSERT OR REPLACE INTO refs (name, target) VALUES (?, ?)");
-	const deleteStmt = db.query("DELETE FROM refs WHERE name = ?");
-	const listPrefixStmt = db.query("SELECT name FROM refs WHERE name >= ? AND name < ? ORDER BY name");
-	const listAllStmt = db.query("SELECT name FROM refs WHERE name LIKE 'refs/%' ORDER BY name");
+function createSqliteRefStore(conn) {
+	const selectStmt = conn.prepare("SELECT target FROM refs WHERE name = ?");
+	const selectExistsStmt = conn.prepare("SELECT 1 FROM refs WHERE name = ?");
+	const insertStmt = conn.prepare("INSERT OR REPLACE INTO refs (name, target) VALUES (?, ?)");
+	const deleteStmt = conn.prepare("DELETE FROM refs WHERE name = ?");
+	const listPrefixStmt = conn.prepare("SELECT name FROM refs WHERE name >= ? AND name < ? ORDER BY name");
+	const listAllStmt = conn.prepare("SELECT name FROM refs WHERE name LIKE 'refs/%' ORDER BY name");
+	const db = conn.db;
 	/**
 	* 开启一个新的事务
 	*

package/dist/repository/ops/object-operations.mjs

@@ -6,6 +6,18 @@ import { patchTree } from "../tree/tree-patch.mjs";
 * 仓库对象操作组装
 */
 /**
+* 空 tree 的规范原始对象
+*
+* 空 tree 序列化后内容为空，header 为 "tree 0\0"，
+* 其 SHA-1 是 Git 通用已知常数。
+* 预计算一份避免每次重复序列化和哈希。
+*/
+const EMPTY_TREE_RAW = {
+	hash: hashObject("tree", Buffer.alloc(0)),
+	type: "tree",
+	content: Buffer.alloc(0)
+};
+/**
 * 创建仓库对象相关操作
 *
 * @example
@@ -36,6 +48,10 @@ function createObjectRepositoryOperations(objects) {
 			return objects.list();
 		},
 		createTree(entries) {
+			if (entries.length === 0) {
+				objects.ingest(EMPTY_TREE_RAW);
+				return EMPTY_TREE_RAW.hash;
+			}
 			return writeObject(objects, {
 				type: "tree",
 				entries

package/dist/workdir/core.d.mts

@@ -169,7 +169,8 @@ interface VirtualWorkdir {
    * 复制路径
    *
    * 新建 workdir node，共享 origin，不共享 node 身份。
-   * 目录复制为浅复制，子项保持懒加载。
+   * 目录复制采用 CoW（写时复制）：子树节点共享同一份 origin 引用，
+   * 任一副本下的子项被修改时才会真正分裂出独立副本。
    */
   copy(from: string, to: string): void;
   /**

package/dist/workdir/directory-view.mjs

@@ -1,15 +1,6 @@
-import { VirtualNotDirectoryError } from "../core/errors.mjs";
-import { ensureNodeFromTreeEntry, joinChildPath, listDirectoryChildren } from "./workdir-path.mjs";
+import { ensureNodeFromTreeEntry, joinChildPath } from "./workdir-path.mjs";
 //#region src/workdir/directory-view.ts
 /**
-* Virtual Workdir 目录展开、观察与编译计划
-*
-* 从 workdir-path.ts 拆分，聚焦以下职责：
-* - 目录子项观察（observeDirectoryChildren / observeListedDirectoryChild / observeNamedDirectoryChild）
-* - origin 按名查询视图（createNamedOriginChildLookup）
-* - 受影响子项编译计划（planAffectedDirectoryChildren）
-*/
-/**
 * 在不展开整个目录列表的前提下，按名称定向解析单个子节点。
 *
 * 优先读取 overlay 绑定；若 overlay 未覆盖，再按需从 origin 条目懒注册。
@@ -71,78 +62,6 @@ function observeListedDirectoryChild(state, dirPath, child) {
 	};
 }
 /**
-* 基于目录节点与子项名称定向读取当前节点与完整路径。
-*
-* 适用于已持有 origin lookup、但不想手工重复拼装 `{ name, path, node }`
-* 局部协议的场景。
-*
-* @example
-* ```ts
-* const observed = observeNamedDirectoryChild(state, dirNode, "", lookup, "a.txt");
-* expect(observed?.path).toBe("a.txt");
-* ```
-*/
-function observeNamedDirectoryChild(state, dirNode, dirPath, originLookup, name) {
-	if (dirNode.state.kind !== "directory") return null;
-	const resolved = resolveNamedChild(state, dirNode, originLookup, name);
-	if (!resolved.found) return null;
-	return {
-		name,
-		path: joinChildPath(dirPath, name),
-		node: resolved.node
-	};
-}
-/**
-* 观察目录当前子项，归纳直接受影响名字与更深层脏项数。
-*
-* 目录自身 overlay 的 add/delete 会直接计入 `affectedNames`；
-* 子目录是否脏、叶子节点是否脏由调用方回调决定。
-*
-* @example
-* ```ts
-* const observed = observeDirectoryChildren(source, state, node, "", {
-*   onDirectoryChild() {
-*     return 0;
-*   },
-*   isLeafChildDirty() {
-*     return false;
-*   },
-* });
-* expect(observed.affectedNames.size).toBeGreaterThanOrEqual(0);
-* ```
-*/
-function observeDirectoryChildren(source, state, dirNode, dirPath, options) {
-	if (dirNode.state.kind !== "directory") throw new VirtualNotDirectoryError(dirPath);
-	const affectedNames = /* @__PURE__ */ new Set([...dirNode.state.overlay.addedEntries.keys(), ...dirNode.state.overlay.deletedNames.values()]);
-	let dirtyDescendantCount = 0;
-	const children = listDirectoryChildren(source, state, dirNode, dirPath);
-	for (const child of children) {
-		const observedChild = observeListedDirectoryChild(state, dirPath, child);
-		if (observedChild === null) continue;
-		if (observedChild.node.state.kind === "directory") {
-			const childDirtyCount = options.onDirectoryChild({
-				name: observedChild.name,
-				path: observedChild.path,
-				node: observedChild.node
-			});
-			if (childDirtyCount > 0) {
-				affectedNames.add(observedChild.name);
-				dirtyDescendantCount += childDirtyCount;
-			}
-			continue;
-		}
-		if (options.isLeafChildDirty({
-			name: observedChild.name,
-			path: observedChild.path,
-			node: observedChild.node
-		})) affectedNames.add(observedChild.name);
-	}
-	return {
-		affectedNames,
-		dirtyDescendantCount
-	};
-}
-/**
 * 为目录 origin 条目创建按名查询视图。
 *
 * @example
@@ -163,35 +82,5 @@ function createNamedOriginChildLookup(entries) {
 		}
 	};
 }
-/**
-* 基于 origin 顺序和受影响名字生成目录子项编译计划。
-*
-* 1. origin 中未受影响的条目保持原顺序并标记为直接复用
-* 2. origin 中受影响的条目保持原顺序并标记为需要编译
-* 3. 不在 origin 中的受影响名字补在末尾
-*
-* @example
-* ```ts
-* const plan = planAffectedDirectoryChildren(lookup, new Set(["b.txt", "c.txt"]));
-* expect(plan.map((entry) => entry.name)).toEqual(["a.txt", "b.txt", "c.txt"]);
-* ```
-*/
-function planAffectedDirectoryChildren(originLookup, affectedNames) {
-	const out = [];
-	for (const entry of originLookup.entries) out.push({
-		name: entry.name,
-		originEntry: entry,
-		shouldCompile: affectedNames.has(entry.name)
-	});
-	for (const name of affectedNames) {
-		if (originLookup.has(name)) continue;
-		out.push({
-			name,
-			originEntry: null,
-			shouldCompile: true
-		});
-	}
-	return out;
-}
 //#endregion
-export { createNamedOriginChildLookup, observeDirectoryChildren, observeListedDirectoryChild, observeNamedDirectoryChild, planAffectedDirectoryChildren };
+export { createNamedOriginChildLookup, observeListedDirectoryChild, resolveNamedChild };

package/dist/workdir/nodes.mjs

@@ -61,7 +61,8 @@ function revertNodeState(node) {
 	};
 }
 /**
-* 为 `copy` 创建新节点：共享 origin，目录为浅复制（子项绑定保留，但 nodeId 为新）
+* 为 `copy` 创建新节点：共享 origin，目录采用 CoW（写时复制）
+* （子项绑定保留，但 nodeId 为新；实际子树只在任一副本写入时分裂）
 */
 function cloneWorkdirNodeForCopy(source, newId) {
 	const origin = source.origin;

package/dist/workdir/sqlite-backend.d.mts

@@ -1,6 +1,5 @@
 import { ObjectDatabase } from "../core/types/odb.mjs";
 import { CreateVirtualWorkdirOptions, VirtualWorkdir } from "./core.mjs";
-import { Database } from "bun:sqlite";
 
 //#region src/workdir/sqlite-backend.d.ts
 /** SQLite 连接层的可选参数 */

package/dist/workdir/sqlite-backend.mjs

@@ -1,7 +1,7 @@
 import { sha1 } from "../core/types.mjs";
+import { acquireConnection } from "../backend/sqlite-pool.mjs";
 import { createRootDirectoryNode } from "./nodes.mjs";
 import { openVirtualWorkdir } from "./workdir.mjs";
-import { Database } from "bun:sqlite";
 //#region src/workdir/sqlite-backend.ts
 /**
 * Virtual Workdir SQLite backend
@@ -20,25 +20,26 @@ const WORKDIR_SQLITE_SCHEMA_VERSION = 6;
 * ```
 */
 function openSqliteVirtualWorkdir(source, dbPath, workdirKey, options) {
-	const db = new Database(dbPath);
-	if (options.walMode !== false) db.run("PRAGMA journal_mode = WAL");
-	ensureSchema(db);
-	const store = createSqliteVirtualWorkdirStateStore(db, workdirKey);
-	if (!hasWorkdir(db, workdirKey)) {
-		if (options.create !== true) {
-			db.close();
-			throw new Error(`Virtual workdir not found: ${workdirKey}`);
+	const conn = acquireConnection(dbPath, options.walMode !== false);
+	try {
+		ensureSchema(conn.db);
+		const store = createSqliteVirtualWorkdirStateStore(conn, workdirKey);
+		if (!hasWorkdir(conn.db, workdirKey)) {
+			if (options.create !== true) throw new Error(`Virtual workdir not found: ${workdirKey}`);
+			store.reset(options.baseTree);
 		}
-		store.reset(options.baseTree);
+		validateWorkdirIntegrity(conn.db, workdirKey);
+		let released = false;
+		const workdir = openVirtualWorkdir(source, store);
+		return Object.assign(workdir, { [Symbol.dispose]() {
+			if (released) return;
+			released = true;
+			conn.release();
+		} });
+	} catch (error) {
+		conn.release();
+		throw error;
 	}
-	validateWorkdirIntegrity(db, workdirKey);
-	let disposed = false;
-	const workdir = openVirtualWorkdir(source, store);
-	return Object.assign(workdir, { [Symbol.dispose]() {
-		if (disposed) return;
-		disposed = true;
-		db.close();
-	} });
 }
 /**
 * 删除指定 key 上的 SQLite VirtualWorkdir
@@ -49,14 +50,13 @@ function openSqliteVirtualWorkdir(source, dbPath, workdirKey, options) {
 * ```
 */
 function deleteSqliteVirtualWorkdir(dbPath, workdirKey, options = {}) {
-	const db = new Database(dbPath);
+	const conn = acquireConnection(dbPath, options.walMode !== false);
 	try {
-		if (options.walMode !== false) db.run("PRAGMA journal_mode = WAL");
-		ensureSchema(db);
-		if (!hasWorkdir(db, workdirKey)) throw new Error(`Virtual workdir not found: ${workdirKey}`);
-		deleteWorkdirRows(db, workdirKey);
+		ensureSchema(conn.db);
+		if (!hasWorkdir(conn.db, workdirKey)) throw new Error(`Virtual workdir not found: ${workdirKey}`);
+		deleteWorkdirRows(conn.db, workdirKey);
 	} finally {
-		db.close();
+		conn.release();
 	}
 }
 /**
@@ -64,18 +64,19 @@ function deleteSqliteVirtualWorkdir(dbPath, workdirKey, options = {}) {
 *
 * @example
 * ```ts
-* const store = createSqliteVirtualWorkdirStateStore(db, "demo");
+* using conn = acquireConnection("/tmp/workdir.sqlite");
+* const store = createSqliteVirtualWorkdirStateStore(conn, "demo");
 * expect(store.kind).toBe("sqlite");
 * ```
 */
-function createSqliteVirtualWorkdirStateStore(db, workdirKey) {
-	const transactImpl = db.transaction((fn) => fn());
-	const readBaseTreeStmt = db.query("SELECT base_tree FROM workdirs WHERE workdir_key = ?");
-	const upsertWorkdirStmt = db.query("INSERT INTO workdirs (workdir_key, base_tree) VALUES (?, ?) ON CONFLICT(workdir_key) DO UPDATE SET base_tree = excluded.base_tree");
-	const getNodeStmt = db.query(`SELECT node_id, origin_kind, origin_hash, origin_mode, state_kind, state_mode, content, target, directory_overlay
+function createSqliteVirtualWorkdirStateStore(conn, workdirKey) {
+	const transactImpl = conn.db.transaction((fn) => fn());
+	const readBaseTreeStmt = conn.prepare("SELECT base_tree FROM workdirs WHERE workdir_key = ?");
+	const upsertWorkdirStmt = conn.prepare("INSERT INTO workdirs (workdir_key, base_tree) VALUES (?, ?) ON CONFLICT(workdir_key) DO UPDATE SET base_tree = excluded.base_tree");
+	const getNodeStmt = conn.prepare(`SELECT node_id, origin_kind, origin_hash, origin_mode, state_kind, state_mode, content, target, directory_overlay
      FROM workdir_nodes
      WHERE workdir_key = ? AND node_id = ?`);
-	const setNodeStmt = db.query(`INSERT INTO workdir_nodes (
+	const setNodeStmt = conn.prepare(`INSERT INTO workdir_nodes (
         workdir_key, node_id, origin_kind, origin_hash, origin_mode,
         state_kind, state_mode, content, target, directory_overlay
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -88,16 +89,16 @@ function createSqliteVirtualWorkdirStateStore(db, workdirKey) {
         content = excluded.content,
         target = excluded.target,
         directory_overlay = excluded.directory_overlay`);
-	const deleteNodeStmt = db.query("DELETE FROM workdir_nodes WHERE workdir_key = ? AND node_id = ?");
-	const clearNodesStmt = db.query("DELETE FROM workdir_nodes WHERE workdir_key = ?");
-	const listChangesStmt = db.query(`SELECT path, previous_kind, previous_mode, previous_hash, current_kind, current_mode, current_hash, source_kind, source_path
+	const deleteNodeStmt = conn.prepare("DELETE FROM workdir_nodes WHERE workdir_key = ? AND node_id = ?");
+	const clearNodesStmt = conn.prepare("DELETE FROM workdir_nodes WHERE workdir_key = ?");
+	const listChangesStmt = conn.prepare(`SELECT path, previous_kind, previous_mode, previous_hash, current_kind, current_mode, current_hash, source_kind, source_path
      FROM workdir_changes
      WHERE workdir_key = ?
      ORDER BY path`);
-	const getChangeStmt = db.query(`SELECT path, previous_kind, previous_mode, previous_hash, current_kind, current_mode, current_hash, source_kind, source_path
+	const getChangeStmt = conn.prepare(`SELECT path, previous_kind, previous_mode, previous_hash, current_kind, current_mode, current_hash, source_kind, source_path
      FROM workdir_changes
      WHERE workdir_key = ? AND path = ?`);
-	const upsertChangeStmt = db.query(`INSERT INTO workdir_changes (
+	const upsertChangeStmt = conn.prepare(`INSERT INTO workdir_changes (
       workdir_key, path, previous_kind, previous_mode, previous_hash,
       current_kind, current_mode, current_hash, source_kind, source_path
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -110,16 +111,16 @@ function createSqliteVirtualWorkdirStateStore(db, workdirKey) {
       current_hash = excluded.current_hash,
       source_kind = excluded.source_kind,
       source_path = excluded.source_path`);
-	const deleteChangeStmt = db.query("DELETE FROM workdir_changes WHERE workdir_key = ? AND path = ?");
-	const clearChangesStmt = db.query("DELETE FROM workdir_changes WHERE workdir_key = ?");
-	const listDirtyDirsStmt = db.query(`SELECT path, is_dirty, dirty_entry_count, dirty_descendant_count, affected_names, current_tree_hash, hash_state
+	const deleteChangeStmt = conn.prepare("DELETE FROM workdir_changes WHERE workdir_key = ? AND path = ?");
+	const clearChangesStmt = conn.prepare("DELETE FROM workdir_changes WHERE workdir_key = ?");
+	const listDirtyDirsStmt = conn.prepare(`SELECT path, is_dirty, dirty_entry_count, dirty_descendant_count, affected_names, current_tree_hash, hash_state
      FROM workdir_dirty_dirs
      WHERE workdir_key = ?
      ORDER BY path`);
-	const getDirtyDirStmt = db.query(`SELECT path, is_dirty, dirty_entry_count, dirty_descendant_count, affected_names, current_tree_hash, hash_state
+	const getDirtyDirStmt = conn.prepare(`SELECT path, is_dirty, dirty_entry_count, dirty_descendant_count, affected_names, current_tree_hash, hash_state
      FROM workdir_dirty_dirs
      WHERE workdir_key = ? AND path = ?`);
-	const upsertDirtyDirStmt = db.query(`INSERT INTO workdir_dirty_dirs (
+	const upsertDirtyDirStmt = conn.prepare(`INSERT INTO workdir_dirty_dirs (
       workdir_key, path, is_dirty, dirty_entry_count, dirty_descendant_count,
       affected_names, current_tree_hash, hash_state
     )
@@ -131,9 +132,9 @@ function createSqliteVirtualWorkdirStateStore(db, workdirKey) {
        affected_names = excluded.affected_names,
        current_tree_hash = excluded.current_tree_hash,
        hash_state = excluded.hash_state`);
-	const deleteDirtyDirStmt = db.query("DELETE FROM workdir_dirty_dirs WHERE workdir_key = ? AND path = ?");
-	const clearDirtyDirsStmt = db.query("DELETE FROM workdir_dirty_dirs WHERE workdir_key = ?");
-	const resetTx = db.transaction((baseTree) => {
+	const deleteDirtyDirStmt = conn.prepare("DELETE FROM workdir_dirty_dirs WHERE workdir_key = ? AND path = ?");
+	const clearDirtyDirsStmt = conn.prepare("DELETE FROM workdir_dirty_dirs WHERE workdir_key = ?");
+	const resetTx = conn.db.transaction((baseTree) => {
 		upsertWorkdirStmt.run(workdirKey, baseTree);
 		clearNodesStmt.run(workdirKey);
 		clearChangesStmt.run(workdirKey);

package/dist/workdir/workdir.mjs

@@ -6,7 +6,6 @@ import { assertValidVirtualPath, normalizeDirectoryPath, parentPath, splitPathSe
 import { getDirectoryChildrenView, getRootNode, requireExistingWriteTarget, requireMissingWriteTarget, resolveLeafWriteTarget, resolvePath, resolveWriteTransfer } from "./workdir-path.mjs";
 import { createChangeIndexPlanner } from "./change-index-plan.mjs";
 import { computeVirtualDiff, rebuildNormalizedChangeIndex, refreshChangeRecordForPath, replaceChangeRecords, rewriteChangeRecordForRename, writeChangeRecordForCopy } from "./change-index.mjs";
-import { createDirtyDirPlanner } from "./dirty-dir-plan.mjs";
 import { revertNodeState } from "./nodes.mjs";
 import { createVirtualWorkdirMemoryStateStore } from "./memory-backend.mjs";
 import { cloneNodeGraphForCopy, runInWriteTransaction, statDirectoryNode, statNode, updateParentOverlay } from "./workdir-transaction.mjs";
@@ -88,7 +87,6 @@ function openVirtualWorkdir(source, state) {
 		rewriteRename: rewriteChangeIndexForRename,
 		writeCopy: writeChangeIndexForCopy
 	});
-	const dirtyDirPlanner = createDirtyDirPlanner(source, state);
 	refreshChangeIndex();
 	const createDirectoryAtPath = (path) => {
 		const target = requireMissingWriteTarget(source, state, path);
@@ -172,14 +170,7 @@ function openVirtualWorkdir(source, state) {
 		},
 		mkdir(path, options) {
 			const recursive = options?.recursive === true;
-			runInWriteTransaction(state, () => {
-				if (recursive) {
-					const segments = splitPathSegments(path);
-					const paths = [];
-					for (let i = 0; i < segments.length; i++) paths.push(segments.slice(0, i + 1).join("/"));
-					dirtyDirPlanner.rebuild(paths);
-				} else dirtyDirPlanner.rebuild([path]);
-			}, invalidateDiffCaches, () => {
+			runInWriteTransaction(state, null, invalidateDiffCaches, () => {
 				if (recursive) mkdirRecursive(path);
 				else createDirectoryAtPath(path);
 			});
@@ -187,7 +178,6 @@ function openVirtualWorkdir(source, state) {
 		writeFile(path, content, options) {
 			runInWriteTransaction(state, () => {
 				changeIndexPlanner.apply(changeIndexPlanner.planRefreshForPath(path));
-				dirtyDirPlanner.rebuild([path]);
 			}, invalidateDiffCaches, () => {
 				const mode = options?.mode ?? "100644";
 				const target = resolveLeafWriteTarget(source, state, path);
@@ -208,7 +198,6 @@ function openVirtualWorkdir(source, state) {
 		writeLink(path, target) {
 			runInWriteTransaction(state, () => {
 				changeIndexPlanner.apply(changeIndexPlanner.planRefreshForPath(path));
-				dirtyDirPlanner.rebuild([path]);
 			}, invalidateDiffCaches, () => {
 				const writeTarget = resolveLeafWriteTarget(source, state, path);
 				const nodeId = writeTarget.existing !== null ? writeTarget.existing.node.id : createNodeId();
@@ -231,7 +220,6 @@ function openVirtualWorkdir(source, state) {
 			}
 			runInWriteTransaction(state, () => {
 				changeIndexPlanner.apply(changeIndexPlanner.planRefreshForPath(path, { treatMissingAsIncremental: true }));
-				dirtyDirPlanner.rebuild([path]);
 			}, invalidateDiffCaches, () => {
 				const target = requireExistingWriteTarget(source, state, path);
 				updateParentOverlay(state, target.parentNode.id, overlayTombstoneEntry(target.parentNode.state.overlay, target.name));
@@ -240,13 +228,6 @@ function openVirtualWorkdir(source, state) {
 		move(from, to) {
 			runInWriteTransaction(state, () => {
 				changeIndexPlanner.apply(changeIndexPlanner.planRewriteForRename(from, to));
-				const dirtyPaths = [from, to];
-				const toParent = parentPath(to);
-				if (toParent !== null) {
-					const segments = splitPathSegments(toParent);
-					for (let i = 0; i < segments.length; i++) dirtyPaths.push(segments.slice(0, i + 1).join("/"));
-				}
-				dirtyDirPlanner.rebuild(dirtyPaths);
 			}, invalidateDiffCaches, () => {
 				assertValidVirtualPath(from);
 				assertValidVirtualPath(to);
@@ -271,7 +252,6 @@ function openVirtualWorkdir(source, state) {
 		copy(from, to) {
 			runInWriteTransaction(state, () => {
 				changeIndexPlanner.apply(changeIndexPlanner.planWriteForCopy(from, to));
-				dirtyDirPlanner.rebuild([from, to]);
 			}, invalidateDiffCaches, () => {
 				assertValidVirtualPath(from);
 				assertValidVirtualPath(to);
@@ -286,7 +266,6 @@ function openVirtualWorkdir(source, state) {
 		revert(path) {
 			runInWriteTransaction(state, () => {
 				changeIndexPlanner.apply(changeIndexPlanner.planRefreshForPath(path));
-				dirtyDirPlanner.rebuild([path]);
 			}, invalidateDiffCaches, () => {
 				assertValidVirtualPath(path);
 				const resolved = resolvePath(source, state, path);
@@ -306,7 +285,6 @@ function openVirtualWorkdir(source, state) {
 		reset(baseTree) {
 			runInWriteTransaction(state, null, invalidateDiffCaches, () => {
 				state.reset(baseTree);
-				dirtyDirPlanner.clear();
 			});
 		}
 	};

package/dist/workdir/write-tree.mjs

@@ -1,14 +1,19 @@
 import { writeObject } from "../objects/raw.mjs";
+import { originBackedNodeId } from "./ids.mjs";
 import { readRepoTree } from "./origin.mjs";
-import { listDirectoryChildren } from "./workdir-path.mjs";
-import { createNamedOriginChildLookup, observeListedDirectoryChild, observeNamedDirectoryChild, planAffectedDirectoryChildren } from "./directory-view.mjs";
-import { materializeDirtyDirSummary } from "./dirty-dir.mjs";
+import { joinChildPath } from "./workdir-path.mjs";
+import { createNamedOriginChildLookup, resolveNamedChild } from "./directory-view.mjs";
 //#region src/workdir/write-tree.ts
 /**
 * Virtual Workdir overlay -> tree 最小化编译
 *
-* 遍历 workdir 的目录 overlay，将受影响的目录重写为新 tree，
-* 未修改的 repo-backed 子树/文件尽量复用原对象哈希。
+* 采用 patchTree 式构造：从 change records + overlay 状态收集脏路径，
+* 沿受影响路径定向编译，只重写有变化的目录 tree 对象。
+*
+* 与旧实现的区别：
+* - 不依赖 DirtyDirSummary 预计算，writeFile/delete 等操作不再触发全量遍历
+* - 脏路径收集仅在 writeTree 时按需执行
+* - 已解析节点中的 overlay 修改通过定向遍历发现
 *
 * writeTree() 成功后不清空 overlay，不推进 baseTree。
 */
@@ -30,131 +35,166 @@ import { materializeDirtyDirSummary } from "./dirty-dir.mjs";
 function writeTreeFromSession(source, state) {
 	const root = state.getNode("root");
 	if (root === null || root.state.kind !== "directory") throw new Error("Virtual workdir: root node is missing or not a directory");
-	return compileDirectory(source, source, state, root);
+	const changes = /* @__PURE__ */ new Map();
+	for (const record of state.listChangeRecords()) changes.set(record.path, record);
+	return compileDirectory({
+		writeSource: source,
+		readSource: source,
+		state,
+		changes,
+		dirtyPaths: collectDirtyPaths(source, state, changes)
+	}, root, "");
 }
 /**
-* 递归编译目录 overlay -> 新 tree
+* 收集所有需要编译的目录路径。
 *
-* 返回新 tree 的 SHA-1（若目录无任何变化则直接复用 origin hash）。
+* 来源：
+* 1. Change records 中每条路径及其祖先
+* 2. 已解析节点中有 overlay 修改的目录及其祖先
 */
-function compileDirectory(writeSource, readSource, state, dirNode, dirPath = "") {
-	if (dirNode.state.kind !== "directory") throw new Error("compileDirectory called on non-directory node");
-	const summary = state.getDirtyDirSummary(dirPath);
-	if (summary !== null && summary.hashState === "materialized" && summary.currentTreeHash !== null) return summary.currentTreeHash;
-	if (summary === null && dirNode.origin.kind === "repo-tree") return dirNode.origin.hash;
-	let anyChanged = false;
-	const newEntries = collectCompiledEntries(writeSource, readSource, state, dirNode, dirPath, summary, (changed) => {
-		if (changed) anyChanged = true;
-	});
-	if (summary !== null && (summary.dirtyEntryCount > 0 || summary.dirtyDescendantCount > 0)) anyChanged = true;
-	if (!anyChanged && dirNode.origin.kind === "repo-tree") {
-		state.setDirtyDirSummary(materializeDirtyDirSummary(summary, dirPath, dirNode.origin.hash));
-		return dirNode.origin.hash;
-	}
-	newEntries.sort((a, b) => a.name.localeCompare(b.name));
-	const treeHash = writeObject(writeSource, {
-		type: "tree",
-		entries: newEntries
-	});
-	state.setDirtyDirSummary(materializeDirtyDirSummary(summary, dirPath, treeHash));
-	return treeHash;
+function collectDirtyPaths(source, state, changes) {
+	const dirty = /* @__PURE__ */ new Set();
+	for (const path of changes.keys()) addPathAndAncestors(dirty, path);
+	const root = state.getNode("root");
+	if (root !== null && root.state.kind === "directory") walkResolvedOverlayNodes(source, state, root, "", dirty);
+	return dirty;
 }
-function collectCompiledEntries(writeSource, readSource, state, dirNode, dirPath, summary, markChanged) {
-	if (dirNode.state.kind !== "directory") throw new Error("collectCompiledEntries called on non-directory node");
-	if (dirNode.origin.kind !== "repo-tree" || summary === null) return listDirectoryChildren(readSource, state, dirNode, dirPath).flatMap((child) => {
-		const observedChild = observeListedDirectoryChild(state, dirPath, child);
-		if (observedChild === null) return [];
-		const entry = compileChildEntry(writeSource, readSource, state, observedChild);
-		if (entry === null) return [];
-		markChanged(entry.changed);
-		return [entry.entry];
-	});
-	const originLookup = createNamedOriginChildLookup(readRepoTree(readSource, dirNode.origin.hash, dirPath).entries);
-	const childPlan = planAffectedDirectoryChildren(originLookup, collectAffectedChildNames(summary));
-	const out = [];
-	for (const planEntry of childPlan) {
-		if (!planEntry.shouldCompile) {
-			if (planEntry.originEntry === null) throw new Error(`collectCompiledEntries: missing origin entry for '${planEntry.name}'`);
-			out.push(planEntry.originEntry);
-			continue;
+/** 将路径及其所有祖先加入集合 */
+function addPathAndAncestors(dirty, path) {
+	dirty.add(path);
+	while (true) {
+		const slashIndex = path.lastIndexOf("/");
+		if (slashIndex < 0) {
+			if (path !== "") dirty.add("");
+			return;
 		}
-		const compiled = compileNamedChildEntry(writeSource, readSource, state, dirNode, dirPath, planEntry.name, originLookup);
-		if (compiled === null) continue;
-		markChanged(compiled.changed);
-		out.push(compiled.entry);
+		path = path.slice(0, slashIndex);
+		dirty.add(path);
 	}
-	return out;
 }
-function collectAffectedChildNames(summary) {
-	return new Set(summary.affectedNames);
+/**
+* 沿已解析节点遍历，将存在 overlay 修改的目录路径加入脏路径集。
+*
+* 仅遍历已在 state 中解析的节点（origin 子节点通过 ensureNodeFromTreeEntry
+* 懒注册时才会在 state 中存在），未解析的子树跳过。
+*/
+function walkResolvedOverlayNodes(source, state, node, dirPath, dirty) {
+	if (node.state.kind !== "directory") return;
+	if (isNodeOverlayDirty(node)) addPathAndAncestors(dirty, dirPath);
+	if (node.origin.kind === "repo-tree") {
+		const tree = readRepoTree(source, node.origin.hash, dirPath);
+		for (const entry of tree.entries) {
+			if (entry.mode !== "040000") continue;
+			const childId = originBackedNodeId(entry.hash);
+			const childNode = state.getNode(childId);
+			if (childNode === null) continue;
+			walkResolvedOverlayNodes(source, state, childNode, joinChildPath(dirPath, entry.name), dirty);
+		}
+	}
+	for (const [name, childId] of node.state.overlay.addedEntries) {
+		const childNode = state.getNode(childId);
+		if (childNode === null || childNode.state.kind !== "directory") continue;
+		walkResolvedOverlayNodes(source, state, childNode, joinChildPath(dirPath, name), dirty);
+	}
 }
-function compileNamedChildEntry(writeSource, readSource, state, dirNode, dirPath, name, originLookup) {
-	if (dirNode.state.kind !== "directory") throw new Error("compileNamedChildEntry called on non-directory node");
-	const observedChild = observeNamedDirectoryChild(state, dirNode, dirPath, originLookup, name);
-	if (observedChild === null) return null;
-	return compileChildEntry(writeSource, readSource, state, observedChild);
+function isNodeOverlayDirty(node) {
+	if (node.state.kind !== "directory") return false;
+	return node.state.overlay.addedEntries.size > 0 || node.state.overlay.deletedNames.size > 0;
 }
-function compileChildEntry(writeSource, readSource, state, child) {
-	const node = child.node;
-	if (node.state.kind === "directory") {
-		const newHash = compileDirectory(writeSource, readSource, state, node, child.path);
-		const originHash = node.origin.kind === "repo-tree" ? node.origin.hash : null;
-		return {
-			entry: {
-				mode: "040000",
-				name: child.name,
-				hash: newHash
-			},
-			changed: newHash !== originHash
-		};
+/**
+* 递归编译目录 -> tree 对象
+*
+* 返回新 tree 的 SHA-1（无变化时直接复用 origin hash）。
+*/
+function compileDirectory(ctx, dirNode, dirPath) {
+	if (dirNode.state.kind !== "directory") throw new Error("compileDirectory called on non-directory node");
+	if (!ctx.dirtyPaths.has(dirPath) && !isNodeOverlayDirty(dirNode) && dirNode.origin.kind === "repo-tree") return dirNode.origin.hash;
+	let originEntries = [];
+	if (dirNode.origin.kind === "repo-tree") originEntries = readRepoTree(ctx.readSource, dirNode.origin.hash, dirPath).entries;
+	const overlay = dirNode.state.overlay;
+	const treeEntries = [];
+	if (dirNode.origin.kind === "repo-tree") {
+		const lookup = createNamedOriginChildLookup(originEntries);
+		for (const originEntry of originEntries) {
+			if (overlay.deletedNames.has(originEntry.name)) continue;
+			if (overlay.addedEntries.has(originEntry.name)) continue;
+			const childPath = joinChildPath(dirPath, originEntry.name);
+			if (originEntry.mode === "040000") {
+				const resolved = resolveNamedChild(ctx.state, dirNode, lookup, originEntry.name);
+				if (resolved.found && resolved.node.state.kind === "directory") if (ctx.dirtyPaths.has(childPath) || isNodeOverlayDirty(resolved.node)) {
+					const hash = compileDirectory(ctx, resolved.node, childPath);
+					treeEntries.push({
+						mode: "040000",
+						name: originEntry.name,
+						hash
+					});
+				} else treeEntries.push(originEntry);
+				else if (resolved.found) {
+					const compiled = compileNodeToEntry(ctx, resolved.node, childPath, originEntry.name);
+					if (compiled !== null) treeEntries.push(compiled);
+				} else treeEntries.push(originEntry);
+			} else if (ctx.changes.has(childPath)) {
+				const resolved = resolveNamedChild(ctx.state, dirNode, lookup, originEntry.name);
+				if (resolved.found) {
+					const compiled = compileNodeToEntry(ctx, resolved.node, childPath, originEntry.name);
+					if (compiled !== null) treeEntries.push(compiled);
+				}
+			} else treeEntries.push(originEntry);
+		}
+	}
+	for (const [name, nodeId] of overlay.addedEntries) {
+		const childNode = ctx.state.getNode(nodeId);
+		if (childNode === null) continue;
+		const compiled = compileNodeToEntry(ctx, childNode, joinChildPath(dirPath, name), name);
+		if (compiled !== null) treeEntries.push(compiled);
 	}
+	treeEntries.sort((a, b) => a.name.localeCompare(b.name));
+	return writeObject(ctx.writeSource, {
+		type: "tree",
+		entries: treeEntries
+	});
+}
+function compileNodeToEntry(ctx, node, childPath, childName) {
+	if (node.state.kind === "directory") return {
+		mode: "040000",
+		name: childName,
+		hash: compileDirectory(ctx, node, childPath)
+	};
 	if (node.state.kind === "file") {
 		if (node.state.content !== void 0) {
-			const hash = writeObject(writeSource, {
+			const hash = writeObject(ctx.writeSource, {
 				type: "blob",
 				content: node.state.content
 			});
 			return {
-				entry: {
-					mode: node.state.mode,
-					name: child.name,
-					hash
-				},
-				changed: node.origin.kind !== "repo-blob" || hash !== node.origin.hash
+				mode: node.state.mode,
+				name: childName,
+				hash
 			};
 		}
 		if (node.origin.kind === "repo-blob") return {
-			entry: {
-				mode: node.state.mode,
-				name: child.name,
-				hash: node.origin.hash
-			},
-			changed: false
+			mode: node.state.mode,
+			name: childName,
+			hash: node.origin.hash
 		};
 		return null;
 	}
-	if (node.state.target !== void 0) {
-		const hash = writeObject(writeSource, {
-			type: "blob",
-			content: node.state.target
-		});
-		return {
-			entry: {
-				mode: "120000",
-				name: child.name,
-				hash
-			},
-			changed: node.origin.kind !== "repo-blob" || hash !== node.origin.hash
+	if (node.state.kind === "symlink") {
+		if (node.state.target !== void 0) return {
+			mode: "120000",
+			name: childName,
+			hash: writeObject(ctx.writeSource, {
+				type: "blob",
+				content: node.state.target
+			})
 		};
-	}
-	if (node.origin.kind === "repo-blob") return {
-		entry: {
+		if (node.origin.kind === "repo-blob") return {
 			mode: "120000",
-			name: child.name,
+			name: childName,
 			hash: node.origin.hash
-		},
-		changed: false
-	};
+		};
+		return null;
+	}
 	return null;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-git",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "files": [
     "dist"
   ],

package/dist/workdir/dirty-dir-plan.mjs

@@ -1,73 +0,0 @@
-import { getRootNode } from "./workdir-path.mjs";
-import { observeDirectoryChildren } from "./directory-view.mjs";
-import { createDirtyDirSummary } from "./dirty-dir.mjs";
-//#region src/workdir/dirty-dir-plan.ts
-/**
-* Virtual Workdir dirty-dir summary 重建策略
-*
-* 把 workdir 写路径里的脏目录摘要清理与重建逻辑集中到单独模块，
-* 让 workdir.ts 更接近纯编排层。
-*/
-/**
-* 创建 dirty-dir summary 策略器。
-*
-* @example
-* ```ts
-* const planner = createDirtyDirPlanner(source, state);
-* planner.rebuild(["src/index.ts"]);
-* ```
-*/
-function createDirtyDirPlanner(source, state) {
-	return {
-		clear() {
-			for (const summary of state.listDirtyDirSummaries()) state.deleteDirtyDirSummary(summary.path);
-		},
-		rebuild(touchedPaths) {
-			const nextSummaries = /* @__PURE__ */ new Map();
-			const invalidatedDirPaths = collectInvalidatedSummaryPaths(touchedPaths);
-			const visitDirectory = (node, dirPath) => {
-				if (node.state.kind !== "directory") throw new Error(`rebuildDirtyDirectorySummaries: '${dirPath}' is not a directory`);
-				const { affectedNames, dirtyDescendantCount } = observeDirectoryChildren(source, state, node, dirPath, {
-					onDirectoryChild(child) {
-						return visitDirectory(child.node, child.path);
-					},
-					isLeafChildDirty(child) {
-						return state.getChangeRecord(child.path) !== null;
-					}
-				});
-				if (affectedNames.size === 0 && dirtyDescendantCount === 0) return 0;
-				const existing = state.getDirtyDirSummary(dirPath);
-				const preserveHash = existing !== null && !invalidatedDirPaths.has(dirPath);
-				nextSummaries.set(dirPath, {
-					...createDirtyDirSummary(dirPath, Array.from(affectedNames)),
-					dirtyDescendantCount,
-					currentTreeHash: preserveHash ? existing.currentTreeHash : null,
-					hashState: preserveHash ? existing.hashState : "stale"
-				});
-				return affectedNames.size + dirtyDescendantCount;
-			};
-			visitDirectory(getRootNode(state), "");
-			for (const summary of state.listDirtyDirSummaries()) if (!nextSummaries.has(summary.path)) state.deleteDirtyDirSummary(summary.path);
-			for (const summary of nextSummaries.values()) state.setDirtyDirSummary(summary);
-		}
-	};
-}
-function collectInvalidatedSummaryPaths(paths) {
-	const out = /* @__PURE__ */ new Set();
-	for (const path of paths) {
-		out.add(path);
-		let cursor = path;
-		while (true) {
-			const slashIndex = cursor.lastIndexOf("/");
-			if (slashIndex < 0) {
-				out.add("");
-				break;
-			}
-			cursor = cursor.slice(0, slashIndex);
-			out.add(cursor);
-		}
-	}
-	return out;
-}
-//#endregion
-export { createDirtyDirPlanner };

package/dist/workdir/dirty-dir.mjs

@@ -1,32 +0,0 @@
-//#region src/workdir/dirty-dir.ts
-/**
-* 创建脏目录摘要记录
-*/
-function createDirtyDirSummary(path, affectedNames = []) {
-	const names = [...new Set(affectedNames)].sort((left, right) => left.localeCompare(right));
-	return {
-		path,
-		isDirty: true,
-		dirtyEntryCount: names.length,
-		dirtyDescendantCount: 0,
-		affectedNames: names,
-		currentTreeHash: null,
-		hashState: "stale"
-	};
-}
-/**
-* 将目录摘要标记为已物化 tree hash。
-*/
-function materializeDirtyDirSummary(current, path, treeHash) {
-	return {
-		path,
-		isDirty: true,
-		dirtyEntryCount: current?.dirtyEntryCount ?? 0,
-		dirtyDescendantCount: current?.dirtyDescendantCount ?? 0,
-		affectedNames: [...current?.affectedNames ?? []].sort((left, right) => left.localeCompare(right)),
-		currentTreeHash: treeHash,
-		hashState: "materialized"
-	};
-}
-//#endregion
-export { createDirtyDirSummary, materializeDirtyDirSummary };