@ghfs/cli 0.0.4 → 0.1.1

package/dist/server-BwSU4kqr.mjs

@@ -0,0 +1,3518 @@
+import { a as formatIssueNumber, c as CodedError, d as diagnostics, l as formatInline, n as normalizeReactions, t as createRepositoryProvider, u as log } from "./factory-DmX3S7tf.mjs";
+import { distDir } from "./dir.mjs";
+import process from "node:process";
+import { basename, dirname, isAbsolute, join, resolve } from "pathe";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+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 { fileURLToPath } from "node:url";
+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 CodedError(log.GHFS0105({ detail: error.message }, { cause: error }));
+	}
+	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 CodedError(log.GHFS0106({ detail: message }));
+	}
+	const { pending, sourceActions, actionErrors } = normalizeActionInputs(parsedResult.output);
+	if (actionErrors.length) throw new CodedError(log.GHFS0107({ detail: actionErrors.join("; ") }));
+	const customErrors = validateExecuteRules(pending);
+	if (customErrors.length) throw new CodedError(log.GHFS0108({ detail: 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: formatInline(diagnostics.GHFS0150())
+	};
+	if (tokens.length === 0) return void 0;
+	const [commandInput, ...args] = tokens;
+	const command = resolveActionName(commandInput);
+	if (!command) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0151({ command: 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: formatInline(diagnostics.GHFS0151({ command: 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: formatInline(diagnostics.GHFS0152({
+			command: "set-title",
+			syntax: "set-title #<number> \"<title>\""
+		}))
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0153({ command: "set-title" }))
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "set-title",
+			number,
+			title: args[1]
+		}
+	};
+}
+function parseAddLabels(args, command) {
+	if (args.length < 2) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0152({
+			command,
+			syntax: `${command} #<number> <label1, label2>`
+		}))
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0153({ command }))
+	};
+	const labels = args.slice(1).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+	if (labels.length === 0) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0154({ command }))
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "add-labels",
+			number,
+			labels
+		}
+	};
+}
+function parseAddAssignees(args, command) {
+	if (args.length < 2) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0152({
+			command,
+			syntax: `${command} #<number> <assignee1, assignee2>`
+		}))
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0153({ command }))
+	};
+	const assignees = args.slice(1).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+	if (assignees.length === 0) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0155({ command }))
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "add-assignees",
+			number,
+			assignees
+		}
+	};
+}
+function parseAddComment(args, command) {
+	if (args.length < 2) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0152({
+			command,
+			syntax: `${command} #<number> "<comment>"`
+		}))
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0153({ command }))
+	};
+	const body = args.slice(1).join(" ").trim();
+	if (!body) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0156({ command }))
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "add-comment",
+			number,
+			body
+		}
+	};
+}
+function parseCloseWithComment(args, command) {
+	if (args.length < 2) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0152({
+			command,
+			syntax: `${command} #<number> "<comment>"`
+		}))
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0153({ command }))
+	};
+	const body = args.slice(1).join(" ").trim();
+	if (!body) return {
+		kind: "warning",
+		message: formatInline(diagnostics.GHFS0156({ command }))
+	};
+	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: formatInline(diagnostics.GHFS0157({ command }))
+	};
+	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.1";
+//#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;
+	const commits = Array.isArray(item.data.commits) ? item.data.commits : void 0;
+	const timeline = Array.isArray(item.data.timeline) ? item.data.timeline : void 0;
+	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)
+			})),
+			...commits ? { commits } : {},
+			...timeline ? { timeline } : {}
+		}
+	};
+}
+//#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(formatInline(diagnostics.GHFS0160({
+				issue: formatIssueNumber(tracked.number, { repo }),
+				path: tracked.filePath
+			})));
+			continue;
+		}
+		const frontmatter = parseFrontmatter(await readFile(markdownPath, "utf8"));
+		if (!frontmatter) {
+			warnings.push(formatInline(diagnostics.GHFS0161({ issue: 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 CodedError(log.GHFS0108({ detail: 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
+function createCancelledError() {
+	return new CodedError(log.GHFS0102());
+}
+function isExecuteCancelledError(error) {
+	return error instanceof CodedError && error.diagnostic.code === "GHFS0102";
+}
+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 CodedError(log.GHFS0100());
+		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 createCancelledError();
+		}
+		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 CodedError(log.GHFS0101({ 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 CodedError(log.GHFS0103({ 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 createCancelledError();
+	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 CodedError(log.GHFS0104({
+		action,
+		issue: `#${number}`
+	}));
+}
+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 shouldSyncPrDetails(sync, kind, state) {
+	if (kind === "issue") return true;
+	return sync.patches === "all" || sync.patches === "open" && state === "open";
+}
+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 needsDetails = shouldSyncPrDetails(context.config.sync, kind, state);
+	const hasCanonicalData = Boolean(tracked?.data && (kind !== "pull" || tracked.data.pull) && (!needsDetails || tracked.data.timeline && (kind !== "pull" || tracked.data.commits)));
+	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 CodedError(log.GHFS0401({ issue: 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) {
+	const includeDetails = shouldSyncPrDetails(context.config.sync, issue.kind, issue.state);
+	const [comments, pull, commits, timeline] = await Promise.all([
+		context.provider.fetchComments(issue.number),
+		issue.kind === "pull" ? context.provider.fetchPullMetadata(issue.number) : Promise.resolve(void 0),
+		issue.kind === "pull" && includeDetails ? context.provider.fetchPullCommits(issue.number) : Promise.resolve(void 0),
+		includeDetails ? context.provider.fetchTimeline(issue.number) : Promise.resolve(void 0)
+	]);
+	return {
+		item: issue,
+		comments,
+		pull,
+		commits,
+		timeline
+	};
+}
+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 CodedError(log.GHFS0400());
+}
+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/portless.ts
+const execFileAsync = promisify(execFile);
+function slugifyRepoName(repo) {
+	return (repo.includes("/") ? repo.slice(repo.lastIndexOf("/") + 1) : repo).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+}
+function resolvePortlessCliPath() {
+	try {
+		return resolve(dirname(fileURLToPath(import.meta.resolve("portless"))), "cli.js");
+	} catch {
+		return;
+	}
+}
+async function runPortless(args) {
+	const cliPath = resolvePortlessCliPath();
+	if (!cliPath) throw new CodedError(log.GHFS0206({ detail: "portless package is not installed" }));
+	try {
+		const { stdout } = await execFileAsync(process.execPath, [cliPath, ...args], { env: {
+			...process.env,
+			FORCE_COLOR: "0"
+		} });
+		return stdout;
+	} catch (error) {
+		const err = error;
+		const detail = (err.stderr || err.stdout || err.message || "").toString().trim();
+		throw new CodedError(log.GHFS0206({ detail: detail ? `portless failed: ${detail}` : "portless failed" }, { cause: error }));
+	}
+}
+async function registerPortlessRoute(options) {
+	const namespace = options.namespace ?? "ghfs";
+	const tld = options.tld ?? "localhost";
+	const hostname = `${options.subdomain}.${namespace}`;
+	const fallbackUrl = `https://${hostname}.${tld}`;
+	await runPortless([
+		"alias",
+		hostname,
+		String(options.port)
+	]);
+	let url = fallbackUrl;
+	try {
+		const resolved = (await runPortless(["get", hostname])).trim().split(/\r?\n/).pop()?.trim();
+		if (resolved && /^https?:\/\//.test(resolved)) url = resolved;
+	} catch {}
+	let unregistered = false;
+	return {
+		hostname,
+		url,
+		async unregister() {
+			if (unregistered) return;
+			unregistered = true;
+			try {
+				await runPortless([
+					"alias",
+					"--remove",
+					hostname
+				]);
+			} catch {}
+		}
+	};
+}
+//#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 CodedError(log.GHFS0201());
+		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 CodedError(log.GHFS0202({ id }));
+	if (entry.source === "per-item") throw new CodedError(log.GHFS0203({ target: entry.filePath ?? "the markdown file" }));
+	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 CodedError(log.GHFS0204());
+	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 CodedError(log.GHFS0202({ id }));
+	if (entry.source !== "execute.yml") throw new CodedError(log.GHFS0205({ source: entry.source }));
+	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/sync/repo-snapshot.ts
+async function loadRepoSnapshot(storageDirAbsolute) {
+	try {
+		const raw = await readFile(join(storageDirAbsolute, REPO_SNAPSHOT_FILE_NAME), "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/server/ui-state.ts
+const UI_STATE_FILE = ".ui.json";
+function createEmptyUiState() {
+	return { drafts: {} };
+}
+function normalizePrTab(value) {
+	if (value === "conversation" || value === "commits" || value === "changes") return value;
+}
+function normalizeUserOverride(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const raw = value;
+	const out = {};
+	if (typeof raw.login === "string" && raw.login.trim()) out.login = raw.login.trim();
+	if (typeof raw.name === "string" && raw.name.trim()) out.name = raw.name.trim();
+	if (typeof raw.avatarUrl === "string" && raw.avatarUrl.startsWith("https://")) out.avatarUrl = raw.avatarUrl.trim();
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+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,
+			lastPrTab: normalizePrTab(parsed.lastPrTab),
+			userOverride: normalizeUserOverride(parsed.userOverride)
+		};
+	} catch {
+		return createEmptyUiState();
+	}
+}
+async function saveUiState(storageDirAbsolute, state) {
+	await mkdir(storageDirAbsolute, { recursive: true });
+	const tab = normalizePrTab(state.lastPrTab);
+	const override = normalizeUserOverride(state.userOverride);
+	const clean = {
+		drafts: { ...state.drafts },
+		...state.listPaneSize != null ? { listPaneSize: state.listPaneSize } : {},
+		...tab ? { lastPrTab: tab } : {},
+		...override ? { userOverride: override } : {}
+	};
+	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, snapshot] = await Promise.all([
+			getRepoMeta(),
+			getSyncState(),
+			getQueue(),
+			loadUiState(ctx.storageDirAbsolute),
+			loadRepoSnapshot(ctx.storageDirAbsolute)
+		]);
+		const repositoryLabels = (snapshot?.labels ?? []).map((label) => ({
+			name: label.name,
+			color: label.color,
+			description: label.description
+		}));
+		const currentUser = await resolveCurrentUser(ctx, uiState);
+		return {
+			repo,
+			syncState,
+			queue,
+			remote: ctx.poller.getCurrent(),
+			recentExecutions: syncState.executions ?? [],
+			uiState,
+			repositoryLabels,
+			currentUser
+		};
+	}
+	async function getPullPatch(number) {
+		const tracked = (await loadSyncState(ctx.storageDirAbsolute)).items[String(number)];
+		if (!tracked?.patchPath) return null;
+		try {
+			return await readFile(join(ctx.storageDirAbsolute, tracked.patchPath), "utf8");
+		} catch (err) {
+			if (err.code === "ENOENT") return null;
+			throw err;
+		}
+	}
+	return {
+		getInitialPayload,
+		getSyncState,
+		getQueue,
+		getRepoMeta,
+		saveUiState: (state) => saveUiState(ctx.storageDirAbsolute, state),
+		getPullPatch
+	};
+}
+async function resolveCurrentUser(ctx, uiState) {
+	const override = uiState.userOverride;
+	let fetched = null;
+	try {
+		const user = await (await ctx.getProvider())?.fetchAuthenticatedUser();
+		if (user) fetched = {
+			login: user.login,
+			name: user.name,
+			avatarUrl: user.avatarUrl
+		};
+	} catch {
+		fetched = null;
+	}
+	if (!override && !fetched) return null;
+	const login = override?.login ?? fetched?.login;
+	if (!login) return null;
+	return {
+		login,
+		name: override?.name ?? fetched?.name ?? null,
+		avatarUrl: override?.avatarUrl ?? fetched?.avatarUrl ?? `https://avatars.githubusercontent.com/${login}`
+	};
+}
+//#endregion
+//#region src/server/handlers/sync.ts
+function createSyncHandler(ctx) {
+	let running = false;
+	return async function triggerSync(options) {
+		if (running) throw new CodedError(log.GHFS0200());
+		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,
+		getPullPatch: state.getPullPatch
+	};
+}
+//#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 CodedError(log.GHFS0001());
+	}
+	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();
+		});
+	});
+	const directUrl = `http://${options.host === "0.0.0.0" ? "localhost" : options.host}:${port}`;
+	let portlessUrl;
+	let portlessUnregister;
+	if (options.portless?.enabled) try {
+		const route = await registerPortlessRoute({
+			subdomain: options.portless.subdomain,
+			namespace: options.portless.namespace,
+			port
+		});
+		portlessUrl = route.url;
+		portlessUnregister = route.unregister;
+	} catch (error) {
+		const message = error.message || String(error);
+		options.logger?.info?.(`portless unavailable (${message}); falling back to ${directUrl}`);
+	}
+	return {
+		url: portlessUrl ?? directUrl,
+		directUrl,
+		portlessUrl,
+		port,
+		host: options.host,
+		close: async () => {
+			if (portlessUnregister) await portlessUnregister();
+			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 { executePendingChanges as a, GHFS_NAME as c, ACTIONS_COLOR_HEX as d, pathExists as f, resolveConfig as h, appendExecutionResult as i, GHFS_VERSION as l, getStorageDirAbsolute as m, slugifyRepoName as n, isExecuteCancelledError as o, getExecuteFile as p, syncRepository as r, loadSyncState as s, createUiServer as t, ensureExecuteArtifacts as u };