@ghfs/cli 0.1.0 → 0.2.0

package/dist/server-n1FLF8Xo.mjs

@@ -1,3331 +0,0 @@
-import { a as formatIssueNumber, n as normalizeReactions, t as createRepositoryProvider } from "./factory-DypZ8oi9.mjs";
-import { distDir } from "./dir.mjs";
-import process from "node:process";
-import { basename, dirname, isAbsolute, join, resolve } from "pathe";
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { createJiti } from "jiti";
-import { access, mkdir, readFile, readdir, rename, rm, stat, watch, writeFile } from "node:fs/promises";
-import * as v from "valibot";
-import { parse, stringify } from "yaml";
-import { randomBytes } from "node:crypto";
-import { Buffer } from "node:buffer";
-import { createServer } from "node:http";
-import { createBirpc } from "birpc";
-import { getPort } from "get-port-please";
-import { createApp, createRouter, eventHandler, serveStatic, setResponseHeader, setResponseStatus, toNodeListener } from "h3";
-import { parse as parse$1, stringify as stringify$1 } from "structured-clone-es";
-import { WebSocketServer } from "ws";
-import { hash } from "ohash";
-//#region src/constants.ts
-const CONFIG_FILE_CANDIDATES = [
-	"ghfs.config.ts",
-	"ghfs.config.mts",
-	"ghfs.config.mjs",
-	"ghfs.config.js",
-	"ghfs.config.cjs"
-];
-const ISSUE_DIR_NAME = "issues";
-const PULL_DIR_NAME = "pulls";
-const CLOSED_DIR_NAME = "closed";
-const SYNC_STATE_FILE_NAME = ".sync.json";
-const ISSUES_INDEX_FILE_NAME = "issues.md";
-const PULLS_INDEX_FILE_NAME = "pulls.md";
-const REPO_SNAPSHOT_FILE_NAME = "repo.json";
-const EXECUTE_FILE_NAME = "execute.yml";
-const EXECUTE_MD_FILE_NAME = "execute.md";
-const EXECUTE_SCHEMA_RELATIVE_PATH = "schema/execute.schema.json";
-//#endregion
-//#region src/config/load.ts
-async function loadUserConfig(cwd) {
-	const configPath = findConfigFile(cwd);
-	if (!configPath) return { config: {} };
-	return {
-		path: configPath,
-		config: extractUserConfig(await createJiti(resolve(cwd, "ghfs.config.ts"), { interopDefault: true }).import(configPath))
-	};
-}
-function extractUserConfig(loaded) {
-	if (!loaded || typeof loaded !== "object") return {};
-	if ("default" in loaded) {
-		const config = loaded.default;
-		if (config && typeof config === "object") return config;
-		return {};
-	}
-	return loaded;
-}
-async function resolveConfig(options = {}) {
-	const cwd = options.cwd ?? process.cwd();
-	const overrides = options.overrides ?? {};
-	const { config: userConfig } = await loadUserConfig(cwd);
-	const merged = mergeUserConfig(userConfig, overrides);
-	const directory = merged.directory ?? ".ghfs";
-	const configuredToken = merged.auth?.token?.trim() || "";
-	const repo = merged.repo?.trim() || "";
-	const issuesEnabled = merged.sync?.issues ?? true;
-	const pullsEnabled = merged.sync?.pulls ?? true;
-	const closedMode = merged.sync?.closed ?? false;
-	const patchesMode = merged.sync?.patches ?? "open";
-	return {
-		cwd,
-		repo,
-		directory,
-		auth: { token: configuredToken },
-		sync: {
-			issues: issuesEnabled,
-			pulls: pullsEnabled,
-			closed: closedMode,
-			patches: patchesMode
-		}
-	};
-}
-function getStorageDirAbsolute(config) {
-	return resolve(config.cwd, config.directory);
-}
-function getExecuteFile(config) {
-	return join(config.directory, EXECUTE_FILE_NAME);
-}
-function findConfigFile(cwd) {
-	for (const candidate of CONFIG_FILE_CANDIDATES) {
-		const fullPath = resolve(cwd, candidate);
-		if (existsSync(fullPath)) return fullPath;
-	}
-}
-function mergeUserConfig(base, overrides) {
-	return {
-		...base,
-		...overrides,
-		auth: {
-			...base.auth,
-			...overrides.auth
-		},
-		sync: {
-			...base.sync,
-			...overrides.sync
-		}
-	};
-}
-//#endregion
-//#region src/utils/fs.ts
-async function pathExists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function writeFileEnsured(path, content) {
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content, "utf8");
-}
-async function removePath(path) {
-	await rm(path, { force: true });
-}
-async function movePath(from, to) {
-	await mkdir(dirname(to), { recursive: true });
-	await rename(from, to);
-}
-async function removePatchIfExists(storageDirAbsolute, number) {
-	const pullsDir = join(storageDirAbsolute, PULL_DIR_NAME);
-	let entries;
-	try {
-		entries = await readdir(pullsDir, { withFileTypes: true });
-	} catch {
-		return 0;
-	}
-	const padded = String(number).padStart(5, "0");
-	let removed = 0;
-	for (const entry of entries) {
-		if (!entry.isFile()) continue;
-		const fileName = entry.name;
-		const isLegacyPatch = fileName === `${number}.patch`;
-		const isCurrentPatch = fileName.startsWith(`${padded}-`) && fileName.endsWith(".patch");
-		if (!isLegacyPatch && !isCurrentPatch) continue;
-		await removePath(join(pullsDir, fileName));
-		removed += 1;
-	}
-	return removed;
-}
-//#endregion
-//#region src/execute/actions.ts
-const ACTIONS_SUPPORTED = [
-	"close",
-	"close-with-comment",
-	"reopen",
-	"set-title",
-	"set-body",
-	"add-comment",
-	"add-labels",
-	"remove-labels",
-	"set-labels",
-	"add-assignees",
-	"remove-assignees",
-	"set-assignees",
-	"set-milestone",
-	"clear-milestone",
-	"lock",
-	"unlock",
-	"request-reviewers",
-	"remove-reviewers",
-	"mark-ready-for-review",
-	"convert-to-draft"
-];
-const ACTIONS_ALIAS_MAP = {
-	"open": "reopen",
-	"closes": "close",
-	"close-comment": "close-with-comment",
-	"comment-close": "close-with-comment",
-	"close-and-comment": "close-with-comment",
-	"comment-and-close": "close-with-comment",
-	"label": "add-labels",
-	"labels": "add-labels",
-	"tag": "add-labels",
-	"tags": "add-labels",
-	"add-tag": "add-labels",
-	"assign": "add-assignees",
-	"assignee": "add-assignees",
-	"assignees": "add-assignees",
-	"body": "set-body",
-	"title": "set-title",
-	"retitle": "set-title",
-	"ready": "mark-ready-for-review",
-	"undraft": "mark-ready-for-review",
-	"draft": "convert-to-draft",
-	"comment": "add-comment"
-};
-const ACTIONS_COLOR_HEX = {
-	"close": "#ef4444",
-	"close-with-comment": "#fb7185",
-	"reopen": "#22c55e",
-	"set-title": "#3b82f6",
-	"set-body": "#06b6d4",
-	"add-comment": "#f97316",
-	"add-labels": "#84cc16",
-	"remove-labels": "#f43f5e",
-	"set-labels": "#eab308",
-	"add-assignees": "#10b981",
-	"remove-assignees": "#fb7185",
-	"set-assignees": "#0ea5e9",
-	"set-milestone": "#6366f1",
-	"clear-milestone": "#f59e0b",
-	"lock": "#a855f7",
-	"unlock": "#14b8a6",
-	"request-reviewers": "#38bdf8",
-	"remove-reviewers": "#e879f9",
-	"mark-ready-for-review": "#34d399",
-	"convert-to-draft": "#f472b6"
-};
-const ACTION_NAMES_SET = new Set(ACTIONS_SUPPORTED);
-const ACTION_ALIASES = Object.keys(ACTIONS_ALIAS_MAP);
-const ACTION_INPUTS = [...ACTIONS_SUPPORTED, ...ACTION_ALIASES];
-function resolveActionName(action) {
-	const normalized = normalizeActionInput(action);
-	if (!normalized) return void 0;
-	if (ACTION_NAMES_SET.has(normalized)) return normalized;
-	return ACTIONS_ALIAS_MAP[normalized];
-}
-function normalizeActionInput(action) {
-	return action.trim().toLowerCase();
-}
-//#endregion
-//#region src/execute/schema.ts
-const executeSchema = {
-	$id: "https://ghfs.dev/schema/execute.json",
-	type: "array",
-	items: {
-		type: "object",
-		additionalProperties: true,
-		required: ["number", "action"],
-		properties: {
-			number: { type: "number" },
-			action: {
-				type: "string",
-				enum: [...ACTION_INPUTS]
-			},
-			ifUnchangedSince: {
-				type: "string",
-				format: "date-time"
-			},
-			title: { type: "string" },
-			body: { type: "string" },
-			labels: {
-				type: "array",
-				items: { type: "string" }
-			},
-			assignees: {
-				type: "array",
-				items: { type: "string" }
-			},
-			milestone: { anyOf: [{ type: "string" }, { type: "number" }] },
-			reviewers: {
-				type: "array",
-				items: { type: "string" }
-			},
-			reason: {
-				type: "string",
-				enum: [
-					"resolved",
-					"off-topic",
-					"too heated",
-					"too-heated",
-					"spam"
-				]
-			}
-		}
-	}
-};
-const EXECUTE_FILE_PLACEHOLDER = [
-	`# yaml-language-server: $schema=./${EXECUTE_SCHEMA_RELATIVE_PATH}`,
-	"# Add operations as YAML list items, then run: `ghfs execute`, examples:",
-	"#",
-	"# - action: close",
-	"#   number: 123",
-	""
-].join("\n");
-const EXECUTE_MD_FILE_PLACEHOLDER = [
-	"<!-- Add one action per line, then run: `ghfs execute`, examples: -->",
-	"",
-	"<!-- close #123 #124 -->",
-	"<!-- label #123 bug, triage -->",
-	"<!-- assign #123 antfu -->",
-	"<!-- comment #123 \"Need more context\" -->",
-	"<!-- close-comment #123 \"Closing as completed\" -->",
-	"<!-- set-title #123 \"new title\" -->",
-	"<!-- add-tag #123 foo, bar -->",
-	""
-].join("\n");
-async function writeExecuteSchema(storageDirAbsolute) {
-	const schemaPath = getExecuteSchemaPath(storageDirAbsolute);
-	await mkdir(dirname(schemaPath), { recursive: true });
-	await writeFile(schemaPath, `${JSON.stringify(executeSchema, null, 2)}\n`, "utf8");
-	return schemaPath;
-}
-async function ensureExecuteArtifacts(executeFilePath) {
-	const storageDirAbsolute = dirname(executeFilePath);
-	const [schemaPath] = await Promise.all([
-		ensureExecuteSchema(storageDirAbsolute),
-		ensureExecuteFile(executeFilePath),
-		ensureExecuteMdFile(storageDirAbsolute)
-	]);
-	return {
-		executeFilePath,
-		schemaPath
-	};
-}
-async function ensureExecuteSchema(storageDirAbsolute) {
-	const schemaPath = getExecuteSchemaPath(storageDirAbsolute);
-	if (await pathExists(schemaPath)) return schemaPath;
-	return writeExecuteSchema(storageDirAbsolute);
-}
-async function ensureExecuteFile(executeFilePath) {
-	if (await pathExists(executeFilePath)) return;
-	await mkdir(dirname(executeFilePath), { recursive: true });
-	await writeFile(executeFilePath, EXECUTE_FILE_PLACEHOLDER, "utf8");
-}
-async function ensureExecuteMdFile(storageDirAbsolute) {
-	const executeMdPath = join(storageDirAbsolute, EXECUTE_MD_FILE_NAME);
-	if (await pathExists(executeMdPath)) return;
-	await mkdir(dirname(executeMdPath), { recursive: true });
-	await writeFile(executeMdPath, EXECUTE_MD_FILE_PLACEHOLDER, "utf8");
-}
-function getExecuteSchemaPath(storageDirAbsolute) {
-	return join(storageDirAbsolute, EXECUTE_SCHEMA_RELATIVE_PATH);
-}
-//#endregion
-//#region src/execute/validate.ts
-const executeOpSchema = v.looseObject({
-	number: v.number(),
-	action: v.string(),
-	ifUnchangedSince: v.optional(v.string()),
-	title: v.optional(v.string()),
-	body: v.optional(v.string()),
-	labels: v.optional(v.array(v.string())),
-	assignees: v.optional(v.array(v.string())),
-	milestone: v.optional(v.union([v.string(), v.number()])),
-	reviewers: v.optional(v.array(v.string())),
-	reason: v.optional(v.picklist([
-		"resolved",
-		"off-topic",
-		"too heated",
-		"too-heated",
-		"spam"
-	]))
-});
-const executeFileSchema = v.array(executeOpSchema);
-async function readAndValidateExecuteFileWithSource(path) {
-	const raw = await readFile(path, "utf8");
-	let parsed;
-	try {
-		parsed = parse(raw || "[]") || [];
-	} catch (error) {
-		throw new Error(`Failed to parse execute YAML: ${error.message}`);
-	}
-	const parsedResult = v.safeParse(executeFileSchema, parsed);
-	if (!parsedResult.success) {
-		const message = parsedResult.issues.map((issue) => {
-			const path = issue.path?.map((segment) => String(segment.key)).join(".");
-			return `${path ? `${path}: ` : ""}${issue.message}`;
-		}).join("; ");
-		throw new Error(`Invalid execute file: ${message}`);
-	}
-	const { pending, sourceActions, actionErrors } = normalizeActionInputs(parsedResult.output);
-	if (actionErrors.length) throw new Error(`Invalid execute file: ${actionErrors.join("; ")}`);
-	const customErrors = validateExecuteRules(pending);
-	if (customErrors.length) throw new Error(`Invalid execute file: ${customErrors.join("; ")}`);
-	return {
-		ops: pending,
-		sourceActions
-	};
-}
-async function writeExecuteFile(path, pending) {
-	const content = stringify(pending);
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content.endsWith("\n") ? content : `${content}\n`, "utf8");
-}
-function validateExecuteRules(pending) {
-	const errors = [];
-	for (const [index, op] of pending.entries()) {
-		const key = `[${index}]`;
-		errors.push(...validateOperationRules(key, op));
-	}
-	return errors;
-}
-function validateOperationRules(key, op) {
-	const errors = [];
-	if (!Number.isInteger(op.number) || op.number <= 0) errors.push(`${key}: number must be a positive integer`);
-	switch (op.action) {
-		case "set-title":
-			if (!isNonEmptyString(op.title)) errors.push(`${key}: set-title requires title`);
-			break;
-		case "set-body":
-		case "add-comment":
-		case "close-with-comment":
-			if (!isNonEmptyString(op.body)) errors.push(`${key}: ${op.action} requires body`);
-			break;
-		case "add-labels":
-		case "remove-labels":
-		case "set-labels":
-			if (!isStringArray(op.labels)) errors.push(`${key}: ${op.action} requires labels[]`);
-			break;
-		case "add-assignees":
-		case "remove-assignees":
-		case "set-assignees":
-			if (!isStringArray(op.assignees)) errors.push(`${key}: ${op.action} requires assignees[]`);
-			break;
-		case "set-milestone":
-			if (!(typeof op.milestone === "string" || typeof op.milestone === "number")) errors.push(`${key}: set-milestone requires milestone`);
-			break;
-		case "request-reviewers":
-		case "remove-reviewers":
-			if (!isStringArray(op.reviewers)) errors.push(`${key}: ${op.action} requires reviewers[]`);
-			break;
-		default: break;
-	}
-	if (op.ifUnchangedSince && Number.isNaN(Date.parse(op.ifUnchangedSince))) errors.push(`${key}: ifUnchangedSince must be a valid datetime`);
-	return errors;
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.trim().length > 0;
-}
-function isStringArray(value) {
-	return Array.isArray(value) && value.every((entry) => typeof entry === "string") && value.length > 0;
-}
-function normalizeActionInputs(pending) {
-	const normalized = [];
-	const sourceActions = [];
-	const actionErrors = [];
-	for (const [index, op] of pending.entries()) {
-		const sourceAction = op.action;
-		sourceActions.push(sourceAction);
-		const action = resolveActionName(sourceAction);
-		if (!action) {
-			actionErrors.push(`[${index}]: unknown action: ${sourceAction}`);
-			continue;
-		}
-		normalized.push({
-			...op,
-			action
-		});
-	}
-	return {
-		pending: normalized,
-		sourceActions,
-		actionErrors
-	};
-}
-//#endregion
-//#region src/execute/sources/execute-md.ts
-const MULTI_SIMPLE_ACTIONS = new Set([
-	"close",
-	"reopen",
-	"clear-milestone",
-	"unlock",
-	"mark-ready-for-review",
-	"convert-to-draft"
-]);
-function parseExecuteMdLine(line) {
-	const trimmed = line.trim();
-	if (!trimmed || isCommentLine(trimmed)) return void 0;
-	const tokens = tokenizeCommand(trimmed);
-	if (!tokens) return {
-		kind: "warning",
-		message: "invalid quoted string syntax"
-	};
-	if (tokens.length === 0) return void 0;
-	const [commandInput, ...args] = tokens;
-	const command = resolveActionName(commandInput);
-	if (!command) return {
-		kind: "warning",
-		message: `unrecognized action pattern: ${commandInput}`
-	};
-	if (command === "set-title") return parseSetTitle(args);
-	if (command === "add-labels") return parseAddLabels(args, commandInput);
-	if (command === "add-assignees") return parseAddAssignees(args, commandInput);
-	if (command === "add-comment") return parseAddComment(args, commandInput);
-	if (command === "close-with-comment") return parseCloseWithComment(args, commandInput);
-	if (MULTI_SIMPLE_ACTIONS.has(command)) return parseMultiSimpleAction(command, args, commandInput);
-	return {
-		kind: "warning",
-		message: `unrecognized action pattern: ${commandInput}`
-	};
-}
-async function readExecuteMdFile(path) {
-	if (!await pathExists(path)) return parseExecuteMd("");
-	return parseExecuteMd(await readFile(path, "utf8"));
-}
-function parseExecuteMd(raw) {
-	const lines = raw.split(/\r?\n/);
-	const ops = [];
-	const parsedLines = [];
-	const warnings = [];
-	let inHtmlCommentBlock = false;
-	for (const [lineIndex, rawLine] of lines.entries()) {
-		const trimmed = rawLine.trim();
-		if (inHtmlCommentBlock) {
-			parsedLines.push({
-				kind: "raw",
-				raw: rawLine
-			});
-			if (trimmed.includes("-->")) inHtmlCommentBlock = false;
-			continue;
-		}
-		if (trimmed.startsWith("<!--")) {
-			parsedLines.push({
-				kind: "raw",
-				raw: rawLine
-			});
-			if (!trimmed.includes("-->")) inHtmlCommentBlock = true;
-			continue;
-		}
-		const parsed = parseExecuteMdLine(rawLine);
-		if (!parsed) {
-			parsedLines.push({
-				kind: "raw",
-				raw: rawLine
-			});
-			continue;
-		}
-		if (parsed.kind === "warning") {
-			warnings.push(`execute-md line ${lineIndex + 1}: ${parsed.message}`);
-			parsedLines.push({
-				kind: "raw",
-				raw: rawLine
-			});
-			continue;
-		}
-		if (parsed.kind === "single") {
-			const opIndex = ops.length;
-			ops.push(parsed.op);
-			parsedLines.push({
-				kind: "single",
-				raw: rawLine,
-				opIndex
-			});
-			continue;
-		}
-		const opIndexes = [];
-		for (const number of parsed.numbers) {
-			opIndexes.push(ops.length);
-			ops.push({
-				action: parsed.action,
-				number
-			});
-		}
-		parsedLines.push({
-			kind: "multi",
-			action: parsed.action,
-			command: parsed.command,
-			opIndexes
-		});
-	}
-	return {
-		ops,
-		warnings,
-		lines: parsedLines
-	};
-}
-function stringifyExecuteMd(parsed, remainingOpIndexes) {
-	const lines = [];
-	for (const line of parsed.lines) {
-		if (line.kind === "raw") {
-			lines.push(line.raw);
-			continue;
-		}
-		if (line.kind === "single") {
-			if (remainingOpIndexes.has(line.opIndex)) lines.push(line.raw);
-			continue;
-		}
-		const numbers = line.opIndexes.filter((index) => remainingOpIndexes.has(index)).map((index) => parsed.ops[index]?.number).filter((value) => typeof value === "number");
-		if (numbers.length > 0) lines.push(`${line.command} ${numbers.map((number) => `#${number}`).join(" ")}`);
-	}
-	return `${lines.join("\n")}\n`;
-}
-function parseSetTitle(args) {
-	if (args.length !== 2) return {
-		kind: "warning",
-		message: "set-title expects: set-title #<number> \"<title>\""
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: "set-title expects a single issue reference (#123)"
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "set-title",
-			number,
-			title: args[1]
-		}
-	};
-}
-function parseAddLabels(args, command) {
-	if (args.length < 2) return {
-		kind: "warning",
-		message: `${command} expects: ${command} #<number> <label1, label2>`
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: `${command} expects a single issue reference (#123)`
-	};
-	const labels = args.slice(1).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
-	if (labels.length === 0) return {
-		kind: "warning",
-		message: `${command} requires at least one label`
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "add-labels",
-			number,
-			labels
-		}
-	};
-}
-function parseAddAssignees(args, command) {
-	if (args.length < 2) return {
-		kind: "warning",
-		message: `${command} expects: ${command} #<number> <assignee1, assignee2>`
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: `${command} expects a single issue reference (#123)`
-	};
-	const assignees = args.slice(1).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
-	if (assignees.length === 0) return {
-		kind: "warning",
-		message: `${command} requires at least one assignee`
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "add-assignees",
-			number,
-			assignees
-		}
-	};
-}
-function parseAddComment(args, command) {
-	if (args.length < 2) return {
-		kind: "warning",
-		message: `${command} expects: ${command} #<number> "<comment>"`
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: `${command} expects a single issue reference (#123)`
-	};
-	const body = args.slice(1).join(" ").trim();
-	if (!body) return {
-		kind: "warning",
-		message: `${command} requires a non-empty comment`
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "add-comment",
-			number,
-			body
-		}
-	};
-}
-function parseCloseWithComment(args, command) {
-	if (args.length < 2) return {
-		kind: "warning",
-		message: `${command} expects: ${command} #<number> "<comment>"`
-	};
-	const number = parseIssueRef(args[0]);
-	if (!number) return {
-		kind: "warning",
-		message: `${command} expects a single issue reference (#123)`
-	};
-	const body = args.slice(1).join(" ").trim();
-	if (!body) return {
-		kind: "warning",
-		message: `${command} requires a non-empty comment`
-	};
-	return {
-		kind: "single",
-		op: {
-			action: "close-with-comment",
-			number,
-			body
-		}
-	};
-}
-function parseMultiSimpleAction(action, args, command) {
-	const numbers = args.map(parseIssueRef);
-	if (numbers.length === 0 || numbers.some((number) => !number)) return {
-		kind: "warning",
-		message: `${command} expects one or more issue references (#123 #456)`
-	};
-	return {
-		kind: "multi",
-		action,
-		command,
-		numbers
-	};
-}
-function parseIssueRef(value) {
-	const match = value.match(/^#(\d+)$/);
-	if (!match) return void 0;
-	const number = Number.parseInt(match[1], 10);
-	if (!Number.isInteger(number) || number <= 0) return void 0;
-	return number;
-}
-function tokenizeCommand(value) {
-	const tokens = [];
-	let index = 0;
-	while (index < value.length) {
-		while (index < value.length && /\s/.test(value[index])) index += 1;
-		if (index >= value.length) break;
-		if (value[index] === "\"") {
-			index += 1;
-			let token = "";
-			let closed = false;
-			while (index < value.length) {
-				const char = value[index];
-				if (char === "\\") {
-					const next = value[index + 1];
-					if (next === "\"" || next === "\\") {
-						token += next;
-						index += 2;
-						continue;
-					}
-				}
-				if (char === "\"") {
-					closed = true;
-					index += 1;
-					break;
-				}
-				token += char;
-				index += 1;
-			}
-			if (!closed) return void 0;
-			tokens.push(token);
-			continue;
-		}
-		const start = index;
-		while (index < value.length && !/\s/.test(value[index])) index += 1;
-		tokens.push(value.slice(start, index));
-	}
-	return tokens;
-}
-function isCommentLine(trimmed) {
-	return trimmed.startsWith("#") || trimmed.startsWith("//") || trimmed.startsWith("<!--");
-}
-//#endregion
-//#region package.json
-var version = "0.1.0";
-//#endregion
-//#region src/meta.ts
-const GHFS_NAME = "ghfs";
-const GHFS_VERSION = version;
-//#endregion
-//#region src/sync/state.ts
-function getSyncStatePath(storageDirAbsolute) {
-	return join(storageDirAbsolute, SYNC_STATE_FILE_NAME);
-}
-async function loadSyncState(storageDirAbsolute) {
-	const path = getSyncStatePath(storageDirAbsolute);
-	try {
-		const raw = await readFile(path, "utf8");
-		const parsed = JSON.parse(raw);
-		if (parsed.version !== 2) return createEmptySyncState();
-		return {
-			version: 2,
-			items: normalizeItems(parsed.items),
-			executions: normalizeExecutions(parsed.executions),
-			ghfsVersion: typeof parsed.ghfsVersion === "string" ? parsed.ghfsVersion : void 0,
-			repo: parsed.repo,
-			lastSyncedAt: parsed.lastSyncedAt,
-			lastSince: parsed.lastSince,
-			lastRepoUpdatedAt: parsed.lastRepoUpdatedAt,
-			lastSyncRun: parsed.lastSyncRun
-		};
-	} catch {
-		return createEmptySyncState();
-	}
-}
-function normalizeItems(items) {
-	if (!items) return {};
-	if (typeof items !== "object" || Array.isArray(items)) return {};
-	const normalizedItems = {};
-	for (const [key, item] of Object.entries(items)) {
-		const normalizedItem = normalizeItem(item);
-		if (!normalizedItem) continue;
-		normalizedItems[key] = normalizedItem;
-	}
-	return normalizedItems;
-}
-function normalizeExecutions(executions) {
-	if (!Array.isArray(executions)) return [];
-	return executions.map((execution) => {
-		if (!execution || typeof execution !== "object") return execution;
-		const typedExecution = execution;
-		if (typedExecution.mode === "dry-run") return {
-			...typedExecution,
-			mode: "report"
-		};
-		return typedExecution;
-	});
-}
-async function saveSyncState(storageDirAbsolute, state) {
-	await mkdir(storageDirAbsolute, { recursive: true });
-	const normalizedState = {
-		...state,
-		ghfsVersion: state.ghfsVersion ?? GHFS_VERSION
-	};
-	await writeFile(getSyncStatePath(storageDirAbsolute), `${JSON.stringify(normalizedState, null, 2)}\n`, "utf8");
-}
-function createEmptySyncState() {
-	return {
-		version: 2,
-		items: {},
-		executions: []
-	};
-}
-function appendExecution(state, result, limit = 20) {
-	const nextExecutions = [result, ...state.executions].slice(0, limit);
-	return {
-		...state,
-		executions: nextExecutions
-	};
-}
-function normalizeItem(item) {
-	if (!item || typeof item !== "object") return void 0;
-	if (!item.lastUpdatedAt || !item.lastSyncedAt || !item.filePath) return void 0;
-	if (!item.data || !item.data.item) return void 0;
-	const comments = Array.isArray(item.data.comments) ? item.data.comments : [];
-	const rawItem = item.data.item;
-	return {
-		...item,
-		data: {
-			...item.data,
-			item: {
-				...rawItem,
-				labels: Array.isArray(rawItem.labels) ? rawItem.labels.filter((v) => typeof v === "string") : [],
-				assignees: Array.isArray(rawItem.assignees) ? rawItem.assignees.filter((v) => typeof v === "string") : [],
-				reactions: normalizeReactions(rawItem.reactions)
-			},
-			comments: comments.filter((comment) => comment && typeof comment === "object").map((comment) => ({
-				...comment,
-				reactions: normalizeReactions(comment.reactions)
-			}))
-		}
-	};
-}
-//#endregion
-//#region src/execute/sources/per-item.ts
-async function loadPerItemSource(storageDir) {
-	const syncState = await loadSyncState(storageDir);
-	const ops = [];
-	const warnings = [];
-	const repo = syncState.repo;
-	for (const tracked of Object.values(syncState.items)) {
-		const markdownPath = join(storageDir, tracked.filePath);
-		if (!await pathExists(markdownPath)) {
-			warnings.push(`per-item: missing markdown for ${formatIssueNumber(tracked.number, { repo })} (${tracked.filePath})`);
-			continue;
-		}
-		const frontmatter = parseFrontmatter(await readFile(markdownPath, "utf8"));
-		if (!frontmatter) {
-			warnings.push(`per-item: invalid or missing frontmatter for ${formatIssueNumber(tracked.number, { repo })}`);
-			continue;
-		}
-		const trackedItem = tracked.data.item;
-		const itemOps = computePerItemOps({
-			number: tracked.number,
-			current: {
-				title: trackedItem.title,
-				state: trackedItem.state,
-				labels: trackedItem.labels,
-				assignees: trackedItem.assignees,
-				milestone: trackedItem.milestone
-			},
-			desired: frontmatter,
-			updatedAt: trackedItem.updatedAt
-		});
-		ops.push(...itemOps);
-	}
-	return {
-		ops,
-		warnings
-	};
-}
-function computePerItemOps(input) {
-	const ops = [];
-	const ifUnchangedSince = input.updatedAt;
-	if (input.current.title !== input.desired.title) ops.push({
-		action: "set-title",
-		number: input.number,
-		title: input.desired.title,
-		ifUnchangedSince
-	});
-	if (input.current.state !== input.desired.state) ops.push({
-		action: input.desired.state === "closed" ? "close" : "reopen",
-		number: input.number,
-		ifUnchangedSince
-	});
-	if (!sameStringSet(input.current.labels, input.desired.labels)) {
-		const additions = diffStrings(input.desired.labels, input.current.labels);
-		const deletions = diffStrings(input.current.labels, input.desired.labels);
-		if (additions.length > 0 && deletions.length > 0) ops.push({
-			action: "set-labels",
-			number: input.number,
-			labels: input.desired.labels,
-			ifUnchangedSince
-		});
-		else if (additions.length > 0) ops.push({
-			action: "add-labels",
-			number: input.number,
-			labels: additions,
-			ifUnchangedSince
-		});
-		else if (deletions.length > 0) ops.push({
-			action: "remove-labels",
-			number: input.number,
-			labels: deletions,
-			ifUnchangedSince
-		});
-	}
-	if (!sameStringSet(input.current.assignees, input.desired.assignees)) {
-		if (input.desired.assignees.length > 0) ops.push({
-			action: "set-assignees",
-			number: input.number,
-			assignees: input.desired.assignees,
-			ifUnchangedSince
-		});
-		else if (input.current.assignees.length > 0) ops.push({
-			action: "remove-assignees",
-			number: input.number,
-			assignees: input.current.assignees,
-			ifUnchangedSince
-		});
-	}
-	if (normalizeMilestone(input.current.milestone) !== normalizeMilestone(input.desired.milestone)) if (input.desired.milestone) ops.push({
-		action: "set-milestone",
-		number: input.number,
-		milestone: input.desired.milestone,
-		ifUnchangedSince
-	});
-	else ops.push({
-		action: "clear-milestone",
-		number: input.number,
-		ifUnchangedSince
-	});
-	return ops;
-}
-function parseFrontmatter(raw) {
-	const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-	if (!match) return void 0;
-	let parsed;
-	try {
-		parsed = parse(match[1]);
-	} catch {
-		return;
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
-	const data = parsed;
-	const title = typeof data.title === "string" && data.title.trim().length > 0 ? data.title.trim() : void 0;
-	const state = data.state === "open" || data.state === "closed" ? data.state : void 0;
-	if (!title || !state) return void 0;
-	return {
-		title,
-		state,
-		labels: normalizeStringArray(data.labels ?? data.tags),
-		assignees: normalizeStringArray(data.assignees),
-		milestone: normalizeMilestone(data.milestone)
-	};
-}
-function normalizeStringArray(value) {
-	if (!Array.isArray(value)) return [];
-	const unique = /* @__PURE__ */ new Set();
-	for (const entry of value) {
-		if (typeof entry !== "string") continue;
-		const normalized = entry.trim();
-		if (!normalized) continue;
-		unique.add(normalized);
-	}
-	return [...unique];
-}
-function sameStringSet(left, right) {
-	if (left.length !== right.length) return false;
-	const sortedLeft = [...left].sort();
-	const sortedRight = [...right].sort();
-	return sortedLeft.every((value, index) => value === sortedRight[index]);
-}
-function normalizeMilestone(value) {
-	if (typeof value !== "string") return null;
-	const normalized = value.trim();
-	return normalized.length > 0 ? normalized : null;
-}
-function diffStrings(source, target) {
-	const targetSet = new Set(target);
-	return source.filter((value) => !targetSet.has(value));
-}
-//#endregion
-//#region src/execute/sources/index.ts
-async function loadExecuteSources(executeFilePath) {
-	const storageDir = dirname(executeFilePath);
-	const executeMdPath = join(storageDir, EXECUTE_MD_FILE_NAME);
-	const yml = await readAndValidateExecuteFileWithSource(executeFilePath);
-	const ymlOps = yml.ops;
-	const executeMd = await readExecuteMdFile(executeMdPath);
-	const perItem = await loadPerItemSource(storageDir);
-	const mergedOps = [
-		...ymlOps,
-		...executeMd.ops,
-		...perItem.ops
-	];
-	const customErrors = validateExecuteRules(mergedOps);
-	if (customErrors.length) throw new Error(`Invalid execute file: ${customErrors.join("; ")}`);
-	return {
-		ops: mergedOps,
-		warnings: [...executeMd.warnings, ...perItem.warnings],
-		async writeRemaining(remainingIndexes) {
-			await writeExecuteFile(executeFilePath, ymlOps.map((op, index) => ({
-				op,
-				index
-			})).filter((item) => remainingIndexes.has(item.index)).map(({ op, index }) => ({
-				...op,
-				action: yml.sourceActions[index] ?? op.action
-			})));
-			if (!await pathExists(executeMdPath)) return;
-			const mdOffset = ymlOps.length;
-			const mdRemaining = /* @__PURE__ */ new Set();
-			for (const index of remainingIndexes) if (index >= mdOffset) mdRemaining.add(index - mdOffset);
-			await writeFile(executeMdPath, stringifyExecuteMd(executeMd, mdRemaining), "utf-8");
-		}
-	};
-}
-//#endregion
-//#region src/execute/index.ts
-var ExecuteCancelledError = class extends Error {
-	constructor() {
-		super("Execution cancelled");
-		this.name = "ExecuteCancelledError";
-	}
-};
-function isExecuteCancelledError(error) {
-	return error instanceof ExecuteCancelledError;
-}
-async function executePendingChanges(options) {
-	try {
-		await ensureExecuteArtifacts(options.executeFilePath);
-		const sources = await loadExecuteSources(options.executeFilePath);
-		const allOps = sources.ops;
-		for (const warning of sources.warnings) options.onWarning?.(warning);
-		if (allOps.length === 0) return {
-			runId: createRunId(),
-			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-			mode: "report",
-			repo: options.repo,
-			planned: 0,
-			applied: 0,
-			failed: 0,
-			details: []
-		};
-		const interactive = process.stdin.isTTY && !options.nonInteractive;
-		if (interactive && !options.prompts) throw new Error("Interactive execute prompts are unavailable. Use --non-interactive or provide prompts.");
-		const selected = Array.isArray(options.selectedIndexes) ? selectOperationsByIndexes(allOps, options.selectedIndexes) : interactive ? await selectOperations(allOps, options.prompts) : allOps.map((op, index) => ({
-			op,
-			index
-		}));
-		const runId = createRunId();
-		const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-		const mode = options.apply ? "apply" : "report";
-		options.reporter?.onStart?.({
-			repo: options.repo,
-			mode,
-			planned: selected.length
-		});
-		if (selected.length === 0) {
-			const result = {
-				runId,
-				createdAt,
-				mode,
-				repo: options.repo,
-				planned: 0,
-				applied: 0,
-				failed: 0,
-				details: []
-			};
-			options.reporter?.onComplete?.({ result });
-			return result;
-		}
-		options.onPlan?.(selected.map((item) => item.op));
-		if (!options.apply) {
-			const result = {
-				runId,
-				createdAt,
-				mode: "report",
-				repo: options.repo,
-				planned: selected.length,
-				applied: 0,
-				failed: 0,
-				details: selected.map(({ op, index }) => ({
-					op: index + 1,
-					action: op.action,
-					number: op.number,
-					status: "planned",
-					message: describeExecutionAction(op.action, op.number)
-				}))
-			};
-			options.reporter?.onComplete?.({ result });
-			return result;
-		}
-		if (interactive) {
-			if (!await confirmApply(selected.length, options.prompts)) throw new ExecuteCancelledError();
-		}
-		const provider = options.provider ?? createRepositoryProvider({
-			token: options.token,
-			repo: options.repo
-		});
-		const details = [];
-		const appliedIndexes = /* @__PURE__ */ new Set();
-		let applied = 0;
-		let failed = 0;
-		for (const { op, index } of selected) try {
-			const target = await applyOperation(provider, op);
-			appliedIndexes.add(index);
-			await persistRemainingOps(sources.writeRemaining, allOps, appliedIndexes);
-			const detail = {
-				op: index + 1,
-				action: op.action,
-				number: op.number,
-				target,
-				status: "applied",
-				message: describeExecutionAction(op.action, op.number)
-			};
-			details.push(detail);
-			applied += 1;
-			options.reporter?.onProgress?.({
-				repo: options.repo,
-				mode: "apply",
-				planned: selected.length,
-				completed: details.length,
-				applied,
-				failed,
-				detail
-			});
-		} catch (error) {
-			failed += 1;
-			const detail = {
-				op: index + 1,
-				action: op.action,
-				number: op.number,
-				status: "failed",
-				message: error.message
-			};
-			details.push(detail);
-			options.reporter?.onProgress?.({
-				repo: options.repo,
-				mode: "apply",
-				planned: selected.length,
-				completed: details.length,
-				applied,
-				failed,
-				detail
-			});
-			if (!options.continueOnError) break;
-		}
-		const result = {
-			runId,
-			createdAt,
-			mode: "apply",
-			repo: options.repo,
-			planned: selected.length,
-			applied,
-			failed,
-			details
-		};
-		options.reporter?.onComplete?.({ result });
-		return result;
-	} catch (error) {
-		options.reporter?.onError?.({ error });
-		throw error;
-	}
-}
-async function persistRemainingOps(writeRemaining, allOps, appliedIndexes) {
-	const remainingIndexes = /* @__PURE__ */ new Set();
-	for (const [index] of allOps.entries()) if (!appliedIndexes.has(index)) remainingIndexes.add(index);
-	await writeRemaining(remainingIndexes);
-}
-async function applyOperation(provider, op) {
-	const item = await provider.fetchItemSnapshot(op.number);
-	const isPull = item.kind === "pull";
-	if (op.ifUnchangedSince) {
-		const remoteUpdatedAt = item.updatedAt;
-		if (remoteUpdatedAt && new Date(remoteUpdatedAt).getTime() > new Date(op.ifUnchangedSince).getTime()) throw new Error(`Operation conflict: remote updated_at=${remoteUpdatedAt}`);
-	}
-	switch (op.action) {
-		case "close":
-			await provider.actionClose(op.number);
-			break;
-		case "reopen":
-			await provider.actionReopen(op.number);
-			break;
-		case "set-title":
-			await provider.actionSetTitle(op.number, op.title);
-			break;
-		case "set-body":
-			await provider.actionSetBody(op.number, op.body);
-			break;
-		case "add-comment":
-			await provider.actionAddComment(op.number, op.body);
-			break;
-		case "close-with-comment":
-			await provider.actionAddComment(op.number, op.body);
-			await provider.actionClose(op.number);
-			break;
-		case "add-labels":
-			await provider.actionAddLabels(op.number, op.labels);
-			break;
-		case "remove-labels":
-			await provider.actionRemoveLabels(op.number, op.labels);
-			break;
-		case "set-labels":
-			await provider.actionSetLabels(op.number, op.labels);
-			break;
-		case "add-assignees":
-			await provider.actionAddAssignees(op.number, op.assignees);
-			break;
-		case "remove-assignees":
-			await provider.actionRemoveAssignees(op.number, op.assignees);
-			break;
-		case "set-assignees":
-			await provider.actionSetAssignees(op.number, op.assignees);
-			break;
-		case "set-milestone":
-			await provider.actionSetMilestone(op.number, op.milestone);
-			break;
-		case "clear-milestone":
-			await provider.actionClearMilestone(op.number);
-			break;
-		case "lock":
-			await provider.actionLock(op.number, op.reason);
-			break;
-		case "unlock":
-			await provider.actionUnlock(op.number);
-			break;
-		case "request-reviewers":
-			ensurePullAction(op.action, op.number, isPull);
-			await provider.actionRequestReviewers(op.number, op.reviewers);
-			break;
-		case "remove-reviewers":
-			ensurePullAction(op.action, op.number, isPull);
-			await provider.actionRemoveReviewers(op.number, op.reviewers);
-			break;
-		case "mark-ready-for-review":
-			ensurePullAction(op.action, op.number, isPull);
-			await provider.actionMarkReadyForReview(op.number);
-			break;
-		case "convert-to-draft":
-			ensurePullAction(op.action, op.number, isPull);
-			await provider.actionConvertToDraft(op.number);
-			break;
-		default: throw new Error(`Unsupported action: ${String(op.action)}`);
-	}
-	return item.kind;
-}
-function createRunId() {
-	return `run_${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "")}_${Math.random().toString(36).slice(2, 7)}`;
-}
-async function selectOperations(ops, prompts) {
-	const selectedIndexes = await prompts.selectOperations(ops);
-	if (!selectedIndexes) throw new ExecuteCancelledError();
-	const selectedIndexesSet = new Set(selectedIndexes);
-	return ops.map((op, index) => ({
-		op,
-		index
-	})).filter((item) => selectedIndexesSet.has(item.index));
-}
-async function confirmApply(count, prompts) {
-	const result = await prompts.confirmApply(count);
-	if (result == null) return false;
-	return result;
-}
-function selectOperationsByIndexes(ops, selectedIndexes) {
-	const selectedSet = /* @__PURE__ */ new Set();
-	for (const index of selectedIndexes) if (Number.isInteger(index) && index >= 0 && index < ops.length) selectedSet.add(index);
-	return ops.map((op, index) => ({
-		op,
-		index
-	})).filter((item) => selectedSet.has(item.index));
-}
-function ensurePullAction(action, number, isPull) {
-	if (!isPull) throw new Error(`Action ${action} requires #${number} to be a pull request`);
-}
-function describeExecutionAction(action, number) {
-	return `${action} #${number}`;
-}
-//#endregion
-//#region src/sync/execution-log.ts
-async function appendExecutionResult(storageDirAbsolute, result) {
-	await saveSyncState(storageDirAbsolute, appendExecution(await loadSyncState(storageDirAbsolute), result));
-}
-//#endregion
-//#region src/utils/sync.ts
-function resolveSince(options, syncState) {
-	if (options.full) return void 0;
-	if (options.since) return options.since;
-	return syncState.lastSyncedAt;
-}
-function normalizeIssueNumbers(numbers) {
-	if (!numbers) return void 0;
-	return [...new Set(numbers.filter((number) => Number.isInteger(number) && number > 0))];
-}
-//#endregion
-//#region src/sync/markdown.ts
-const FIELDS_ALWAYS_KEEP = new Set(["labels", "assignees"]);
-const FIELDS_ALWAYS_EXCLUDE = new Set(["repo", "kind"]);
-const REACTION_FIELDS = [
-	{
-		key: "plusOne",
-		emoji: "👍"
-	},
-	{
-		key: "minusOne",
-		emoji: "👎"
-	},
-	{
-		key: "laugh",
-		emoji: "😄"
-	},
-	{
-		key: "hooray",
-		emoji: "🎉"
-	},
-	{
-		key: "confused",
-		emoji: "😕"
-	},
-	{
-		key: "heart",
-		emoji: "❤️"
-	},
-	{
-		key: "rocket",
-		emoji: "🚀"
-	},
-	{
-		key: "eyes",
-		emoji: "👀"
-	}
-];
-function renderIssueMarkdown(input) {
-	const url = input.url || `https://github.com/${input.repo}/${input.kind === "pull" ? "pull" : "issues"}/${input.number}`;
-	const frontmatter = {
-		repo: input.repo,
-		number: input.number,
-		kind: input.kind,
-		url,
-		state: input.state,
-		title: input.title,
-		author: input.author,
-		labels: input.labels,
-		assignees: input.assignees,
-		milestone: input.milestone,
-		created_at: input.createdAt,
-		updated_at: input.updatedAt,
-		closed_at: input.closedAt,
-		last_synced_at: input.lastSyncedAt,
-		reactions: formatReactionsFrontmatter(input.reactions),
-		is_draft: input.pr?.isDraft,
-		merged: input.pr?.merged,
-		merged_at: input.pr?.mergedAt,
-		base_ref: input.pr?.baseRef,
-		head_ref: input.pr?.headRef,
-		reviewers_requested: input.pr?.requestedReviewers
-	};
-	const compactFrontmatter = Object.fromEntries(Object.entries(frontmatter).filter(([key, value]) => {
-		if (FIELDS_ALWAYS_EXCLUDE.has(key)) return false;
-		if (FIELDS_ALWAYS_KEEP.has(key)) return true;
-		if (value === void 0 || value === null || value === false) return false;
-		if (Array.isArray(value)) return value.length > 0;
-		return true;
-	}));
-	const sections = [
-		`# ${input.title}`,
-		"",
-		"## Description",
-		"",
-		input.body?.trim() || "_No description._"
-	];
-	const bodyReactionsLine = formatReactionsLine(input.reactions);
-	if (bodyReactionsLine) {
-		sections.push("");
-		sections.push(bodyReactionsLine);
-	}
-	sections.push("");
-	sections.push("---");
-	sections.push("");
-	sections.push("## Comments");
-	sections.push("");
-	if (input.comments.length === 0) sections.push("_No comments._");
-	else for (const [index, comment] of input.comments.entries()) {
-		if (index > 0) {
-			sections.push("---");
-			sections.push("");
-		}
-		sections.push(`### @${comment.author} on ${comment.createdAt}`);
-		sections.push(`<!-- comment-id:${comment.id} updated:${comment.updatedAt} -->`);
-		sections.push("");
-		sections.push(comment.body?.trim() || "_No content._");
-		const reactionsLine = formatReactionsLine(comment.reactions);
-		if (reactionsLine) {
-			sections.push("");
-			sections.push(reactionsLine);
-		}
-		sections.push("");
-	}
-	return [
-		"---",
-		stringify(compactFrontmatter).trimEnd(),
-		"---",
-		"",
-		...sections,
-		""
-	].join("\n");
-}
-function formatReactionsLine(reactions) {
-	const entries = getReactionEntries(reactions);
-	if (entries.length === 0) return void 0;
-	return `> ${entries.map((entry) => `\`${entry.emoji} ${entry.count}\``).join(" | ")}`;
-}
-function formatReactionsFrontmatter(reactions) {
-	const entries = getReactionEntries(reactions);
-	if (entries.length === 0) return void 0;
-	return Object.fromEntries(entries.map((entry) => [entry.emoji, entry.count]));
-}
-function getReactionEntries(reactions) {
-	const normalized = normalizeReactions(reactions);
-	return REACTION_FIELDS.map(({ key, emoji }) => {
-		const count = normalized[key];
-		if (!count) return void 0;
-		return {
-			emoji,
-			count
-		};
-	}).filter((entry) => Boolean(entry));
-}
-//#endregion
-//#region src/utils/string.ts
-function slugifyTitle(title, maxLength = 48) {
-	const normalized = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-	if (!normalized) return "item";
-	return normalized.slice(0, maxLength).replace(/-+$/g, "") || "item";
-}
-//#endregion
-//#region src/sync/paths.ts
-const FILE_NUMBER_PAD_LENGTH = 5;
-const MAX_SLUG_LENGTH = 48;
-function getIssueMarkdownPath(storageDirAbsolute, number, state, title) {
-	const fileName = getItemFileName(number, title);
-	if (state === "closed") return join(storageDirAbsolute, ISSUE_DIR_NAME, CLOSED_DIR_NAME, fileName);
-	return join(storageDirAbsolute, ISSUE_DIR_NAME, fileName);
-}
-function getPullMarkdownPath(storageDirAbsolute, number, state, title) {
-	const fileName = getItemFileName(number, title);
-	if (state === "closed") return join(storageDirAbsolute, PULL_DIR_NAME, CLOSED_DIR_NAME, fileName);
-	return join(storageDirAbsolute, PULL_DIR_NAME, fileName);
-}
-function getItemMarkdownPath(storageDirAbsolute, kind, number, state, title) {
-	if (kind === "pull") return getPullMarkdownPath(storageDirAbsolute, number, state, title);
-	return getIssueMarkdownPath(storageDirAbsolute, number, state, title);
-}
-function getItemFileName(number, title) {
-	return `${String(number).padStart(FILE_NUMBER_PAD_LENGTH, "0")}-${slugifyTitle(title, MAX_SLUG_LENGTH)}.md`;
-}
-function getPrPatchPath(storageDirAbsolute, number, title) {
-	return join(storageDirAbsolute, PULL_DIR_NAME, getItemFileName(number, title).replace(/\.md$/, ".patch"));
-}
-//#endregion
-//#region src/sync/sync-repository-utils.ts
-function createCounters(scanned = 0, selected = 0) {
-	return {
-		scanned,
-		selected,
-		processed: 0,
-		skipped: 0,
-		written: 0,
-		moved: 0,
-		patchesWritten: 0,
-		patchesDeleted: 0
-	};
-}
-function addItemStats(counters, stats) {
-	counters.skipped += stats.skipped;
-	counters.written += stats.written;
-	counters.moved += stats.moved;
-	counters.patchesWritten += stats.patchesWritten;
-	counters.patchesDeleted += stats.patchesDeleted;
-}
-function shouldSyncKind(sync, kind) {
-	return kind === "issue" ? sync.issues : sync.pulls;
-}
-function shouldSyncIssue(sync, issue) {
-	return shouldSyncKind(sync, issue.kind);
-}
-function resolvePatchPlan(patchesMode, kind, state) {
-	if (kind !== "pull") return {
-		shouldWritePatch: false,
-		shouldDeletePatch: false
-	};
-	const shouldWritePatch = patchesMode === "all" || patchesMode === "open" && state === "open";
-	return {
-		shouldWritePatch,
-		shouldDeletePatch: !shouldWritePatch
-	};
-}
-function relativeToStorage(storageDirAbsolute, absolutePath) {
-	if (absolutePath.startsWith(storageDirAbsolute)) return absolutePath.slice(storageDirAbsolute.length + 1);
-	return basename(absolutePath);
-}
-//#endregion
-//#region src/sync/sync-repository-storage.ts
-async function resolveIssuePaths(storageDirAbsolute, kind, number, title, state, trackedFilePath) {
-	const closedPath = getItemMarkdownPath(storageDirAbsolute, kind, number, "closed", title);
-	const openPath = getItemMarkdownPath(storageDirAbsolute, kind, number, "open", title);
-	const hasClosedFile = await pathExists(closedPath);
-	const hasOpenFile = await pathExists(openPath);
-	const trackedPath = resolveTrackedPath(storageDirAbsolute, trackedFilePath);
-	const hasTrackedFile = trackedPath ? await pathExists(trackedPath) : false;
-	const targetPath = getItemMarkdownPath(storageDirAbsolute, kind, number, state, title);
-	const hasTargetFile = state === "open" ? hasOpenFile : hasClosedFile;
-	const matchedPaths = await findMatchedMarkdownPaths(storageDirAbsolute, kind, number, [
-		openPath,
-		closedPath,
-		trackedPath
-	]);
-	return {
-		openPath,
-		closedPath,
-		targetPath,
-		patchPath: getPrPatchPath(storageDirAbsolute, number, title),
-		trackedPath,
-		hasOpenFile,
-		hasClosedFile,
-		hasTrackedFile,
-		matchedPaths,
-		hasLocalFile: hasOpenFile || hasClosedFile || hasTrackedFile || matchedPaths.length > 0,
-		hasTargetFile
-	};
-}
-async function moveMarkdownByState(paths, state) {
-	const sourcePath = resolveMoveSourcePath(paths, state);
-	if (!sourcePath) return 0;
-	if (sourcePath === paths.targetPath) return 0;
-	if (await pathExists(paths.targetPath)) return 0;
-	await movePath(sourcePath, paths.targetPath);
-	return 1;
-}
-function resolveMoveSourcePath(paths, state) {
-	if (paths.hasTrackedFile && paths.trackedPath && paths.trackedPath !== paths.targetPath) return paths.trackedPath;
-	if (state === "open" && paths.hasClosedFile && paths.closedPath !== paths.targetPath) return paths.closedPath;
-	if (state === "closed" && paths.hasOpenFile && paths.openPath !== paths.targetPath) return paths.openPath;
-	if (paths.hasOpenFile && paths.openPath !== paths.targetPath) return paths.openPath;
-	if (paths.hasClosedFile && paths.closedPath !== paths.targetPath) return paths.closedPath;
-	return paths.matchedPaths.find((path) => path !== paths.targetPath);
-}
-function getExistingMarkdownPaths(paths) {
-	const markdownPaths = /* @__PURE__ */ new Set();
-	if (paths.hasOpenFile) markdownPaths.add(paths.openPath);
-	if (paths.hasClosedFile) markdownPaths.add(paths.closedPath);
-	if (paths.hasTrackedFile && paths.trackedPath) markdownPaths.add(paths.trackedPath);
-	for (const matchedPath of paths.matchedPaths) markdownPaths.add(matchedPath);
-	return [...markdownPaths];
-}
-function resolveTrackedPath(storageDirAbsolute, trackedFilePath) {
-	if (!trackedFilePath) return void 0;
-	if (isAbsolute(trackedFilePath)) return trackedFilePath;
-	return join(storageDirAbsolute, trackedFilePath);
-}
-function resolveTrackedPathOrJoin(storageDirAbsolute, trackedFilePath) {
-	return resolveTrackedPath(storageDirAbsolute, trackedFilePath) ?? join(storageDirAbsolute, trackedFilePath);
-}
-async function findMatchedMarkdownPaths(storageDirAbsolute, kind, number, knownPaths) {
-	const matchedPaths = /* @__PURE__ */ new Set();
-	const knownPathSet = new Set(knownPaths.filter(Boolean));
-	const padded = String(number).padStart(5, "0");
-	const kindDir = kind === "issue" ? ISSUE_DIR_NAME : PULL_DIR_NAME;
-	for (const stateDir of ["", CLOSED_DIR_NAME]) {
-		const dir = stateDir ? join(storageDirAbsolute, kindDir, stateDir) : join(storageDirAbsolute, kindDir);
-		let files;
-		try {
-			files = await readdir(dir);
-		} catch {
-			continue;
-		}
-		for (const fileName of files) {
-			if (!fileName.startsWith(`${padded}-`) || !fileName.endsWith(".md")) continue;
-			const fullPath = join(dir, fileName);
-			if (!knownPathSet.has(fullPath)) matchedPaths.add(fullPath);
-		}
-	}
-	return [...matchedPaths];
-}
-function updateTrackedItem(context, number, kind, state, issueUpdatedAt, markdownPath, patchPath, data) {
-	context.syncState.items[String(number)] = {
-		number,
-		kind,
-		state,
-		lastUpdatedAt: issueUpdatedAt,
-		lastSyncedAt: context.syncedAt,
-		filePath: relativeToStorage(context.storageDirAbsolute, markdownPath),
-		patchPath: patchPath ? relativeToStorage(context.storageDirAbsolute, patchPath) : void 0,
-		data
-	};
-}
-async function pruneTrackedClosedItems(storageDirAbsolute, syncState, sync) {
-	if (sync.issues) await rm(join(storageDirAbsolute, ISSUE_DIR_NAME, CLOSED_DIR_NAME), {
-		recursive: true,
-		force: true
-	});
-	if (sync.pulls) await rm(join(storageDirAbsolute, PULL_DIR_NAME, CLOSED_DIR_NAME), {
-		recursive: true,
-		force: true
-	});
-	let patchesDeleted = 0;
-	for (const item of Object.values(syncState.items)) {
-		if (item.state !== "closed") continue;
-		if (!shouldSyncKind(sync, item.kind)) continue;
-		await removePath(resolveTrackedPathOrJoin(storageDirAbsolute, item.filePath));
-		if (item.kind === "pull") patchesDeleted += await removePatchIfExists(storageDirAbsolute, item.number);
-		delete syncState.items[String(item.number)];
-	}
-	return patchesDeleted;
-}
-async function pruneMissingOpenTrackedItems(storageDirAbsolute, syncState, openNumbers, sync) {
-	let patchesDeleted = 0;
-	for (const item of Object.values(syncState.items)) {
-		if (item.state !== "open") continue;
-		if (!shouldSyncKind(sync, item.kind)) continue;
-		if (openNumbers.has(item.number)) continue;
-		await removePath(resolveTrackedPathOrJoin(storageDirAbsolute, item.filePath));
-		if (item.kind === "pull") patchesDeleted += await removePatchIfExists(storageDirAbsolute, item.number);
-		delete syncState.items[String(item.number)];
-	}
-	return patchesDeleted;
-}
-//#endregion
-//#region src/sync/sync-repository-item.ts
-async function prepareIssueCandidateSync(context, issue) {
-	const number = issue.number;
-	const kind = issue.kind;
-	const state = issue.state;
-	const tracked = context.syncState.items[String(number)];
-	const paths = await resolveIssuePaths(context.storageDirAbsolute, kind, number, issue.title, state, tracked?.filePath);
-	const patchPlan = resolvePatchPlan(context.config.sync.patches, kind, state);
-	if (state === "closed" && context.config.sync.closed === false) {
-		delete context.syncState.items[String(number)];
-		return {
-			number,
-			kind,
-			state,
-			action: "remove",
-			paths,
-			patchPlan
-		};
-	}
-	if (state === "closed" && context.config.sync.closed === true && !paths.hasLocalFile) {
-		delete context.syncState.items[String(number)];
-		return {
-			number,
-			kind,
-			state,
-			action: "remove",
-			paths,
-			patchPlan
-		};
-	}
-	const hasCanonicalData = Boolean(tracked?.data && (kind !== "pull" || tracked.data.pull));
-	const shouldRefetch = !tracked || tracked.lastUpdatedAt !== issue.updatedAt || !hasCanonicalData;
-	const data = shouldRefetch ? await fetchCanonicalData(context, issue) : tracked.data;
-	updateTrackedItem(context, number, kind, state, issue.updatedAt, paths.targetPath, patchPlan.shouldWritePatch ? paths.patchPath : void 0, data);
-	return {
-		number,
-		kind,
-		state,
-		action: resolveSyncAction(shouldRefetch, paths, state),
-		paths,
-		patchPlan
-	};
-}
-async function materializePreparedIssue(context, candidate) {
-	const { number, kind, state, action, patchPlan, paths } = candidate;
-	if (action === "remove") {
-		for (const markdownPath of getExistingMarkdownPaths(paths)) await removePath(markdownPath);
-		let patchesDeleted = 0;
-		if (kind === "pull") patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
-		return {
-			kind,
-			action,
-			skipped: 0,
-			written: 0,
-			moved: 0,
-			patchesWritten: 0,
-			patchesDeleted
-		};
-	}
-	if (action === "skip") {
-		let patchesDeleted = 0;
-		if (patchPlan.shouldDeletePatch) patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
-		return {
-			kind,
-			action,
-			skipped: 1,
-			written: 0,
-			moved: 0,
-			patchesWritten: 0,
-			patchesDeleted
-		};
-	}
-	const tracked = context.syncState.items[String(number)];
-	if (!tracked) throw new Error(`Missing tracked canonical data for ${formatIssueNumber(number, {
-		repo: context.repoSlug,
-		kind
-	})}`);
-	const markdown = buildTrackedMarkdown(context, tracked);
-	const moved = await moveMarkdownByState(paths, state);
-	await writeFileEnsured(paths.targetPath, markdown);
-	const patchStats = await syncPatchByPlan(context, number, paths.patchPath, patchPlan);
-	return {
-		kind,
-		action,
-		skipped: 0,
-		written: 1,
-		moved,
-		patchesWritten: patchStats.patchesWritten,
-		patchesDeleted: patchStats.patchesDeleted
-	};
-}
-async function rematerializeTrackedMarkdown(context) {
-	let processed = 0;
-	let written = 0;
-	let moved = 0;
-	for (const tracked of Object.values(context.syncState.items)) {
-		const paths = await resolveIssuePaths(context.storageDirAbsolute, tracked.kind, tracked.number, tracked.data.item.title, tracked.state, tracked.filePath);
-		moved += await moveMarkdownByState(paths, tracked.state);
-		await writeFileEnsured(paths.targetPath, buildTrackedMarkdown(context, tracked));
-		tracked.filePath = relativeToStorage(context.storageDirAbsolute, paths.targetPath);
-		tracked.lastSyncedAt = context.syncedAt;
-		processed += 1;
-		written += 1;
-	}
-	return {
-		processed,
-		written,
-		moved
-	};
-}
-async function reconcileMarkdownFilesByScan(context) {
-	let written = 0;
-	let moved = 0;
-	const expectedPaths = /* @__PURE__ */ new Set();
-	for (const tracked of Object.values(context.syncState.items)) {
-		const paths = await resolveIssuePaths(context.storageDirAbsolute, tracked.kind, tracked.number, tracked.data.item.title, tracked.state, tracked.filePath);
-		expectedPaths.add(paths.targetPath);
-		const movedByState = !paths.hasTargetFile ? await moveMarkdownByState(paths, tracked.state) : 0;
-		let changed = movedByState > 0;
-		if (!await pathExists(paths.targetPath)) {
-			await writeFileEnsured(paths.targetPath, buildTrackedMarkdown(context, tracked));
-			written += 1;
-			changed = true;
-		}
-		tracked.filePath = relativeToStorage(context.storageDirAbsolute, paths.targetPath);
-		if (changed) tracked.lastSyncedAt = context.syncedAt;
-		moved += movedByState;
-	}
-	moved += await moveExtraMarkdownFilesToClosed(context.storageDirAbsolute, expectedPaths);
-	return {
-		written,
-		moved
-	};
-}
-function resolveSyncAction(shouldRefetch, paths, state) {
-	if (shouldRefetch) return "refetch";
-	if (paths.hasTargetFile) return "skip";
-	if (resolveMoveSourcePath(paths, state)) return "move";
-	return "create";
-}
-async function fetchCanonicalData(context, issue) {
-	return {
-		item: issue,
-		comments: await context.provider.fetchComments(issue.number),
-		pull: issue.kind === "pull" ? await context.provider.fetchPullMetadata(issue.number) : void 0
-	};
-}
-async function syncPatchByPlan(context, number, patchPath, patchPlan) {
-	let patchesWritten = 0;
-	let patchesDeleted = 0;
-	if (patchPlan.shouldWritePatch) {
-		const patch = await context.provider.fetchPullPatch(number);
-		await removePatchIfExists(context.storageDirAbsolute, number);
-		await writeFileEnsured(patchPath, patch);
-		patchesWritten += 1;
-	}
-	if (patchPlan.shouldDeletePatch) patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
-	return {
-		patchesWritten,
-		patchesDeleted
-	};
-}
-function buildTrackedMarkdown(context, tracked) {
-	return renderIssueMarkdown({
-		repo: context.repoSlug,
-		number: tracked.data.item.number,
-		kind: tracked.data.item.kind,
-		url: tracked.data.item.url,
-		state: tracked.data.item.state,
-		title: tracked.data.item.title,
-		body: tracked.data.item.body ?? "",
-		author: tracked.data.item.author ?? "unknown",
-		labels: tracked.data.item.labels,
-		assignees: tracked.data.item.assignees,
-		milestone: tracked.data.item.milestone,
-		createdAt: tracked.data.item.createdAt,
-		updatedAt: tracked.data.item.updatedAt,
-		closedAt: tracked.data.item.closedAt,
-		lastSyncedAt: context.syncedAt,
-		reactions: normalizeReactions(tracked.data.item.reactions),
-		comments: tracked.data.comments.map((comment) => ({
-			id: comment.id,
-			author: comment.author ?? "unknown",
-			body: comment.body ?? "",
-			createdAt: comment.createdAt,
-			updatedAt: comment.updatedAt,
-			reactions: normalizeReactions(comment.reactions)
-		})),
-		pr: tracked.data.pull
-	});
-}
-async function moveExtraMarkdownFilesToClosed(storageDirAbsolute, expectedPaths) {
-	let moved = 0;
-	moved += await moveOpenMarkdownFilesToClosed(join(storageDirAbsolute, ISSUE_DIR_NAME), expectedPaths);
-	moved += await moveOpenMarkdownFilesToClosed(join(storageDirAbsolute, PULL_DIR_NAME), expectedPaths);
-	return moved;
-}
-async function moveOpenMarkdownFilesToClosed(kindDirAbsolute, expectedPaths) {
-	let moved = 0;
-	const openFiles = await listOpenMarkdownFiles(kindDirAbsolute);
-	const closedDirAbsolute = join(kindDirAbsolute, CLOSED_DIR_NAME);
-	for (const markdownPath of openFiles) {
-		if (expectedPaths.has(markdownPath)) continue;
-		await movePath(markdownPath, await resolveUniqueClosedTarget(closedDirAbsolute, basename(markdownPath)));
-		moved += 1;
-	}
-	return moved;
-}
-async function listOpenMarkdownFiles(kindDirAbsolute) {
-	try {
-		return (await readdir(kindDirAbsolute, {
-			withFileTypes: true,
-			encoding: "utf8"
-		})).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => join(kindDirAbsolute, entry.name));
-	} catch {
-		return [];
-	}
-}
-async function resolveUniqueClosedTarget(closedDirAbsolute, fileName) {
-	const baseName = fileName.replace(/\.md$/i, "");
-	let candidate = join(closedDirAbsolute, fileName);
-	let index = 1;
-	while (await pathExists(candidate)) {
-		candidate = join(closedDirAbsolute, `${baseName}-extra-${index}.md`);
-		index += 1;
-	}
-	return candidate;
-}
-//#endregion
-//#region src/sync/sync-repository-provider.ts
-async function fetchIssueCandidatesByPagination(context, since) {
-	const issues = [];
-	let scanned = 0;
-	const allOpenNumbers = context.config.sync.closed === false && !since ? /* @__PURE__ */ new Set() : void 0;
-	const state = context.config.sync.closed === false ? "open" : "all";
-	for await (const page of context.provider.paginateItems({
-		state,
-		since
-	})) for (const issue of page) {
-		if (!shouldSyncIssue(context.config.sync, issue)) continue;
-		scanned += 1;
-		issues.push(issue);
-		if (state === "open" && allOpenNumbers) allOpenNumbers.add(issue.number);
-	}
-	return {
-		issues,
-		scanned,
-		allOpenNumbers
-	};
-}
-async function fetchIssueCandidatesByNumbers(context, numbers) {
-	const issues = (await context.provider.fetchItemsByNumbers(numbers)).filter((issue) => shouldSyncIssue(context.config.sync, issue));
-	return {
-		issues,
-		scanned: issues.length
-	};
-}
-//#endregion
-//#region src/utils/markdown.ts
-function getTimestamp(value) {
-	const timestamp = Date.parse(value);
-	if (Number.isFinite(timestamp)) return timestamp;
-	return Number.NEGATIVE_INFINITY;
-}
-function renderRowsTable(rows) {
-	const lines = ["| Number | Title | Labels | Updated | File |", "| --- | --- | --- | --- | --- |"];
-	if (rows.length === 0) {
-		lines.push("| - | - | - | - | - |");
-		return lines;
-	}
-	for (const row of rows) {
-		const labels = row.labels.length ? row.labels.map((label) => `\`${escapeInlineCode(label)}\``).join(", ") : "-";
-		lines.push(`| #${row.number} | ${escapeTableCell(row.title)} | ${labels} | ${escapeTableCell(row.updatedAt)} | [${row.filePath}](${row.filePath}) |`);
-	}
-	return lines;
-}
-function escapeTableCell(value) {
-	return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim() || "-";
-}
-function escapeInlineCode(value) {
-	return value.replace(/`/g, "\\`");
-}
-//#endregion
-//#region src/sync/sync-repository-snapshot.ts
-async function writeRepoSnapshot(context) {
-	const repoSnapshot = await buildRepoSnapshot(context);
-	await mkdir(context.storageDirAbsolute, { recursive: true });
-	await writeFile(join(context.storageDirAbsolute, REPO_SNAPSHOT_FILE_NAME), `${JSON.stringify(repoSnapshot, null, 2)}\n`, "utf8");
-}
-async function writeRepositoryIndexes(context) {
-	const [issuesMarkdown, pullsMarkdown] = await Promise.all([renderIndexMarkdown(context, "issue"), renderIndexMarkdown(context, "pull")]);
-	await mkdir(context.storageDirAbsolute, { recursive: true });
-	await Promise.all([writeFile(join(context.storageDirAbsolute, ISSUES_INDEX_FILE_NAME), issuesMarkdown, "utf8"), writeFile(join(context.storageDirAbsolute, PULLS_INDEX_FILE_NAME), pullsMarkdown, "utf8")]);
-}
-async function renderIndexMarkdown(context, kind) {
-	const rows = Object.values(context.syncState.items).filter((item) => item.kind === kind).map((item) => readIndexRow(item));
-	const openRows = sortRows(rows.filter((row) => row.state === "open"));
-	const closedRows = sortRows(rows.filter((row) => row.state === "closed"));
-	return [
-		`# ${kind === "issue" ? "Issues" : "Pull Requests"}`,
-		"",
-		`- repo: ${context.repoSlug}`,
-		`- synced_at: ${context.syncedAt}`,
-		`- total: ${rows.length}`,
-		`- open: ${openRows.length}`,
-		`- closed: ${closedRows.length}`,
-		"",
-		`## Open (${openRows.length})`,
-		"",
-		...renderRowsTable(openRows),
-		"",
-		`## Closed (${closedRows.length})`,
-		"",
-		...renderRowsTable(closedRows),
-		""
-	].join("\n");
-}
-function readIndexRow(item) {
-	return {
-		number: item.number,
-		state: item.state,
-		title: item.data.item.title,
-		labels: item.data.item.labels,
-		updatedAt: item.data.item.updatedAt,
-		filePath: item.filePath
-	};
-}
-function sortRows(rows) {
-	return [...rows].sort((left, right) => {
-		const updatedDiff = getTimestamp(right.updatedAt) - getTimestamp(left.updatedAt);
-		if (updatedDiff !== 0) return updatedDiff;
-		return right.number - left.number;
-	});
-}
-async function buildRepoSnapshot(context) {
-	const [repoResult, labelsResult, milestonesResult] = await Promise.all([
-		context.provider.fetchRepository(),
-		context.provider.fetchRepositoryLabels(),
-		context.provider.fetchRepositoryMilestones()
-	]);
-	const repository = repoResult;
-	const labels = labelsResult.map((label) => ({
-		name: label.name,
-		color: label.color,
-		description: label.description ?? null,
-		default: Boolean(label.default)
-	})).sort((left, right) => left.name.localeCompare(right.name));
-	const milestones = milestonesResult.map((milestone) => ({
-		number: milestone.number,
-		title: milestone.title,
-		state: milestone.state,
-		description: milestone.description ?? null,
-		due_on: milestone.due_on,
-		open_issues: milestone.open_issues,
-		closed_issues: milestone.closed_issues,
-		created_at: milestone.created_at,
-		updated_at: milestone.updated_at,
-		closed_at: milestone.closed_at
-	})).sort((left, right) => left.number - right.number);
-	return {
-		repo: context.repoSlug,
-		synced_at: context.syncedAt,
-		repository: {
-			owner: repository.owner.login,
-			name: repository.name,
-			full_name: repository.full_name,
-			description: repository.description ?? null,
-			private: repository.private,
-			archived: repository.archived,
-			default_branch: repository.default_branch,
-			html_url: repository.html_url,
-			fork: repository.fork,
-			open_issues_count: repository.open_issues_count,
-			has_issues: repository.has_issues,
-			has_projects: repository.has_projects,
-			has_wiki: repository.has_wiki,
-			created_at: repository.created_at,
-			updated_at: repository.updated_at,
-			pushed_at: repository.pushed_at
-		},
-		labels,
-		milestones
-	};
-}
-//#endregion
-//#region src/sync/sync-repository.ts
-async function syncRepository(options) {
-	const reporter = options.reporter;
-	const startedAt = /* @__PURE__ */ new Date();
-	const startedAtIso = startedAt.toISOString();
-	const runId = createSyncRunId();
-	const provider = options.provider ?? createRepositoryProvider({
-		token: options.token,
-		repo: options.repo
-	});
-	const storageDirAbsolute = resolve(options.config.cwd, options.config.directory);
-	const targetNumbers = normalizeIssueNumbers(options.numbers);
-	const counters = createCounters();
-	const stageDurations = createStageDurations();
-	let errorReported = false;
-	reporter?.onStart?.({
-		repo: options.repo,
-		startedAt: startedAtIso,
-		numbersCount: targetNumbers?.length,
-		snapshot: cloneSnapshot(counters)
-	});
-	let context;
-	let since;
-	let repoUpdatedAt;
-	let candidates = {
-		issues: [],
-		scanned: 0
-	};
-	const preparedCandidates = [];
-	let updatedIssues = 0;
-	let updatedPulls = 0;
-	let ghfsVersionMismatch = false;
-	let previousGhfsVersion;
-	const runStage = async (stage, message, fn) => {
-		reporter?.onStageStart?.({
-			stage,
-			message,
-			snapshot: cloneSnapshot(counters)
-		});
-		const stageStartedAt = Date.now();
-		try {
-			const result = await fn();
-			const durationMs = Date.now() - stageStartedAt;
-			stageDurations[stage] = durationMs;
-			reporter?.onStageEnd?.({
-				stage,
-				message,
-				durationMs,
-				snapshot: cloneSnapshot(counters)
-			});
-			return result;
-		} catch (error) {
-			errorReported = true;
-			stageDurations[stage] = Date.now() - stageStartedAt;
-			reporter?.onError?.({
-				stage,
-				error,
-				snapshot: cloneSnapshot(counters)
-			});
-			throw error;
-		}
-	};
-	try {
-		let shouldEarlyReturn = false;
-		await runStage("metadata", "Fetch repository metadata", async () => {
-			const syncState = await loadSyncState(storageDirAbsolute);
-			since = targetNumbers ? void 0 : resolveSince(options, syncState);
-			const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
-			context = {
-				provider,
-				repoSlug: options.repo,
-				storageDirAbsolute,
-				config: options.config,
-				syncState,
-				syncedAt,
-				totalIssues: 0,
-				totalPulls: 0
-			};
-			previousGhfsVersion = syncState.ghfsVersion;
-			ghfsVersionMismatch = syncState.ghfsVersion !== GHFS_VERSION;
-			if (targetNumbers) return;
-			repoUpdatedAt = (await provider.fetchRepository()).updated_at;
-			if (!options.full && syncState.lastRepoUpdatedAt && syncState.lastRepoUpdatedAt === repoUpdatedAt) shouldEarlyReturn = true;
-			reporter?.onStageUpdate?.({
-				stage: "metadata",
-				snapshot: cloneSnapshot(counters),
-				message: `since=${since ?? "(full)"} repoUpdatedAt=${repoUpdatedAt}`
-			});
-		});
-		assertContext(context);
-		const syncContext = context;
-		if (!shouldEarlyReturn) {
-			await runStage("pagination", "Pagination", async () => {
-				const paginatedSince = options.full ? void 0 : since;
-				candidates = targetNumbers ? await fetchIssueCandidatesByNumbers(syncContext, targetNumbers) : await fetchIssueCandidatesByPagination(syncContext, paginatedSince);
-				counters.scanned = candidates.scanned;
-				counters.selected = candidates.issues.length;
-				reporter?.onStageUpdate?.({
-					stage: "pagination",
-					snapshot: cloneSnapshot(counters),
-					message: `scanned=${counters.scanned} selected=${counters.selected}`
-				});
-			});
-			await runStage("fetch", "Fetch updated issues/PRs", async () => {
-				for (const issue of candidates.issues) {
-					const prepared = await prepareIssueCandidateSync(syncContext, issue);
-					preparedCandidates.push(prepared);
-					counters.processed += 1;
-					if (prepared.action === "refetch" || prepared.action === "create") if (prepared.kind === "issue") updatedIssues += 1;
-					else updatedPulls += 1;
-					reporter?.onStageUpdate?.({
-						stage: "fetch",
-						snapshot: cloneSnapshot(counters),
-						message: `${formatIssueNumber(issue.number, {
-							repo: options.repo,
-							kind: issue.kind
-						})} ${prepared.kind} ${prepared.action}`
-					});
-				}
-			});
-			syncContext.syncState.repo = options.repo;
-			if (!targetNumbers) {
-				syncContext.syncState.lastSyncedAt = syncContext.syncedAt;
-				syncContext.syncState.lastSince = since;
-				syncContext.syncState.lastRepoUpdatedAt = repoUpdatedAt;
-			}
-			await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
-			await runStage("materialize", "Materialize local files", async () => {
-				for (const prepared of preparedCandidates) addItemStats(counters, await materializePreparedIssue(syncContext, prepared));
-			});
-			await runStage("prune", "Prune stale local artifacts", async () => {
-				if (options.config.sync.closed === false) counters.patchesDeleted += await pruneTrackedClosedItems(syncContext.storageDirAbsolute, syncContext.syncState, options.config.sync);
-				if (!targetNumbers && options.config.sync.closed === false && candidates.allOpenNumbers) counters.patchesDeleted += await pruneMissingOpenTrackedItems(syncContext.storageDirAbsolute, syncContext.syncState, candidates.allOpenNumbers, options.config.sync);
-				reporter?.onStageUpdate?.({
-					stage: "prune",
-					snapshot: cloneSnapshot(counters),
-					message: `patchesDeleted=${counters.patchesDeleted}`
-				});
-			});
-		}
-		await runStage("save", "Save sync state", async () => {
-			if (ghfsVersionMismatch) {
-				const rematerialized = await rematerializeTrackedMarkdown(syncContext);
-				reporter?.onStageUpdate?.({
-					stage: "save",
-					snapshot: cloneSnapshot(counters),
-					message: `regenerated=${rematerialized.written} version=${previousGhfsVersion ?? "(none)"}->${GHFS_VERSION}`
-				});
-			}
-			const scanStats = await reconcileMarkdownFilesByScan(syncContext);
-			counters.written += scanStats.written;
-			counters.moved += scanStats.moved;
-			reporter?.onStageUpdate?.({
-				stage: "save",
-				snapshot: cloneSnapshot(counters),
-				message: `scan-fixed written=${scanStats.written} moved=${scanStats.moved}`
-			});
-			if (!shouldEarlyReturn) await writeRepoSnapshot(syncContext);
-			if (!shouldEarlyReturn || ghfsVersionMismatch) await writeRepositoryIndexes(syncContext);
-			syncContext.syncState.ghfsVersion = GHFS_VERSION;
-			await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
-		});
-		const totals = computeTotals(syncContext.syncState.items);
-		syncContext.totalIssues = totals.totalIssues;
-		syncContext.totalPulls = totals.totalPulls;
-		const finishedAt = /* @__PURE__ */ new Date();
-		const durationMs = Math.max(0, finishedAt.getTime() - startedAt.getTime());
-		const requestCount = provider.getRequestCount();
-		const summary = {
-			repo: options.repo,
-			since,
-			syncedAt: syncContext.syncedAt,
-			totalIssues: totals.totalIssues,
-			totalPulls: totals.totalPulls,
-			updatedIssues,
-			updatedPulls,
-			trackedItems: totals.trackedItems,
-			requestCount,
-			scanned: counters.scanned,
-			selected: counters.selected,
-			processed: counters.processed,
-			skipped: counters.skipped,
-			written: counters.written,
-			moved: counters.moved,
-			patchesWritten: counters.patchesWritten,
-			patchesDeleted: counters.patchesDeleted,
-			durationMs
-		};
-		syncContext.syncState.lastSyncRun = {
-			runId,
-			repo: options.repo,
-			startedAt: startedAtIso,
-			finishedAt: finishedAt.toISOString(),
-			durationMs,
-			requestCount,
-			since,
-			numbersCount: targetNumbers?.length,
-			counters: cloneSnapshot(counters),
-			stages: { ...stageDurations }
-		};
-		await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
-		reporter?.onComplete?.({
-			summary,
-			stages: { ...stageDurations }
-		});
-		return summary;
-	} catch (error) {
-		if (!errorReported) reporter?.onError?.({
-			error,
-			snapshot: cloneSnapshot(counters)
-		});
-		throw error;
-	}
-}
-function assertContext(context) {
-	if (!context) throw new Error("Sync context was not initialized");
-}
-function createSyncRunId() {
-	return `sync_${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "")}_${randomBytes(3).toString("hex")}`;
-}
-function createStageDurations() {
-	return {
-		metadata: 0,
-		pagination: 0,
-		fetch: 0,
-		materialize: 0,
-		prune: 0,
-		save: 0
-	};
-}
-function cloneSnapshot(counters) {
-	return {
-		scanned: counters.scanned,
-		selected: counters.selected,
-		processed: counters.processed,
-		skipped: counters.skipped,
-		written: counters.written,
-		moved: counters.moved,
-		patchesWritten: counters.patchesWritten,
-		patchesDeleted: counters.patchesDeleted
-	};
-}
-function computeTotals(items) {
-	let totalIssues = 0;
-	let totalPulls = 0;
-	for (const item of Object.values(items)) if (item.kind === "issue") totalIssues += 1;
-	else totalPulls += 1;
-	return {
-		totalIssues,
-		totalPulls,
-		trackedItems: totalIssues + totalPulls
-	};
-}
-//#endregion
-//#region src/server/poller.ts
-function createRemotePoller(options) {
-	const intervalMs = options.intervalMs ?? 6e4;
-	let current = options.initial ?? {
-		downCount: 0,
-		checkedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-		stale: true,
-		message: "Not checked yet"
-	};
-	let stopped = false;
-	let timer;
-	let failures = 0;
-	let inFlight;
-	function setStatus(next) {
-		current = next;
-		options.onUpdate(current);
-		return current;
-	}
-	async function doCheck() {
-		const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const since = options.getSince();
-		if (!since) return setStatus({
-			downCount: 0,
-			checkedAt,
-			stale: true,
-			message: "Not synced yet"
-		});
-		let provider;
-		try {
-			provider = await options.getProvider();
-		} catch (error) {
-			return setStatus({
-				downCount: current.downCount,
-				checkedAt,
-				stale: true,
-				message: error.message
-			});
-		}
-		if (!provider) return setStatus({
-			downCount: 0,
-			checkedAt,
-			stale: true,
-			message: "Missing GitHub token"
-		});
-		try {
-			const counts = await provider.countUpdatedSince(since);
-			failures = 0;
-			return setStatus({
-				downCount: counts.issues + counts.pulls,
-				checkedAt,
-				stale: false
-			});
-		} catch (error) {
-			failures += 1;
-			return setStatus({
-				downCount: current.downCount,
-				checkedAt,
-				stale: true,
-				message: error.message
-			});
-		}
-	}
-	async function check() {
-		if (inFlight) return inFlight;
-		inFlight = doCheck();
-		try {
-			return await inFlight;
-		} finally {
-			inFlight = void 0;
-			schedule();
-		}
-	}
-	function schedule() {
-		if (stopped) return;
-		if (timer) clearTimeout(timer);
-		const backoff = failures === 0 ? intervalMs : Math.min(intervalMs * 2 ** Math.min(failures, 4), intervalMs * 16);
-		timer = setTimeout(() => {
-			check().catch(() => {});
-		}, backoff);
-	}
-	timer = setTimeout(() => {
-		check().catch(() => {});
-	}, 2e3);
-	return {
-		getCurrent: () => current,
-		checkNow: check,
-		close: () => {
-			stopped = true;
-			if (timer) clearTimeout(timer);
-		}
-	};
-}
-//#endregion
-//#region src/server/queue-builder.ts
-async function buildQueueState(options) {
-	const { storageDirAbsolute, executeFilePath } = options;
-	const executeMdPath = join(storageDirAbsolute, EXECUTE_MD_FILE_NAME);
-	const [yml, md, perItem, syncState] = await Promise.all([
-		readYmlOps(executeFilePath),
-		readMdOps(executeMdPath),
-		loadPerItemSource(storageDirAbsolute),
-		loadSyncState(storageDirAbsolute)
-	]);
-	const entries = [];
-	for (const [index, op] of yml.ops.entries()) entries.push(buildEntry(op, "execute.yml", index));
-	for (const [index, op] of md.ops.entries()) entries.push(buildEntry(op, "execute.md", index));
-	for (const [index, op] of perItem.ops.entries()) {
-		const filePath = syncState.items[String(op.number)]?.filePath;
-		entries.push(buildEntry(op, "per-item", index, filePath));
-	}
-	return {
-		entries,
-		warnings: [
-			...yml.warnings,
-			...md.warnings,
-			...perItem.warnings
-		],
-		upCount: entries.length
-	};
-}
-async function readYmlOps(path) {
-	if (!await pathExists(path)) return {
-		ops: [],
-		warnings: []
-	};
-	try {
-		return {
-			ops: (await readAndValidateExecuteFileWithSource(path)).ops,
-			warnings: []
-		};
-	} catch (error) {
-		return {
-			ops: [],
-			warnings: [`execute.yml: ${error.message}`]
-		};
-	}
-}
-async function readMdOps(path) {
-	const parsed = await readExecuteMdFile(path);
-	return {
-		ops: parsed.ops,
-		warnings: parsed.warnings
-	};
-}
-function buildEntry(op, source, index, filePath) {
-	return {
-		id: hash({
-			source,
-			index,
-			action: op.action,
-			number: op.number
-		}),
-		source,
-		index,
-		op,
-		filePath
-	};
-}
-//#endregion
-//#region src/server/handlers/editor.ts
-function createEditorHandler(ctx) {
-	return async function openInEditor(filePath) {
-		const absolute = isAbsolute(filePath) ? filePath : resolve(ctx.storageDirAbsolute, filePath);
-		const editor = process.env.EDITOR || process.env.VISUAL || "code";
-		return new Promise((resolvePromise, rejectPromise) => {
-			const child = spawn(editor, [absolute], {
-				stdio: "ignore",
-				detached: true
-			});
-			child.on("error", rejectPromise);
-			child.unref();
-			resolvePromise();
-		});
-	};
-}
-//#endregion
-//#region src/server/handlers/execute.ts
-function createExecuteHandler(ctx) {
-	let running = false;
-	return async function executeQueue(options) {
-		if (running) throw new Error("An execute is already in progress");
-		running = true;
-		try {
-			const token = await ctx.getToken();
-			const selectedIndexes = await resolveSelectedIndexes(ctx, options.entryIds);
-			ctx.broadcast.onExecuteStart({ planned: selectedIndexes?.length ?? -1 });
-			return await executePendingChanges({
-				config: ctx.config,
-				repo: ctx.repo,
-				token,
-				executeFilePath: ctx.executeFilePath,
-				apply: true,
-				nonInteractive: true,
-				continueOnError: options.continueOnError ?? true,
-				selectedIndexes,
-				reporter: {
-					onStart(event) {
-						ctx.broadcast.onExecuteStart({ planned: event.planned });
-					},
-					onProgress(event) {
-						ctx.broadcast.onExecuteProgress({
-							completed: event.completed,
-							planned: event.planned,
-							applied: event.applied,
-							failed: event.failed,
-							detail: event.detail
-						});
-					},
-					onComplete(event) {
-						ctx.broadcast.onExecuteComplete(event.result);
-					},
-					onError(event) {
-						const message = event.error instanceof Error ? event.error.message : String(event.error);
-						ctx.broadcast.onExecuteError(message);
-					}
-				}
-			});
-		} finally {
-			running = false;
-		}
-	};
-}
-async function resolveSelectedIndexes(ctx, entryIds) {
-	if (!entryIds || entryIds.length === 0) return void 0;
-	const queue = await buildQueueState({
-		storageDirAbsolute: ctx.storageDirAbsolute,
-		executeFilePath: ctx.executeFilePath
-	});
-	const ids = new Set(entryIds);
-	const indexes = [];
-	queue.entries.forEach((entry, globalIndex) => {
-		if (ids.has(entry.id)) indexes.push(globalIndex);
-	});
-	return indexes;
-}
-//#endregion
-//#region src/execute/compress.ts
-function createEmptyState() {
-	return {
-		title: null,
-		body: null,
-		stateChange: null,
-		extraComments: [],
-		labels: {
-			mode: "delta",
-			set: [],
-			add: [],
-			remove: []
-		},
-		assignees: {
-			mode: "delta",
-			set: [],
-			add: [],
-			remove: []
-		},
-		reviewers: {
-			add: [],
-			remove: []
-		},
-		milestone: null,
-		lock: null,
-		draft: null,
-		ifUnchangedSince: void 0
-	};
-}
-function addUnique(list, value) {
-	if (!list.includes(value)) list.push(value);
-}
-function removeFromList(list, value) {
-	const idx = list.indexOf(value);
-	if (idx >= 0) list.splice(idx, 1);
-}
-function mergeIfUnchangedSince(current, next) {
-	if (!next) return current;
-	if (!current) return next;
-	try {
-		return new Date(next).getTime() < new Date(current).getTime() ? next : current;
-	} catch {
-		return current;
-	}
-}
-function applyOp(state, op) {
-	state.ifUnchangedSince = mergeIfUnchangedSince(state.ifUnchangedSince, op.ifUnchangedSince);
-	switch (op.action) {
-		case "close": {
-			if (state.stateChange?.kind === "reopen") {
-				state.stateChange = null;
-				break;
-			}
-			const body = state.stateChange?.kind === "close" ? state.stateChange.body : void 0;
-			state.stateChange = body ? {
-				kind: "close",
-				body
-			} : { kind: "close" };
-			break;
-		}
-		case "reopen":
-			if (state.stateChange?.kind === "close") {
-				state.stateChange = null;
-				break;
-			}
-			state.stateChange = { kind: "reopen" };
-			break;
-		case "close-with-comment":
-			if (state.stateChange?.kind === "reopen") {
-				addUnique(state.extraComments, op.body);
-				state.stateChange = null;
-				break;
-			}
-			if (state.stateChange?.kind === "close" && state.stateChange.body && state.stateChange.body !== op.body) addUnique(state.extraComments, state.stateChange.body);
-			state.stateChange = {
-				kind: "close",
-				body: op.body
-			};
-			break;
-		case "set-title":
-			state.title = op.title;
-			break;
-		case "set-body":
-			state.body = op.body;
-			break;
-		case "add-comment":
-			if (state.stateChange?.kind === "close" && state.stateChange.body === op.body) break;
-			addUnique(state.extraComments, op.body);
-			break;
-		case "add-labels":
-			if (state.labels.mode === "set") for (const l of op.labels) addUnique(state.labels.set, l);
-			else for (const l of op.labels) if (state.labels.remove.includes(l)) removeFromList(state.labels.remove, l);
-			else addUnique(state.labels.add, l);
-			break;
-		case "remove-labels":
-			if (state.labels.mode === "set") state.labels.set = state.labels.set.filter((l) => !op.labels.includes(l));
-			else for (const l of op.labels) if (state.labels.add.includes(l)) removeFromList(state.labels.add, l);
-			else addUnique(state.labels.remove, l);
-			break;
-		case "set-labels":
-			state.labels = {
-				mode: "set",
-				set: [...op.labels],
-				add: [],
-				remove: []
-			};
-			break;
-		case "add-assignees":
-			if (state.assignees.mode === "set") for (const a of op.assignees) addUnique(state.assignees.set, a);
-			else for (const a of op.assignees) if (state.assignees.remove.includes(a)) removeFromList(state.assignees.remove, a);
-			else addUnique(state.assignees.add, a);
-			break;
-		case "remove-assignees":
-			if (state.assignees.mode === "set") state.assignees.set = state.assignees.set.filter((a) => !op.assignees.includes(a));
-			else for (const a of op.assignees) if (state.assignees.add.includes(a)) removeFromList(state.assignees.add, a);
-			else addUnique(state.assignees.remove, a);
-			break;
-		case "set-assignees":
-			state.assignees = {
-				mode: "set",
-				set: [...op.assignees],
-				add: [],
-				remove: []
-			};
-			break;
-		case "set-milestone":
-			state.milestone = { set: op.milestone };
-			break;
-		case "clear-milestone":
-			state.milestone = "clear";
-			break;
-		case "lock":
-			state.lock = {
-				lock: true,
-				reason: op.reason
-			};
-			break;
-		case "unlock":
-			state.lock = state.lock?.lock === true ? null : { lock: false };
-			break;
-		case "convert-to-draft":
-			state.draft = state.draft === "ready" ? null : "draft";
-			break;
-		case "mark-ready-for-review":
-			state.draft = state.draft === "draft" ? null : "ready";
-			break;
-		case "request-reviewers":
-			for (const r of op.reviewers) if (state.reviewers.remove.includes(r)) removeFromList(state.reviewers.remove, r);
-			else addUnique(state.reviewers.add, r);
-			break;
-		case "remove-reviewers":
-			for (const r of op.reviewers) if (state.reviewers.add.includes(r)) removeFromList(state.reviewers.add, r);
-			else addUnique(state.reviewers.remove, r);
-			break;
-	}
-}
-function emit(number, state) {
-	const ifUnchangedSince = state.ifUnchangedSince;
-	const withBase = (op) => ifUnchangedSince ? {
-		...op,
-		ifUnchangedSince
-	} : op;
-	const out = [];
-	if (state.title != null) out.push(withBase({
-		action: "set-title",
-		number,
-		title: state.title
-	}));
-	if (state.body != null) out.push(withBase({
-		action: "set-body",
-		number,
-		body: state.body
-	}));
-	if (state.labels.mode === "set") out.push(withBase({
-		action: "set-labels",
-		number,
-		labels: [...state.labels.set]
-	}));
-	else {
-		if (state.labels.add.length) out.push(withBase({
-			action: "add-labels",
-			number,
-			labels: [...state.labels.add]
-		}));
-		if (state.labels.remove.length) out.push(withBase({
-			action: "remove-labels",
-			number,
-			labels: [...state.labels.remove]
-		}));
-	}
-	if (state.assignees.mode === "set") out.push(withBase({
-		action: "set-assignees",
-		number,
-		assignees: [...state.assignees.set]
-	}));
-	else {
-		if (state.assignees.add.length) out.push(withBase({
-			action: "add-assignees",
-			number,
-			assignees: [...state.assignees.add]
-		}));
-		if (state.assignees.remove.length) out.push(withBase({
-			action: "remove-assignees",
-			number,
-			assignees: [...state.assignees.remove]
-		}));
-	}
-	if (state.milestone === "clear") out.push(withBase({
-		action: "clear-milestone",
-		number
-	}));
-	else if (state.milestone && "set" in state.milestone) out.push(withBase({
-		action: "set-milestone",
-		number,
-		milestone: state.milestone.set
-	}));
-	if (state.reviewers.add.length) out.push(withBase({
-		action: "request-reviewers",
-		number,
-		reviewers: [...state.reviewers.add]
-	}));
-	if (state.reviewers.remove.length) out.push(withBase({
-		action: "remove-reviewers",
-		number,
-		reviewers: [...state.reviewers.remove]
-	}));
-	if (state.draft === "draft") out.push(withBase({
-		action: "convert-to-draft",
-		number
-	}));
-	else if (state.draft === "ready") out.push(withBase({
-		action: "mark-ready-for-review",
-		number
-	}));
-	for (const body of state.extraComments) out.push(withBase({
-		action: "add-comment",
-		number,
-		body
-	}));
-	if (state.stateChange?.kind === "close") if (state.stateChange.body != null) out.push(withBase({
-		action: "close-with-comment",
-		number,
-		body: state.stateChange.body
-	}));
-	else out.push(withBase({
-		action: "close",
-		number
-	}));
-	else if (state.stateChange?.kind === "reopen") out.push(withBase({
-		action: "reopen",
-		number
-	}));
-	if (state.lock?.lock === true) out.push(withBase({
-		action: "lock",
-		number,
-		...state.lock.reason ? { reason: state.lock.reason } : {}
-	}));
-	else if (state.lock?.lock === false) out.push(withBase({
-		action: "unlock",
-		number
-	}));
-	return out;
-}
-/**
-* Compress a list of pending ops by merging/cancelling redundant ones per-item.
-*
-* - `close` + `reopen` cancel each other.
-* - `close-with-comment("a")` + `close-with-comment("b")` keeps "b" bundled and demotes "a" to a standalone add-comment.
-* - `close-with-comment("a")` + `reopen` cancels entirely (the body is dropped — if users want to keep the comment they can add it explicitly).
-* - Adjacent `add-labels` / `remove-labels` merge; overlapping pairs cancel out.
-* - `set-title` / `set-body` / `set-labels` / `set-assignees` / `set-milestone` / `clear-milestone` follow last-write-wins.
-* - `add-comment` bodies dedupe.
-* - `lock`/`unlock` and `convert-to-draft`/`mark-ready-for-review` cancel when paired in that order.
-* - `ifUnchangedSince` is preserved as the earliest (most conservative) value across ops in the group.
-*
-* Groups are emitted in the order their number first appeared in the input.
-*/
-function compressOps(ops) {
-	const groups = /* @__PURE__ */ new Map();
-	let order = 0;
-	for (const op of ops) {
-		let entry = groups.get(op.number);
-		if (!entry) {
-			entry = {
-				order: order++,
-				list: []
-			};
-			groups.set(op.number, entry);
-		}
-		entry.list.push(op);
-	}
-	const sorted = [...groups.entries()].sort((a, b) => a[1].order - b[1].order);
-	const result = [];
-	for (const [number, { list }] of sorted) {
-		const state = createEmptyState();
-		for (const op of list) applyOp(state, op);
-		result.push(...emit(number, state));
-	}
-	return result;
-}
-//#endregion
-//#region src/server/queue-writer.ts
-async function addQueueOp(options, op) {
-	await ensureExecuteArtifacts(options.executeFilePath);
-	const next = compressOps([...(await readAndValidateExecuteFileWithSource(options.executeFilePath)).ops, op]);
-	await writeExecuteFile(options.executeFilePath, next);
-	return buildQueueState(options);
-}
-async function removeQueueOp(options, id) {
-	const entry = (await buildQueueState(options)).entries.find((e) => e.id === id);
-	if (!entry) throw new Error(`Queue entry not found: ${id}`);
-	if (entry.source === "per-item") throw new Error(`Cannot remove a per-item edit from the queue. Edit ${entry.filePath ?? "the markdown file"} directly to adjust it.`);
-	if (entry.source === "execute.yml") {
-		const next = (await readAndValidateExecuteFileWithSource(options.executeFilePath)).ops.filter((_, index) => index !== entry.index);
-		await writeExecuteFile(options.executeFilePath, next);
-		return buildQueueState(options);
-	}
-	const mdPath = join(options.storageDirAbsolute, EXECUTE_MD_FILE_NAME);
-	if (!await pathExists(mdPath)) throw new Error("execute.md not found; cannot remove op");
-	const parsed = await readExecuteMdFile(mdPath);
-	const remaining = /* @__PURE__ */ new Set();
-	for (let i = 0; i < parsed.ops.length; i += 1) if (i !== entry.index) remaining.add(i);
-	await writeFile(mdPath, stringifyExecuteMd(parsed, remaining), "utf-8");
-	return buildQueueState(options);
-}
-async function updateQueueOp(options, id, op) {
-	const entry = (await buildQueueState(options)).entries.find((e) => e.id === id);
-	if (!entry) throw new Error(`Queue entry not found: ${id}`);
-	if (entry.source !== "execute.yml") throw new Error(`Cannot edit ${entry.source} ops from the queue panel`);
-	const replaced = (await readAndValidateExecuteFileWithSource(options.executeFilePath)).ops.map((existing, index) => index === entry.index ? op : existing);
-	await writeExecuteFile(options.executeFilePath, compressOps(replaced));
-	return buildQueueState(options);
-}
-async function clearQueue(options) {
-	await ensureExecuteArtifacts(options.executeFilePath);
-	await writeExecuteFile(options.executeFilePath, []);
-	return buildQueueState(options);
-}
-//#endregion
-//#region src/server/handlers/queue.ts
-function createQueueHandlers(ctx) {
-	const options = {
-		storageDirAbsolute: ctx.storageDirAbsolute,
-		executeFilePath: ctx.executeFilePath
-	};
-	return {
-		addQueueOp: (op) => addQueueOp(options, op),
-		updateQueueOp: (id, op) => updateQueueOp(options, id, op),
-		removeQueueOp: (id) => removeQueueOp(options, id),
-		clearQueue: () => clearQueue(options)
-	};
-}
-//#endregion
-//#region src/server/handlers/remote.ts
-function createRemoteHandler(ctx) {
-	return async function checkRemote() {
-		return ctx.poller.checkNow();
-	};
-}
-//#endregion
-//#region src/server/ui-state.ts
-const UI_STATE_FILE = ".ui.json";
-function createEmptyUiState() {
-	return { drafts: {} };
-}
-async function loadUiState(storageDirAbsolute) {
-	try {
-		const raw = await readFile(join(storageDirAbsolute, UI_STATE_FILE), "utf8");
-		const parsed = JSON.parse(raw);
-		const drafts = {};
-		if (parsed.drafts && typeof parsed.drafts === "object") {
-			for (const [key, value] of Object.entries(parsed.drafts)) if (typeof value === "string" && value.length > 0) drafts[key] = value;
-		}
-		return {
-			drafts,
-			listPaneSize: typeof parsed.listPaneSize === "number" ? parsed.listPaneSize : void 0
-		};
-	} catch {
-		return createEmptyUiState();
-	}
-}
-async function saveUiState(storageDirAbsolute, state) {
-	await mkdir(storageDirAbsolute, { recursive: true });
-	const clean = {
-		drafts: { ...state.drafts },
-		...state.listPaneSize != null ? { listPaneSize: state.listPaneSize } : {}
-	};
-	await writeFile(join(storageDirAbsolute, UI_STATE_FILE), `${JSON.stringify(clean, null, 2)}\n`, "utf8");
-}
-//#endregion
-//#region src/server/handlers/state.ts
-function createStateHandlers(ctx) {
-	async function getRepoMeta() {
-		const syncState = await loadSyncState(ctx.storageDirAbsolute);
-		let hasToken = false;
-		try {
-			const token = await ctx.getToken();
-			hasToken = Boolean(token);
-		} catch {
-			hasToken = false;
-		}
-		return {
-			repo: ctx.repo,
-			storageDir: ctx.config.directory,
-			ghfsVersion: GHFS_VERSION,
-			lastSyncedAt: syncState.lastSyncedAt,
-			lastSince: syncState.lastSince,
-			hasToken
-		};
-	}
-	async function getSyncState() {
-		return loadSyncState(ctx.storageDirAbsolute);
-	}
-	async function getQueue() {
-		return buildQueueState({
-			storageDirAbsolute: ctx.storageDirAbsolute,
-			executeFilePath: ctx.executeFilePath
-		});
-	}
-	async function getInitialPayload() {
-		const [repo, syncState, queue, uiState] = await Promise.all([
-			getRepoMeta(),
-			getSyncState(),
-			getQueue(),
-			loadUiState(ctx.storageDirAbsolute)
-		]);
-		return {
-			repo,
-			syncState,
-			queue,
-			remote: ctx.poller.getCurrent(),
-			recentExecutions: syncState.executions ?? [],
-			uiState
-		};
-	}
-	return {
-		getInitialPayload,
-		getSyncState,
-		getQueue,
-		getRepoMeta,
-		saveUiState: (state) => saveUiState(ctx.storageDirAbsolute, state)
-	};
-}
-//#endregion
-//#region src/server/handlers/sync.ts
-function createSyncHandler(ctx) {
-	let running = false;
-	return async function triggerSync(options) {
-		if (running) throw new Error("A sync is already in progress");
-		running = true;
-		try {
-			const token = await ctx.getToken();
-			return await syncRepository({
-				config: ctx.config,
-				repo: ctx.repo,
-				token,
-				full: options.full,
-				since: options.since,
-				numbers: options.numbers,
-				reporter: {
-					onStageStart(event) {
-						ctx.broadcast.onSyncStageStart({
-							stage: event.stage,
-							message: event.message
-						});
-					},
-					onStageUpdate(event) {
-						ctx.broadcast.onSyncProgress({
-							stage: event.stage,
-							message: event.message,
-							snapshot: event.snapshot
-						});
-					},
-					onStageEnd(event) {
-						ctx.broadcast.onSyncStageEnd({
-							stage: event.stage,
-							durationMs: event.durationMs
-						});
-					},
-					onComplete(event) {
-						ctx.broadcast.onSyncComplete(event.summary);
-					},
-					onError(event) {
-						const message = event.error instanceof Error ? event.error.message : String(event.error);
-						ctx.broadcast.onSyncError(message);
-					}
-				}
-			});
-		} finally {
-			running = false;
-		}
-	};
-}
-//#endregion
-//#region src/server/rpc.ts
-function createServerFunctions(ctx) {
-	const state = createStateHandlers(ctx);
-	const queue = createQueueHandlers(ctx);
-	return {
-		getInitialPayload: state.getInitialPayload,
-		getSyncState: state.getSyncState,
-		getQueue: state.getQueue,
-		getRepoMeta: state.getRepoMeta,
-		triggerSync: createSyncHandler(ctx),
-		executeQueue: createExecuteHandler(ctx),
-		addQueueOp: queue.addQueueOp,
-		updateQueueOp: queue.updateQueueOp,
-		removeQueueOp: queue.removeQueueOp,
-		clearQueue: queue.clearQueue,
-		checkRemote: createRemoteHandler(ctx),
-		openInEditor: createEditorHandler(ctx),
-		saveUiState: state.saveUiState
-	};
-}
-//#endregion
-//#region src/server/static.ts
-const MIME_TYPES = {
-	css: "text/css; charset=utf-8",
-	html: "text/html; charset=utf-8",
-	ico: "image/x-icon",
-	jpeg: "image/jpeg",
-	jpg: "image/jpeg",
-	js: "application/javascript; charset=utf-8",
-	json: "application/json; charset=utf-8",
-	map: "application/json; charset=utf-8",
-	mjs: "application/javascript; charset=utf-8",
-	png: "image/png",
-	svg: "image/svg+xml; charset=utf-8",
-	txt: "text/plain; charset=utf-8",
-	webp: "image/webp",
-	woff: "font/woff",
-	woff2: "font/woff2",
-	xml: "application/xml; charset=utf-8"
-};
-function mimeTypeFor(id) {
-	const dot = id.lastIndexOf(".");
-	if (dot < 0) return void 0;
-	return MIME_TYPES[id.slice(dot + 1).toLowerCase()];
-}
-async function createStaticHandler(staticDir) {
-	async function metaFor(id) {
-		let stats;
-		try {
-			stats = await stat(resolve(staticDir, `.${id}`));
-		} catch {
-			return;
-		}
-		if (!stats.isFile()) return void 0;
-		return {
-			mtime: stats.mtimeMs,
-			size: stats.size,
-			type: mimeTypeFor(id)
-		};
-	}
-	const spaFallback = await readFallback(staticDir);
-	return eventHandler(async (event) => {
-		if (await serveStatic(event, {
-			getContents: (id) => readFile(resolve(staticDir, `.${id}`)),
-			getMeta: (id) => metaFor(id),
-			indexNames: ["/index.html"],
-			fallthrough: true
-		}) !== false) return;
-		if (spaFallback) {
-			setResponseHeader(event, "content-type", "text/html; charset=utf-8");
-			return spaFallback;
-		}
-		setResponseHeader(event, "content-type", "text/plain; charset=utf-8");
-		return `ghfs UI assets not found at ${staticDir}. Run "pnpm build" first.\n`;
-	});
-}
-async function readFallback(staticDir) {
-	for (const name of ["200.html", "index.html"]) {
-		const candidate = resolve(staticDir, name);
-		if (await pathExists(candidate)) return readFile(candidate, "utf-8");
-	}
-}
-//#endregion
-//#region src/server/watcher.ts
-async function createGhfsWatcher(options) {
-	const { storageDirAbsolute, onSyncStateChange, onQueueChange } = options;
-	const debounceMs = options.debounceMs ?? 150;
-	await mkdir(storageDirAbsolute, { recursive: true });
-	let syncTimer;
-	let queueTimer;
-	const flushSync = () => {
-		syncTimer = void 0;
-		try {
-			onSyncStateChange();
-		} catch {}
-	};
-	const flushQueue = () => {
-		queueTimer = void 0;
-		try {
-			onQueueChange();
-		} catch {}
-	};
-	const scheduleSync = () => {
-		if (syncTimer) clearTimeout(syncTimer);
-		syncTimer = setTimeout(flushSync, debounceMs);
-	};
-	const scheduleQueue = () => {
-		if (queueTimer) clearTimeout(queueTimer);
-		queueTimer = setTimeout(flushQueue, debounceMs);
-	};
-	const controller = new AbortController();
-	const iterator = watch(storageDirAbsolute, {
-		recursive: true,
-		signal: controller.signal
-	});
-	const pump = async () => {
-		try {
-			for await (const event of iterator) {
-				const filename = event.filename ? event.filename.replace(/\\/g, "/") : "";
-				if (!filename) continue;
-				const basename = filename.split("/").pop() ?? "";
-				if (basename === ".sync.json") {
-					scheduleSync();
-					scheduleQueue();
-					continue;
-				}
-				if (basename === "execute.yml" || basename === "execute.md") {
-					scheduleQueue();
-					continue;
-				}
-				if (basename.endsWith(".md")) scheduleQueue();
-			}
-		} catch (error) {
-			if (error.name !== "AbortError") throw error;
-		}
-	};
-	pump();
-	return { close: async () => {
-		controller.abort();
-		if (syncTimer) clearTimeout(syncTimer);
-		if (queueTimer) clearTimeout(queueTimer);
-	} };
-}
-//#endregion
-//#region src/server/index.ts
-const EVENT_NAMES = [
-	"onSyncStageStart",
-	"onSyncProgress",
-	"onSyncStageEnd",
-	"onSyncComplete",
-	"onSyncError",
-	"onExecuteStart",
-	"onExecuteProgress",
-	"onExecuteComplete",
-	"onExecuteError",
-	"onSyncStateChange",
-	"onQueueChange",
-	"onRemoteStatusChange"
-];
-async function createUiServer(options) {
-	const storageDirAbsolute = resolve(options.config.cwd, options.config.directory);
-	const executeFilePath = resolve(options.config.cwd, getExecuteFile(options.config));
-	let cachedToken = options.initialToken ?? "";
-	async function getToken() {
-		if (cachedToken) return cachedToken;
-		if (options.onRequestToken) {
-			cachedToken = await options.onRequestToken();
-			return cachedToken;
-		}
-		throw new Error("Missing GitHub token");
-	}
-	let cachedProvider;
-	async function getProvider() {
-		if (cachedProvider) return cachedProvider;
-		let token;
-		try {
-			token = await getToken();
-		} catch {
-			return null;
-		}
-		if (!token) return null;
-		cachedProvider = createRepositoryProvider({
-			token,
-			repo: options.repo
-		});
-		return cachedProvider;
-	}
-	let lastSyncedAt = (await loadSyncState(storageDirAbsolute)).lastSyncedAt;
-	const clients = /* @__PURE__ */ new Set();
-	const broadcast = createBroadcast(clients);
-	const poller = createRemotePoller({
-		intervalMs: options.pollerIntervalMs,
-		getProvider,
-		getSince: () => lastSyncedAt,
-		onUpdate: (status) => broadcast.onRemoteStatusChange(status)
-	});
-	const serverFunctions = createServerFunctions({
-		config: options.config,
-		repo: options.repo,
-		storageDirAbsolute,
-		executeFilePath,
-		getToken,
-		getProvider,
-		broadcast,
-		poller
-	});
-	const watcher = await createGhfsWatcher({
-		storageDirAbsolute,
-		onSyncStateChange: async () => {
-			const state = await loadSyncState(storageDirAbsolute);
-			lastSyncedAt = state.lastSyncedAt;
-			broadcast.onSyncStateChange(state);
-		},
-		onQueueChange: async () => {
-			const queue = await buildQueueState({
-				storageDirAbsolute,
-				executeFilePath
-			});
-			broadcast.onQueueChange(queue);
-		}
-	});
-	const app = createApp();
-	const router = createRouter();
-	router.get("/api/metadata.json", eventHandler(() => ({
-		repo: options.repo,
-		storageDir: options.config.directory,
-		ghfsVersion: GHFS_VERSION,
-		wsPath: "/__ws",
-		devMode: Boolean(options.devMode)
-	})));
-	app.use(router);
-	if (options.devMode) app.use("/", eventHandler((event) => {
-		setResponseStatus(event, 200);
-		setResponseHeader(event, "content-type", "text/plain; charset=utf-8");
-		return `ghfs ui dev mode — open http://localhost:7711 for the Vite-powered UI.\n`;
-	}));
-	else {
-		const staticDir = join(distDir, "ui");
-		app.use("/", await createStaticHandler(staticDir));
-	}
-	const port = await getPort({
-		port: options.port,
-		portRange: [options.port, options.port + 19],
-		host: options.host
-	});
-	const httpServer = createServer(toNodeListener(app));
-	const wss = new WebSocketServer({
-		server: httpServer,
-		path: "/__ws"
-	});
-	wss.on("connection", (socket) => {
-		const rpc = createBirpc(serverFunctions, {
-			post: (data) => socket.send(data),
-			on: (fn) => socket.on("message", (raw) => {
-				fn(rawToString(raw));
-			}),
-			serialize: (data) => stringify$1(data),
-			deserialize: (raw) => parse$1(rawToString(raw)),
-			timeout: 12e4,
-			eventNames: EVENT_NAMES
-		});
-		clients.add(rpc);
-		socket.on("close", () => {
-			clients.delete(rpc);
-		});
-		socket.on("error", () => {
-			clients.delete(rpc);
-		});
-	});
-	await new Promise((resolvePromise, rejectPromise) => {
-		httpServer.once("error", rejectPromise);
-		httpServer.listen(port, options.host, () => {
-			httpServer.off("error", rejectPromise);
-			resolvePromise();
-		});
-	});
-	return {
-		url: `http://${options.host === "0.0.0.0" ? "localhost" : options.host}:${port}`,
-		port,
-		host: options.host,
-		close: async () => {
-			poller.close();
-			await watcher.close();
-			await new Promise((resolveClose) => wss.close(() => resolveClose()));
-			await new Promise((resolveClose) => httpServer.close(() => resolveClose()));
-		}
-	};
-}
-function createBroadcast(clients) {
-	return new Proxy({}, { get(_, prop) {
-		if (typeof prop !== "string") return void 0;
-		return (...args) => {
-			for (const rpc of clients) try {
-				const fn = rpc[prop];
-				if (typeof fn === "function") fn(...args);
-			} catch {}
-		};
-	} });
-}
-function rawToString(raw) {
-	if (typeof raw === "string") return raw;
-	if (raw instanceof Uint8Array) return Buffer.from(raw).toString("utf-8");
-	if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf-8");
-	return String(raw);
-}
-//#endregion
-export { isExecuteCancelledError as a, GHFS_VERSION as c, pathExists as d, getExecuteFile as f, executePendingChanges as i, ensureExecuteArtifacts as l, resolveConfig as m, syncRepository as n, loadSyncState as o, getStorageDirAbsolute as p, appendExecutionResult as r, GHFS_NAME as s, createUiServer as t, ACTIONS_COLOR_HEX as u };