screw-up 1.31.0 → 1.33.0

package/dist/{metadata-file-BWd04LhD.js → metadata-file-Case8fsm.js}

@@ -1,18 +1,20 @@
 /*!
 * name: screw-up
-* version: 1.31.0
+* version: 1.33.0
 * description: Simply package metadata inserter on Vite plugin
 * author: Kouji Matsui (@kekyo@mi.kekyo.net)
 * license: MIT
 * repository.url: https://github.com/kekyo/screw-up.git
-* git.commit.hash: ebb41ebf06ebe1bec39a3770c70a62cb95b4b7d6
+* git.commit.hash: be56ff1901b5073e1b0238a28b80d0c4f3c1e894
 */
-import fs, { mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
+import fs, { mkdir, open, readFile, readdir, stat, writeFile } from "fs/promises";
 import { existsSync } from "fs";
 import { basename, dirname, isAbsolute, join } from "path";
 import { glob } from "glob";
 import * as git from "isomorphic-git";
 import __screwUpDefaultImportModule0 from "isomorphic-git";
+import { createHash } from "crypto";
+import { inflateSync } from "zlib";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -1506,10 +1508,10 @@ var require_dayjs_min = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#region src/internal.ts
 var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
 var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
-var JSON5 = __resolveDefaultExport$3(import_dist.default, false);
-var dayjs$1 = __resolveDefaultExport$3(import_dayjs_min.default, false);
+var JSON5 = __resolveDefaultExport$2(import_dist.default, false);
+var dayjs$1 = __resolveDefaultExport$2(import_dayjs_min.default, false);
 globalThis.__screwUpIsInCJS_db7919f73ec9 = false;
-function __resolveDefaultExport$3(module, isESM) {
+function __resolveDefaultExport$2(module, isESM) {
 	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_db7919f73ec9 === true;
 	const maybe = module;
 	const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
@@ -1879,57 +1881,405 @@ var resolveRawPackageJsonObject = async (projectRoot, fetchGitMetadata, alwaysOv
 };
 //#endregion
 //#region src/git-ref-utils.ts
-var git$2 = __resolveDefaultExport$2(__screwUpDefaultImportModule0, false);
-globalThis.__screwUpIsInCJS_89cc61422477 = false;
-function __resolveDefaultExport$2(module, isESM) {
-	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_89cc61422477 === true;
-	const maybe = module;
-	const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
-	const unwrapNamespaceDefault = (value) => {
-		if (!value || typeof value !== "object") return value;
-		const inner = value;
-		if ((inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module") && "default" in inner) return inner.default;
-		return value;
-	};
-	const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
-	if (__isInCJS) return hasDefault ? resolvedDefault !== null && resolvedDefault !== void 0 ? resolvedDefault : module : module;
-	if (isESM) {
-		if (hasDefault) return resolvedDefault;
-		throw new Error("Default export not found.");
-	}
-	return hasDefault ? resolvedDefault !== null && resolvedDefault !== void 0 ? resolvedDefault : module : module;
-}
+var PACK_TRAILER_SIZE = 20;
+var LOOSE_TAG_RESOLUTION_CONCURRENCY = 4;
+var PACKED_OBJECT_TYPE_BY_CODE = new Map([
+	[1, "commit"],
+	[2, "tree"],
+	[3, "blob"],
+	[4, "tag"],
+	[6, "ofs-delta"],
+	[7, "ref-delta"]
+]);
 /**
-* Resolve the actual Git directory for repositories, worktrees, and submodules.
+* Resolve Git directory paths for repositories, worktrees, and submodules.
 * @param repoPath - Repository path
-* @returns The resolved Git directory path
+* @returns The resolved Git directory paths
 */
-var getActualGitDir = async (repoPath) => {
+var resolveGitDirectoryPaths = async (repoPath) => {
 	const gitDir = join(repoPath, ".git");
 	const gitStat = await stat(gitDir).catch(() => null);
-	if (!(gitStat === null || gitStat === void 0 ? void 0 : gitStat.isFile())) return gitDir;
-	const match = (await readFile(gitDir, "utf-8")).match(/^gitdir:\s*(.+)$/m);
-	if (!match) return gitDir;
-	return isAbsolute(match[1]) ? match[1] : join(repoPath, match[1]);
+	const resolvedGitDir = !(gitStat === null || gitStat === void 0 ? void 0 : gitStat.isFile()) ? gitDir : await (async () => {
+		const match = (await readFile(gitDir, "utf-8")).match(/^gitdir:\s*(.+)$/m);
+		if (!match) return gitDir;
+		return isAbsolute(match[1]) ? match[1] : join(repoPath, match[1]);
+	})();
+	return {
+		gitDir: resolvedGitDir,
+		commonGitDir: await readFile(join(resolvedGitDir, "commondir"), "utf-8").then((content) => {
+			const commondir = content.trim();
+			if (!commondir) return resolvedGitDir;
+			return isAbsolute(commondir) ? commondir : join(resolvedGitDir, commondir);
+		}).catch((error) => {
+			if ((error === null || error === void 0 ? void 0 : error.code) !== "ENOENT") throw error;
+			return resolvedGitDir;
+		})
+	};
+};
+/**
+* Resolve the worktree-specific Git directory.
+* @param repoPath - Repository path
+* @returns The resolved worktree-specific Git directory path
+*/
+var getActualGitDir = async (repoPath) => {
+	return (await resolveGitDirectoryPaths(repoPath)).gitDir;
 };
 /**
-* Resolve a tag object OID to the commit OID it ultimately points to.
-* Lightweight tags are returned unchanged.
+* Resolve the common Git directory used for refs and objects.
 * @param repoPath - Repository path
-* @param tagOid - Tag or commit OID
-* @returns Commit hash this tag points to
+* @returns The resolved common Git directory path
 */
-var resolveTagOidToCommit = async (repoPath, tagOid) => {
+var getCommonGitDir = async (repoPath) => {
+	return (await resolveGitDirectoryPaths(repoPath)).commonGitDir;
+};
+var readFixedRange = async (fileHandle, offset, length) => {
+	const buffer = Buffer.alloc(length);
+	const { bytesRead } = await fileHandle.read(buffer, 0, length, offset);
+	if (bytesRead !== length) throw new Error(`Unexpected EOF while reading pack entry at offset ${offset} (expected ${length}, got ${bytesRead})`);
+	return buffer;
+};
+var readLooseObject = async (gitDir, oid) => {
 	try {
-		var _tagObject$tag;
-		const tagObject = await git$2.readTag({
-			fs,
-			dir: repoPath,
-			oid: tagOid
+		const wrapped = inflateSync(await readFile(join(gitDir, "objects", oid.slice(0, 2), oid.slice(2))));
+		const headerEnd = wrapped.indexOf(0);
+		if (headerEnd < 0) throw new Error(`Invalid loose object header: ${oid}`);
+		const header = wrapped.subarray(0, headerEnd).toString("utf-8");
+		const match = header.match(/^(commit|tree|blob|tag) (\d+)$/);
+		if (!match) throw new Error(`Unsupported loose object header: ${header}`);
+		const content = wrapped.subarray(headerEnd + 1);
+		const expectedSize = Number(match[2]);
+		if (content.length !== expectedSize) throw new Error(`Loose object size mismatch: ${oid} (expected ${expectedSize}, got ${content.length})`);
+		return {
+			oid,
+			type: match[1],
+			content
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+};
+var readLargePackOffset = (idxBuffer, largeOffsetsStart, largeOffsetIndex) => {
+	const offset = Number(idxBuffer.readBigUInt64BE(largeOffsetsStart + largeOffsetIndex * 8));
+	if (!Number.isSafeInteger(offset)) throw new Error(`Pack offset exceeds safe integer range: ${offset}`);
+	return offset;
+};
+var loadPackIndex = async (idxPath) => {
+	const packPath = idxPath.replace(/\.idx$/, ".pack");
+	const [idxBuffer, packStat, fileHandle] = await Promise.all([
+		readFile(idxPath),
+		stat(packPath),
+		open(packPath, "r")
+	]);
+	if (idxBuffer.readUInt32BE(0) !== 4285812579) throw new Error(`Unsupported pack index signature: ${idxPath}`);
+	if (idxBuffer.readUInt32BE(4) !== 2) throw new Error(`Unsupported pack index version: ${idxPath}`);
+	const objectCount = idxBuffer.readUInt32BE(1028);
+	const oidStart = 1032;
+	const offsetStart = oidStart + objectCount * 20 + objectCount * 4;
+	const largeOffsetStart = offsetStart + objectCount * 4;
+	const objectByOid = /* @__PURE__ */ new Map();
+	const objectByOffset = /* @__PURE__ */ new Map();
+	const sortedObjects = [];
+	const packIndex = {
+		fileHandle,
+		objectByOid,
+		objectByOffset
+	};
+	for (let index = 0; index < objectCount; index++) {
+		const oidOffset = oidStart + index * 20;
+		const oid = idxBuffer.subarray(oidOffset, oidOffset + 20).toString("hex");
+		const rawOffset = idxBuffer.readUInt32BE(offsetStart + index * 4);
+		const offset = (rawOffset & 2147483648) === 0 ? rawOffset : readLargePackOffset(idxBuffer, largeOffsetStart, rawOffset & 2147483647);
+		sortedObjects.push({
+			oid,
+			offset
+		});
+	}
+	sortedObjects.sort((left, right) => left.offset - right.offset);
+	const packEndOffset = packStat.size - PACK_TRAILER_SIZE;
+	for (let index = 0; index < sortedObjects.length; index++) {
+		var _sortedObjects$offset, _sortedObjects;
+		const currentObject = sortedObjects[index];
+		const nextOffset = (_sortedObjects$offset = (_sortedObjects = sortedObjects[index + 1]) === null || _sortedObjects === void 0 ? void 0 : _sortedObjects.offset) !== null && _sortedObjects$offset !== void 0 ? _sortedObjects$offset : packEndOffset;
+		const location = {
+			oid: currentObject.oid,
+			offset: currentObject.offset,
+			nextOffset,
+			packIndex
+		};
+		objectByOid.set(currentObject.oid, location);
+		objectByOffset.set(currentObject.offset, location);
+	}
+	return packIndex;
+};
+var loadPackStore = async (gitDir) => {
+	try {
+		const packDir = join(gitDir, "objects", "pack");
+		const idxPaths = (await readdir(packDir)).filter((entryName) => entryName.endsWith(".idx")).map((entryName) => join(packDir, entryName));
+		const packs = await Promise.all(idxPaths.map(loadPackIndex));
+		const objectByOid = /* @__PURE__ */ new Map();
+		for (const pack of packs) for (const [oid, location] of pack.objectByOid.entries()) objectByOid.set(oid, location);
+		return {
+			packs,
+			objectByOid
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			packs: [],
+			objectByOid: /* @__PURE__ */ new Map()
+		};
+		throw error;
+	}
+};
+var decodeOfsDeltaDistance = (buffer, startOffset) => {
+	let cursor = startOffset;
+	let byte = buffer[cursor++];
+	let distance = byte & 127;
+	while (byte & 128) {
+		byte = buffer[cursor++];
+		distance = distance + 1 << 7 | byte & 127;
+	}
+	return {
+		distance,
+		nextOffset: cursor
+	};
+};
+var parsePackedEntryHeader = (entryBuffer, objectOffset) => {
+	let cursor = 0;
+	let byte = entryBuffer[cursor++];
+	const packedType = PACKED_OBJECT_TYPE_BY_CODE.get(byte >> 4 & 7);
+	if (!packedType) throw new Error(`Unsupported packed object type at offset ${objectOffset}`);
+	let declaredSize = byte & 15;
+	let shift = 4;
+	while (byte & 128) {
+		byte = entryBuffer[cursor++];
+		declaredSize |= (byte & 127) << shift;
+		shift += 7;
+	}
+	let baseOffset;
+	let baseOid;
+	if (packedType === "ofs-delta") {
+		const decoded = decodeOfsDeltaDistance(entryBuffer, cursor);
+		cursor = decoded.nextOffset;
+		baseOffset = objectOffset - decoded.distance;
+	} else if (packedType === "ref-delta") {
+		baseOid = entryBuffer.subarray(cursor, cursor + 20).toString("hex");
+		cursor += 20;
+	}
+	return {
+		packedType,
+		declaredSize,
+		headerLength: cursor,
+		baseOffset,
+		baseOid
+	};
+};
+var readDeltaSize = (buffer, startOffset) => {
+	let cursor = startOffset;
+	let size = 0;
+	let shift = 0;
+	while (cursor < buffer.length) {
+		const byte = buffer[cursor++];
+		size |= (byte & 127) << shift;
+		if ((byte & 128) === 0) return {
+			size,
+			nextOffset: cursor
+		};
+		shift += 7;
+	}
+	throw new Error("Invalid git delta size encoding");
+};
+var applyGitDelta = (baseContent, deltaContent) => {
+	const baseSizeInfo = readDeltaSize(deltaContent, 0);
+	if (baseSizeInfo.size !== baseContent.length) throw new Error(`Git delta base size mismatch: expected ${baseSizeInfo.size}, got ${baseContent.length}`);
+	const targetSizeInfo = readDeltaSize(deltaContent, baseSizeInfo.nextOffset);
+	const result = Buffer.alloc(targetSizeInfo.size);
+	let deltaOffset = targetSizeInfo.nextOffset;
+	let resultOffset = 0;
+	while (deltaOffset < deltaContent.length) {
+		const opcode = deltaContent[deltaOffset++];
+		if ((opcode & 128) !== 0) {
+			let copyOffset = 0;
+			let copySize = 0;
+			if (opcode & 1) copyOffset |= deltaContent[deltaOffset++];
+			if (opcode & 2) copyOffset |= deltaContent[deltaOffset++] << 8;
+			if (opcode & 4) copyOffset |= deltaContent[deltaOffset++] << 16;
+			if (opcode & 8) copyOffset |= deltaContent[deltaOffset++] << 24;
+			if (opcode & 16) copySize |= deltaContent[deltaOffset++];
+			if (opcode & 32) copySize |= deltaContent[deltaOffset++] << 8;
+			if (opcode & 64) copySize |= deltaContent[deltaOffset++] << 16;
+			if (copySize === 0) copySize = 65536;
+			baseContent.copy(result, resultOffset, copyOffset, copyOffset + copySize);
+			resultOffset += copySize;
+			continue;
+		}
+		if (opcode === 0) throw new Error("Invalid git delta opcode");
+		deltaContent.copy(result, resultOffset, deltaOffset, deltaOffset + opcode);
+		deltaOffset += opcode;
+		resultOffset += opcode;
+	}
+	if (resultOffset !== result.length) throw new Error(`Git delta size mismatch: expected ${result.length}, got ${resultOffset}`);
+	return result;
+};
+var inflatePackedObject = (compressedContent) => Buffer.from(inflateSync(compressedContent));
+var parseTagTargetOid = (tagContent) => {
+	const firstLineEnd = tagContent.indexOf(10);
+	const firstLine = firstLineEnd >= 0 ? tagContent.subarray(0, firstLineEnd).toString("utf-8") : tagContent.toString("utf-8");
+	const match = firstLine.match(/^object ([0-9a-f]{40})$/);
+	if (!match) throw new Error(`Invalid annotated tag payload: ${firstLine}`);
+	return match[1];
+};
+var parseTreeEntries = (treeContent) => {
+	const entries = [];
+	let offset = 0;
+	while (offset < treeContent.length) {
+		const modeEnd = treeContent.indexOf(32, offset);
+		if (modeEnd < 0) throw new Error("Invalid tree entry mode");
+		const nameEnd = treeContent.indexOf(0, modeEnd + 1);
+		if (nameEnd < 0 || nameEnd + 21 > treeContent.length) throw new Error("Invalid tree entry name");
+		entries.push({
+			mode: treeContent.subarray(offset, modeEnd).toString("utf-8"),
+			name: treeContent.subarray(modeEnd + 1, nameEnd).toString("utf-8"),
+			oid: treeContent.subarray(nameEnd + 1, nameEnd + 21).toString("hex")
+		});
+		offset = nameEnd + 21;
+	}
+	return entries;
+};
+var createGitObjectResolver = async (repoPath) => {
+	const commonGitDir = await getCommonGitDir(repoPath);
+	const resolvedObjects = /* @__PURE__ */ new Map();
+	let packStorePromise;
+	const getPackStore = async () => {
+		if (!packStorePromise) packStorePromise = loadPackStore(commonGitDir);
+		return packStorePromise;
+	};
+	const readPackedObject = async (location) => {
+		var _location$packIndex$o, _location$packIndex$o2, _header$baseOid;
+		const entryLength = location.nextOffset - location.offset;
+		const entryBuffer = await readFixedRange(location.packIndex.fileHandle, location.offset, entryLength);
+		const header = parsePackedEntryHeader(entryBuffer, location.offset);
+		const compressedContent = entryBuffer.subarray(header.headerLength);
+		if (header.packedType === "commit" || header.packedType === "tree" || header.packedType === "blob" || header.packedType === "tag") {
+			const content = inflatePackedObject(compressedContent);
+			if (content.length !== header.declaredSize) throw new Error(`Packed object size mismatch: ${location.oid} (expected ${header.declaredSize}, got ${content.length})`);
+			return {
+				oid: location.oid,
+				type: header.packedType,
+				content
+			};
+		}
+		const deltaContent = inflatePackedObject(compressedContent);
+		if (deltaContent.length !== header.declaredSize) throw new Error(`Packed delta size mismatch: ${location.oid} (expected ${header.declaredSize}, got ${deltaContent.length})`);
+		const baseObject = header.packedType === "ofs-delta" ? await readObject((_location$packIndex$o = (_location$packIndex$o2 = location.packIndex.objectByOffset.get(header.baseOffset)) === null || _location$packIndex$o2 === void 0 ? void 0 : _location$packIndex$o2.oid) !== null && _location$packIndex$o !== void 0 ? _location$packIndex$o : (() => {
+			throw new Error(`Missing ofs-delta base object at offset ${header.baseOffset}`);
+		})()) : await readObject((_header$baseOid = header.baseOid) !== null && _header$baseOid !== void 0 ? _header$baseOid : (() => {
+			throw new Error("Missing ref-delta base object id");
+		})());
+		const content = applyGitDelta(baseObject.content, deltaContent);
+		return {
+			oid: location.oid,
+			type: baseObject.type,
+			content
+		};
+	};
+	const readObject = async (oid) => {
+		const cachedObject = resolvedObjects.get(oid);
+		if (cachedObject) return cachedObject;
+		const objectPromise = (async () => {
+			const looseObject = await readLooseObject(commonGitDir, oid);
+			if (looseObject) return looseObject;
+			const location = (await getPackStore()).objectByOid.get(oid);
+			if (!location) throw new Error(`Git object not found: ${oid}`);
+			return readPackedObject(location);
+		})();
+		resolvedObjects.set(oid, objectPromise);
+		try {
+			return await objectPromise;
+		} catch (error) {
+			resolvedObjects.delete(oid);
+			throw error;
+		}
+	};
+	return {
+		close: async () => {
+			if (!packStorePromise) return;
+			const packStore = await packStorePromise;
+			await Promise.allSettled(packStore.packs.map(async (pack) => {
+				await pack.fileHandle.close();
+			}));
+		},
+		readObject,
+		resolveTagOidToCommit: async (tagOid) => {
+			let currentOid = tagOid;
+			const visitedOids = /* @__PURE__ */ new Set();
+			while (true) {
+				if (visitedOids.has(currentOid)) throw new Error(`Detected cyclic tag reference: ${currentOid}`);
+				visitedOids.add(currentOid);
+				const object = await readObject(currentOid);
+				if (object.type !== "tag") return currentOid;
+				currentOid = parseTagTargetOid(object.content);
+			}
+		}
+	};
+};
+var runWithConcurrency = async (values, concurrency, worker) => {
+	let nextIndex = 0;
+	const runWorker = async () => {
+		while (nextIndex < values.length) {
+			const currentIndex = nextIndex;
+			nextIndex += 1;
+			await worker(values[currentIndex]);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(concurrency, Math.max(values.length, 1)) }, () => runWorker()));
+};
+/**
+* Resolve multiple tag object OIDs to their peeled commit OIDs.
+* @param repoPath - Repository path
+* @param tagOids - Tag or commit OIDs
+* @returns Map of tag object OID to peeled commit OID
+*/
+var resolveTagOidsToCommits = async (repoPath, tagOids) => {
+	const resolver = await createGitObjectResolver(repoPath);
+	const result = /* @__PURE__ */ new Map();
+	const uniqueTagOids = Array.from(new Set(tagOids));
+	try {
+		await runWithConcurrency(uniqueTagOids, LOOSE_TAG_RESOLUTION_CONCURRENCY, async (tagOid) => {
+			result.set(tagOid, await resolver.resolveTagOidToCommit(tagOid));
 		});
-		if (tagObject === null || tagObject === void 0 || (_tagObject$tag = tagObject.tag) === null || _tagObject$tag === void 0 ? void 0 : _tagObject$tag.object) return tagObject.tag.object;
-	} catch (_unused) {}
-	return tagOid;
+	} finally {
+		await resolver.close();
+	}
+	return result;
+};
+var collectTreeFiles = async (resolver, treeOid, prefix, files) => {
+	const treeObject = await resolver.readObject(treeOid);
+	if (treeObject.type !== "tree") throw new Error(`Expected tree object: ${treeOid}`);
+	for (const entry of parseTreeEntries(treeObject.content)) {
+		const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+		if (entry.mode === "40000") {
+			await collectTreeFiles(resolver, entry.oid, path, files);
+			continue;
+		}
+		if (entry.mode !== "160000") files.set(path, entry.oid);
+	}
+};
+/**
+* Collect all tracked file blob OIDs under the specified tree.
+* @param repoPath - Repository path
+* @param treeOid - Tree object OID
+* @returns Map of repository-relative file path to blob OID
+*/
+var listTreeFiles = async (repoPath, treeOid) => {
+	const resolver = await createGitObjectResolver(repoPath);
+	const files = /* @__PURE__ */ new Map();
+	try {
+		await collectTreeFiles(resolver, treeOid, "", files);
+	} finally {
+		await resolver.close();
+	}
+	return files;
 };
 //#endregion
 //#region src/fast-tags.ts
@@ -1982,8 +2332,8 @@ var readLooseTags = async (refsTagsPath) => {
 * @returns Array of all tag names
 */
 var listTagsFast = async (repoPath) => {
-	const actualGitDir = await getActualGitDir(repoPath);
-	const [packedTags, looseTags] = await Promise.all([parsePackedRefs(join(actualGitDir, "packed-refs")), readLooseTags(join(actualGitDir, "refs", "tags"))]);
+	const commonGitDir = await getCommonGitDir(repoPath);
+	const [packedTags, looseTags] = await Promise.all([parsePackedRefs(join(commonGitDir, "packed-refs")), readLooseTags(join(commonGitDir, "refs", "tags"))]);
 	const allTags = new Set([...packedTags, ...looseTags]);
 	return Array.from(allTags).sort();
 };
@@ -1996,11 +2346,11 @@ var listTagsFast = async (repoPath) => {
 var resolveTagsBatchWithCommit = async (repoPath, tagNames, logger) => {
 	const startTime = Date.now();
 	const result = /* @__PURE__ */ new Map();
-	const actualGitDir = await getActualGitDir(repoPath);
+	const commonGitDir = await getCommonGitDir(repoPath);
 	const tagSet = new Set(tagNames);
 	const packedRefsStart = Date.now();
 	try {
-		const lines = (await readFile(join(actualGitDir, "packed-refs"), "utf-8")).split("\n");
+		const lines = (await readFile(join(commonGitDir, "packed-refs"), "utf-8")).split("\n");
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i];
 			if (line.startsWith("#") || !line.trim()) continue;
@@ -2023,19 +2373,28 @@ var resolveTagsBatchWithCommit = async (repoPath, tagNames, logger) => {
 	const remainingTags = tagNames.filter((tag) => !result.has(tag));
 	if (remainingTags.length > 0) {
 		const looseRefsStart = Date.now();
-		await Promise.all(remainingTags.map(async (tagName) => {
-			const looseRefPath = join(actualGitDir, "refs", "tags", tagName);
+		const looseTagEntries = (await Promise.all(remainingTags.map(async (tagName) => {
+			const looseRefPath = join(commonGitDir, "refs", "tags", tagName);
 			try {
-				const oid = (await readFile(looseRefPath, "utf-8")).trim();
-				const commitOid = await resolveTagOidToCommit(repoPath, oid);
+				return {
+					tagName,
+					oid: (await readFile(looseRefPath, "utf-8")).trim()
+				};
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+				return;
+			}
+		}))).filter((entry) => entry !== void 0);
+		if (looseTagEntries.length > 0) {
+			const commitOids = await resolveTagOidsToCommits(repoPath, looseTagEntries.map((entry) => entry.oid));
+			for (const { tagName, oid } of looseTagEntries) {
+				var _commitOids$get;
 				result.set(tagName, {
 					oid,
-					commitOid
+					commitOid: (_commitOids$get = commitOids.get(oid)) !== null && _commitOids$get !== void 0 ? _commitOids$get : oid
 				});
-			} catch (error) {
-				if (error.code !== "ENOENT") throw error;
 			}
-		}));
+		}
 		logger.debug(`[fast-tags] read loose refs: ${Date.now() - looseRefsStart}ms`);
 	}
 	const totalTime = Date.now() - startTime;
@@ -2231,16 +2590,26 @@ var formatVersion = (version) => {
 	return result;
 };
 /**
-* Get a commit by hash
+* Build a Git read context that can operate correctly inside worktrees.
 * @param repositoryPath - Local Git repository directory
+* @returns The resolved Git read context
+*/
+var createGitReadContext = async (repositoryPath) => ({
+	dir: repositoryPath,
+	gitdir: await getCommonGitDir(repositoryPath)
+});
+/**
+* Get a commit by hash
+* @param context - Git read context
 * @param hash - The hash of the commit
 * @returns The commit or undefined if the commit is not found
 */
-var getCommit = async (repositoryPath, hash) => {
+var getCommit = async (context, hash) => {
 	try {
 		const commit = await git.readCommit({
 			fs,
-			dir: repositoryPath,
+			dir: context.dir,
+			gitdir: context.gitdir,
 			oid: hash
 		});
 		return {
@@ -2248,7 +2617,8 @@ var getCommit = async (repositoryPath, hash) => {
 			shortHash: commit.oid.substring(0, 7),
 			date: (/* @__PURE__ */ new Date(commit.commit.author.timestamp * 1e3)).toISOString(),
 			message: commit.commit.message.trim(),
-			parents: commit.commit.parent || []
+			parents: commit.commit.parent || [],
+			tree: commit.commit.tree
 		};
 	} catch (_unused) {
 		return;
@@ -2256,19 +2626,20 @@ var getCommit = async (repositoryPath, hash) => {
 };
 /**
 * Get the current commit
-* @param repositoryPath - Local Git repository directory
+* @param context - Git read context
 * @returns The current commit or undefined if the current commit is not found
 */
-var getCurrentCommit = async (repositoryPath) => {
+var getCurrentCommit = async (context) => {
 	try {
 		const currentOid = await git.resolveRef({
 			fs,
-			dir: repositoryPath,
+			dir: context.dir,
 			ref: "HEAD"
 		});
 		const commit = await git.readCommit({
 			fs,
-			dir: repositoryPath,
+			dir: context.dir,
+			gitdir: context.gitdir,
 			oid: currentOid
 		});
 		return {
@@ -2276,7 +2647,8 @@ var getCurrentCommit = async (repositoryPath) => {
 			shortHash: commit.oid.substring(0, 7),
 			date: (/* @__PURE__ */ new Date(commit.commit.author.timestamp * 1e3)).toISOString(),
 			message: commit.commit.message.trim(),
-			parents: commit.commit.parent || []
+			parents: commit.commit.parent || [],
+			tree: commit.commit.tree
 		};
 	} catch (_unused2) {
 		return;
@@ -2293,21 +2665,23 @@ var getRelatedTagsFromMap = (commitToTags, commitHash) => {
 };
 /**
 * Get the commit related branch name.
-* @param repositoryPath - Local Git repository directory
+* @param context - Git read context
 * @param commitHash - The hash of the commit
 * @returns The commit related branch name or undefined if not found
 */
-var getRelatedBranches = async (repositoryPath, commitHash) => {
+var getRelatedBranches = async (context, commitHash) => {
 	try {
 		const branches = await git.listBranches({
 			fs,
-			dir: repositoryPath
+			dir: context.dir,
+			gitdir: context.gitdir
 		});
 		const relatedBranches = [];
 		for (const branch of branches) try {
 			if (await git.resolveRef({
 				fs,
-				dir: repositoryPath,
+				dir: context.dir,
+				gitdir: context.gitdir,
 				ref: branch
 			}) === commitHash) relatedBranches.push(branch);
 		} catch (_unused3) {}
@@ -2316,94 +2690,133 @@ var getRelatedBranches = async (repositoryPath, commitHash) => {
 		return [];
 	}
 };
-/**
-* Check if the repository has modified files (following RelaxVersioner logic).
-* Checks for staged files, unstaged files, and untracked files (respecting .gitignore).
-* @param repositoryPath - Local Git repository directory
-* @returns Modified files
-*/
-var isModifiedFile = ([, head, workdir, stage]) => {
-	return workdir === 2 || stage === 2 || stage === 3 || head === 1 && workdir === 0 || head === 0 && workdir === 1;
-};
-var getStatusRow = async (filepath, entries) => {
-	const [head, workdir, stage] = entries;
-	const [headType, workdirType, stageType] = await Promise.all([
-		head ? head.type() : void 0,
-		workdir ? workdir.type() : void 0,
-		stage ? stage.type() : void 0
-	]);
-	const isBlob = [
-		headType,
-		workdirType,
-		stageType
-	].includes("blob");
-	if ((headType === "tree" || headType === "special") && !isBlob) return;
-	if (headType === "commit") return;
-	if ((workdirType === "tree" || workdirType === "special") && !isBlob) return;
-	if (stageType === "commit") return;
-	if ((stageType === "tree" || stageType === "special") && !isBlob) return;
-	const headOid = headType === "blob" ? await head.oid() : void 0;
-	const stageOid = stageType === "blob" ? await stage.oid() : void 0;
-	let workdirOid;
-	if (headType !== "blob" && workdirType === "blob" && stageType !== "blob") workdirOid = "42";
-	else if (workdirType === "blob") workdirOid = await workdir.oid();
-	const entry = [
-		void 0,
-		headOid,
-		workdirOid,
-		stageOid
-	];
-	const statusValues = entry.map((value) => entry.indexOf(value));
-	return [
-		filepath,
-		statusValues[1],
-		statusValues[2],
-		statusValues[3]
-	];
-};
-var reduceModifiedFiles = async (parent, children) => {
-	const modifiedFiles = parent ? [parent] : [];
-	for (const child of children) modifiedFiles.push(...child);
-	return modifiedFiles;
-};
-var iterateSequentially = async (walk, children) => {
-	const results = [];
-	for (const child of children) results.push(await walk(child));
-	return results;
-};
-var getModifiedFiles = async (repositoryPath) => {
+var parseGitIndex = async (gitDir) => {
 	try {
-		return await git.walk({
-			fs,
-			dir: repositoryPath,
-			trees: [
-				git.TREE({ ref: "HEAD" }),
-				git.WORKDIR(),
-				git.STAGE()
-			],
-			map: async (filepath, entries) => {
-				const [head, workdir, stage] = entries;
-				if (!head && !stage && workdir) {
-					if (await git.isIgnored({
-						fs,
-						dir: repositoryPath,
-						filepath
-					})) return null;
+		const buffer = await fs.readFile(join(gitDir, "index"));
+		if (buffer.subarray(0, 4).toString("ascii") !== "DIRC") throw new Error("Unsupported git index signature");
+		const version = buffer.readUInt32BE(4);
+		if (version !== 2 && version !== 3) throw new Error(`Unsupported git index version: ${version}`);
+		const entryCount = buffer.readUInt32BE(8);
+		let offset = 12;
+		const entries = /* @__PURE__ */ new Map();
+		for (let index = 0; index < entryCount; index++) {
+			const entryStart = offset;
+			const size = buffer.readUInt32BE(entryStart + 36);
+			const oid = buffer.subarray(entryStart + 40, entryStart + 60).toString("hex");
+			const flags = buffer.readUInt16BE(entryStart + 60);
+			const stage = flags >> 12 & 3;
+			offset = entryStart + 62;
+			if (version >= 3 && (flags & 16384) !== 0) offset += 2;
+			const pathEnd = buffer.indexOf(0, offset);
+			if (pathEnd < 0) throw new Error("Invalid git index path entry");
+			const path = buffer.subarray(offset, pathEnd).toString("utf-8");
+			offset = pathEnd + 1;
+			while ((offset - entryStart) % 8 !== 0) offset += 1;
+			entries.set(path, {
+				path,
+				oid,
+				size,
+				stage
+			});
+		}
+		return entries;
+	} catch (error) {
+		if (error.code === "ENOENT") return /* @__PURE__ */ new Map();
+		throw error;
+	}
+};
+var listTrackedDirectories = (indexEntries) => {
+	const directories = new Set([""]);
+	for (const path of indexEntries.keys()) {
+		const segments = path.split("/");
+		let currentPath = "";
+		for (let index = 0; index < segments.length - 1; index++) {
+			currentPath = currentPath ? `${currentPath}/${segments[index]}` : segments[index];
+			directories.add(currentPath);
+		}
+	}
+	return directories;
+};
+var listWorkingDirectoryFiles = async (repositoryPath, trackedDirectories, relativePath = "") => {
+	const directoryPath = relativePath ? join(repositoryPath, relativePath) : repositoryPath;
+	const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		if (entry.name === ".git") continue;
+		const entryPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) {
+			if (!trackedDirectories.has(entryPath)) {
+				if (await git.isIgnored({
+					fs,
+					dir: repositoryPath,
+					filepath: entryPath
+				})) continue;
+			}
+			files.push(...await listWorkingDirectoryFiles(repositoryPath, trackedDirectories, entryPath));
+			continue;
+		}
+		if (entry.isFile() || entry.isSymbolicLink()) files.push(entryPath);
+	}
+	return files;
+};
+var calculateBlobOid = async (filePath) => {
+	const content = await fs.readFile(filePath);
+	return createHash("sha1").update(`blob ${content.length}\0`).update(content).digest("hex");
+};
+var getModifiedFiles = async (repositoryPath, headTreeOid) => {
+	try {
+		const gitDir = await getActualGitDir(repositoryPath);
+		const [headFiles, indexEntries] = await Promise.all([listTreeFiles(repositoryPath, headTreeOid), parseGitIndex(gitDir)]);
+		const workdirFiles = await listWorkingDirectoryFiles(repositoryPath, listTrackedDirectories(indexEntries));
+		const modifiedFiles = /* @__PURE__ */ new Map();
+		const rememberModifiedFile = (path, reason) => {
+			if (!modifiedFiles.has(path)) modifiedFiles.set(path, {
+				path,
+				reason
+			});
+		};
+		for (const [path, headOid] of headFiles.entries()) {
+			const indexEntry = indexEntries.get(path);
+			if (!indexEntry) rememberModifiedFile(path, "staged");
+			else if (indexEntry.stage !== 0 || indexEntry.oid !== headOid) rememberModifiedFile(path, "staged");
+		}
+		for (const indexEntry of indexEntries.values()) {
+			if (!headFiles.has(indexEntry.path)) rememberModifiedFile(indexEntry.path, "staged");
+			const absolutePath = join(repositoryPath, indexEntry.path);
+			try {
+				const stats = await fs.lstat(absolutePath);
+				if (!stats.isFile() && !stats.isSymbolicLink()) {
+					rememberModifiedFile(indexEntry.path, "worktree");
+					continue;
 				}
-				const statusRow = await getStatusRow(filepath, entries);
-				if (!statusRow || !isModifiedFile(statusRow)) return;
-				return statusRow;
-			},
-			reduce: reduceModifiedFiles,
-			iterate: iterateSequentially
-		});
+				if (indexEntry.stage !== 0) {
+					rememberModifiedFile(indexEntry.path, "staged");
+					continue;
+				}
+				if (indexEntry.size !== stats.size || await calculateBlobOid(absolutePath) !== indexEntry.oid) rememberModifiedFile(indexEntry.path, "worktree");
+			} catch (error) {
+				if (error.code === "ENOENT") {
+					rememberModifiedFile(indexEntry.path, "worktree");
+					continue;
+				}
+				throw error;
+			}
+		}
+		const trackedPaths = new Set(indexEntries.keys());
+		for (const filepath of workdirFiles) {
+			if (trackedPaths.has(filepath)) continue;
+			if (!await git.isIgnored({
+				fs,
+				dir: repositoryPath,
+				filepath
+			})) rememberModifiedFile(filepath, "untracked");
+		}
+		return Array.from(modifiedFiles.values());
 	} catch (_unused5) {
 		return [];
 	}
 };
-var formatModifiedFile = (modifiedFile) => {
-	return `'${modifiedFile[0]}':${modifiedFile[1]}:${modifiedFile[2]}:${modifiedFile[3]}`;
-};
+var formatModifiedFile = (modifiedFile) => `'${modifiedFile.path}':${modifiedFile.reason}`;
 /**
 * Lookup version label recursively core analyzer
 * @param cwd - The directory to check
@@ -2412,7 +2825,7 @@ var formatModifiedFile = (modifiedFile) => {
 * @param commitToTags - Map of commit hash to tags for performance
 * @returns The version or undefined if no version is found
 */
-var lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, commitToTags) => {
+var lookupVersionLabelRecursive = async (context, commit, reachedCommits, commitToTags) => {
 	const scheduledStack = [];
 	let version = {
 		major: 0,
@@ -2436,10 +2849,11 @@ var lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, commitToTa
 		try {
 			const parentHashes = (await git.readCommit({
 				fs,
-				dir: cwd,
+				dir: context.dir,
+				gitdir: context.gitdir,
 				oid: currentCommit.hash
 			})).commit.parent || [];
-			parentCommits = (await Promise.all(parentHashes.map((parentHash) => getCommit(cwd, parentHash)))).filter((ci) => ci !== void 0);
+			parentCommits = (await Promise.all(parentHashes.map((parentHash) => getCommit(context, parentHash)))).filter((ci) => ci !== void 0);
 		} catch (_unused6) {}
 		if (parentCommits.length === 0) {
 			reachedCommits.set(currentCommit.hash, version);
@@ -2454,7 +2868,7 @@ var lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, commitToTa
 	while (scheduledStack.length >= 1) {
 		const { commit: scheduledCommit, parents } = scheduledStack.pop();
 		if (parents.length >= 2) for (let index = 1; index < parents.length; index++) {
-			const alternateParentVersion = await lookupVersionLabelRecursive(cwd, parents[index], reachedCommits, commitToTags);
+			const alternateParentVersion = await lookupVersionLabelRecursive(context, parents[index], reachedCommits, commitToTags);
 			if (alternateParentVersion && compareVersions(alternateParentVersion, version) < 0) version = alternateParentVersion;
 		}
 		version = incrementLastVersionComponent(version);
@@ -2482,12 +2896,31 @@ var getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logger)
 		logger.debug(`[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`);
 		return metadata;
 	}
+	let gitContext;
 	try {
-		const currentCommit = await getCurrentCommit(gitRootPath);
-		if (!currentCommit) {
-			logger.debug(`[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`);
-			return metadata;
+		gitContext = await createGitReadContext(gitRootPath);
+	} catch (error) {
+		logger.warn(`Failed to resolve git metadata context: ${error}`);
+		logger.debug(`[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`);
+		return metadata;
+	}
+	const currentCommit = await getCurrentCommit(gitContext);
+	if (!currentCommit) {
+		logger.debug(`[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`);
+		return metadata;
+	}
+	const gitMetadata = {
+		tags: [],
+		branches: [],
+		commit: {
+			hash: currentCommit.hash,
+			shortHash: currentCommit.shortHash,
+			date: dayjs(currentCommit.date).format("YYYY-MM-DDTHH:mm:ssZ"),
+			message: currentCommit.message
 		}
+	};
+	metadata.git = gitMetadata;
+	try {
 		const buildStart = Date.now();
 		const commitToTags = await buildCompleteTagCache(gitRootPath, (tagName) => {
 			const version = parseVersion(tagName);
@@ -2495,15 +2928,10 @@ var getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logger)
 		}, logger);
 		logger.debug(`[screw-up] buildCompleteTagCache: ${Date.now() - buildStart}ms`);
 		logger.debug(`Built tag map with ${commitToTags.size} commits`);
-		let version = await lookupVersionLabelRecursive(gitRootPath, currentCommit, /* @__PURE__ */ new Map(), commitToTags);
-		const gitMetadata = {
-			tags: [],
-			branches: []
-		};
-		metadata.git = gitMetadata;
+		let version = await lookupVersionLabelRecursive(gitContext, currentCommit, /* @__PURE__ */ new Map(), commitToTags);
 		if (version) {
 			if (checkWorkingDirectoryStatus) {
-				const modifiedFiles = await getModifiedFiles(gitRootPath);
+				const modifiedFiles = await getModifiedFiles(gitRootPath, currentCommit.tree);
 				if (modifiedFiles.length >= 1) {
 					const newVersion = incrementLastVersionComponent(version);
 					logger.debug(`Increased git version by detected modified items: ${formatVersion(version)} ---> ${formatVersion(newVersion)}, Files=[${modifiedFiles.map(formatModifiedFile).join(", ")}]`);
@@ -2514,16 +2942,14 @@ var getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logger)
 			gitMetadata.version = gitVersion;
 			metadata.version = gitVersion;
 		}
-		gitMetadata.commit = {
-			hash: currentCommit.hash,
-			shortHash: currentCommit.shortHash,
-			date: dayjs(currentCommit.date).format("YYYY-MM-DDTHH:mm:ssZ"),
-			message: currentCommit.message
-		};
 		gitMetadata.tags = getRelatedTagsFromMap(commitToTags, currentCommit.hash).map((tag) => tag.name);
-		gitMetadata.branches = await getRelatedBranches(gitRootPath, currentCommit.hash);
 	} catch (error) {
-		logger.warn(`Failed to extract git metadata: ${error}`);
+		logger.warn(`Failed to resolve git versioning metadata: ${error}`);
+	}
+	try {
+		gitMetadata.branches = await getRelatedBranches(gitContext, currentCommit.hash);
+	} catch (error) {
+		logger.warn(`Failed to resolve git branch metadata: ${error}`);
 	}
 	logger.debug(`[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`);
 	return metadata;
@@ -2609,4 +3035,4 @@ var ensureMetadataGitignore = async (metadataSourcePath, logger) => {
 //#endregion
 export { collectWorkspaceSiblings as a, replacePeerDependenciesWildcards as c, require_dist as d, __exportAll as f, getFetchGitMetadata as i, resolvePackageMetadata as l, generateMetadataFileContent as n, createConsoleLogger as o, __toESM as p, writeFileIfChanged as r, findWorkspaceRoot as s, ensureMetadataGitignore as t, resolveRawPackageJsonObject as u };
 
-//# sourceMappingURL=metadata-file-BWd04LhD.js.map
+//# sourceMappingURL=metadata-file-Case8fsm.js.map