@sanurb/ringi 0.2.0 → 0.2.1

package/dist/runtime.mjs

@@ -0,0 +1,2975 @@
+import { execFile, spawn } from "node:child_process";
+import { mkdirSync, stat, unwatchFile, watch, watchFile } from "node:fs";
+import * as sp from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import * as HttpApiSchema from "@effect/platform/HttpApiSchema";
+import * as Schema from "effect/Schema";
+import { lstat, open, readFile, readdir, realpath, stat as stat$1 } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { DatabaseSync } from "node:sqlite";
+import * as Config from "effect/Config";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import "effect/ManagedRuntime";
+import { platform, type } from "node:os";
+import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
+import * as Queue from "effect/Queue";
+import * as Runtime from "effect/Runtime";
+import * as Stream from "effect/Stream";
+//#region ../../packages/core/src/schemas/review.ts
+const ReviewId = Schema.String.pipe(Schema.brand("ReviewId"));
+const ReviewStatus = Schema.Literal("in_progress", "approved", "changes_requested");
+const ReviewSourceType = Schema.Literal("staged", "branch", "commits");
+Schema.Struct({
+	baseRef: Schema.NullOr(Schema.String),
+	createdAt: Schema.String,
+	id: ReviewId,
+	repositoryPath: Schema.String,
+	snapshotData: Schema.String,
+	sourceRef: Schema.NullOr(Schema.String),
+	sourceType: ReviewSourceType,
+	status: ReviewStatus,
+	updatedAt: Schema.String
+});
+Schema.Struct({
+	sourceRef: Schema.optionalWith(Schema.NullOr(Schema.String), { default: () => null }),
+	sourceType: Schema.optionalWith(ReviewSourceType, { default: () => "staged" })
+});
+Schema.Struct({ status: Schema.optionalWith(ReviewStatus, { as: "Option" }) });
+var ReviewNotFound = class extends Schema.TaggedError()("ReviewNotFound", { id: ReviewId }, HttpApiSchema.annotations({ status: 404 })) {};
+//#endregion
+//#region ../../packages/core/src/schemas/todo.ts
+const TodoId = Schema.String.pipe(Schema.brand("TodoId"));
+Schema.Struct({
+	completed: Schema.Boolean,
+	content: Schema.String,
+	createdAt: Schema.String,
+	id: TodoId,
+	position: Schema.Number,
+	reviewId: Schema.NullOr(ReviewId),
+	updatedAt: Schema.String
+});
+Schema.Struct({
+	content: Schema.String.pipe(Schema.minLength(1)),
+	reviewId: Schema.optionalWith(Schema.NullOr(ReviewId), { default: () => null })
+});
+Schema.Struct({
+	completed: Schema.optionalWith(Schema.Boolean, { as: "Option" }),
+	content: Schema.optionalWith(Schema.String.pipe(Schema.minLength(1)), { as: "Option" })
+});
+var TodoNotFound = class extends Schema.TaggedError()("TodoNotFound", { id: TodoId }, HttpApiSchema.annotations({ status: 404 })) {};
+//#endregion
+//#region ../../packages/core/src/db/migrations.ts
+const migrations = [
+	`CREATE TABLE IF NOT EXISTS reviews (
+    id TEXT PRIMARY KEY,
+    repository_path TEXT NOT NULL,
+    base_ref TEXT,
+    snapshot_data TEXT NOT NULL,
+    status TEXT DEFAULT 'in_progress',
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+	`CREATE TABLE IF NOT EXISTS comments (
+    id TEXT PRIMARY KEY,
+    review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+    file_path TEXT NOT NULL,
+    line_number INTEGER,
+    line_type TEXT,
+    content TEXT NOT NULL,
+    suggestion TEXT,
+    resolved INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+	`ALTER TABLE reviews ADD COLUMN source_type TEXT DEFAULT 'staged';
+   ALTER TABLE reviews ADD COLUMN source_ref TEXT`,
+	`CREATE TABLE IF NOT EXISTS todos (
+    id TEXT PRIMARY KEY,
+    content TEXT NOT NULL,
+    completed INTEGER DEFAULT 0,
+    review_id TEXT REFERENCES reviews(id) ON DELETE CASCADE,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+	`ALTER TABLE todos ADD COLUMN position INTEGER DEFAULT 0`,
+	`CREATE TABLE IF NOT EXISTS review_files (
+    id TEXT PRIMARY KEY,
+    review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+    file_path TEXT NOT NULL,
+    old_path TEXT,
+    status TEXT NOT NULL,
+    additions INTEGER NOT NULL DEFAULT 0,
+    deletions INTEGER NOT NULL DEFAULT 0,
+    hunks_data TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`
+];
+/** Apply pending migrations using PRAGMA user_version as the version tracker. */
+const runMigrations = (db) => {
+	const currentVersion = db.prepare("PRAGMA user_version").get().user_version;
+	for (let i = currentVersion; i < migrations.length; i++) {
+		const statements = migrations[i].split(";").map((s) => s.trim()).filter(Boolean);
+		for (const sql of statements) db.exec(sql);
+		db.exec(`PRAGMA user_version = ${i + 1}`);
+	}
+};
+//#endregion
+//#region ../../packages/core/src/db/database.ts
+/**
+* Wraps `body` in a SQLite transaction: BEGIN before, COMMIT on success,
+* ROLLBACK on any failure or interruption.
+*/
+const withTransaction = (db, body) => Effect.acquireUseRelease(Effect.sync(() => db.exec("BEGIN")), () => body, (_, exit) => Effect.sync(() => {
+	if (Exit.isSuccess(exit)) db.exec("COMMIT");
+	else db.exec("ROLLBACK");
+}));
+var SqliteService = class extends Effect.Service()("@ringi/SqliteService", { effect: Effect.gen(function* effect() {
+	const dbPath = yield* Config.string("DB_PATH").pipe(Config.withDefault(".ringi/reviews.db"));
+	mkdirSync(dirname(dbPath), { recursive: true });
+	const db = new DatabaseSync(dbPath);
+	db.exec("PRAGMA journal_mode=WAL");
+	db.exec("PRAGMA foreign_keys=ON");
+	runMigrations(db);
+	return { db };
+}) }) {};
+//#endregion
+//#region ../../packages/core/src/repos/comment.repo.ts
+const rowToComment = (row) => ({
+	content: row.content,
+	createdAt: row.created_at,
+	filePath: row.file_path,
+	id: row.id,
+	lineNumber: row.line_number,
+	lineType: row.line_type,
+	resolved: row.resolved === 1,
+	reviewId: row.review_id,
+	suggestion: row.suggestion,
+	updatedAt: row.updated_at
+});
+var CommentRepo = class extends Effect.Service()("@ringi/CommentRepo", {
+	dependencies: [SqliteService.Default],
+	effect: Effect.gen(function* effect() {
+		const { db } = yield* SqliteService;
+		const stmtFindById = db.prepare("SELECT * FROM comments WHERE id = ?");
+		const stmtFindByReview = db.prepare("SELECT * FROM comments WHERE review_id = ? ORDER BY created_at ASC");
+		const stmtFindByFile = db.prepare("SELECT * FROM comments WHERE review_id = ? AND file_path = ? ORDER BY line_number ASC, created_at ASC");
+		const stmtInsert = db.prepare(`INSERT INTO comments (id, review_id, file_path, line_number, line_type, content, suggestion, resolved, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 0, datetime('now'), datetime('now'))`);
+		const stmtDelete = db.prepare("DELETE FROM comments WHERE id = ?");
+		const stmtDeleteByReview = db.prepare("DELETE FROM comments WHERE review_id = ?");
+		const stmtSetResolved = db.prepare("UPDATE comments SET resolved = ?, updated_at = datetime('now') WHERE id = ?");
+		const stmtCountByReview = db.prepare(`SELECT
+         COUNT(*) as total,
+         SUM(CASE WHEN resolved = 1 THEN 1 ELSE 0 END) as resolved,
+         SUM(CASE WHEN resolved = 0 THEN 1 ELSE 0 END) as unresolved,
+         SUM(CASE WHEN suggestion IS NOT NULL THEN 1 ELSE 0 END) as with_suggestions
+       FROM comments WHERE review_id = ?`);
+		const findById = (id) => Effect.sync(() => {
+			const row = stmtFindById.get(id);
+			return row ? rowToComment(row) : null;
+		});
+		const findByReview = (reviewId) => Effect.sync(() => {
+			return stmtFindByReview.all(reviewId).map(rowToComment);
+		});
+		const findByFile = (reviewId, filePath) => Effect.sync(() => {
+			return stmtFindByFile.all(reviewId, filePath).map(rowToComment);
+		});
+		const create = (input) => Effect.sync(() => {
+			stmtInsert.run(input.id, input.reviewId, input.filePath, input.lineNumber, input.lineType, input.content, input.suggestion);
+			return rowToComment(stmtFindById.get(input.id));
+		});
+		const update = (id, updates) => Effect.sync(() => {
+			const setClauses = [];
+			const params = [];
+			if (updates.content !== void 0) {
+				setClauses.push("content = ?");
+				params.push(updates.content);
+			}
+			if (updates.suggestion !== void 0) {
+				setClauses.push("suggestion = ?");
+				params.push(updates.suggestion);
+			}
+			if (setClauses.length === 0) {
+				const row = stmtFindById.get(id);
+				return row ? rowToComment(row) : null;
+			}
+			setClauses.push("updated_at = datetime('now')");
+			params.push(id);
+			db.prepare(`UPDATE comments SET ${setClauses.join(", ")} WHERE id = ?`).run(...params);
+			const row = stmtFindById.get(id);
+			return row ? rowToComment(row) : null;
+		});
+		const setResolved = (id, resolved) => Effect.sync(() => {
+			stmtSetResolved.run(resolved ? 1 : 0, id);
+			const row = stmtFindById.get(id);
+			return row ? rowToComment(row) : null;
+		});
+		const remove = (id) => Effect.sync(() => {
+			const result = stmtDelete.run(id);
+			return Number(result.changes) > 0;
+		});
+		const removeByReview = (reviewId) => Effect.sync(() => {
+			const result = stmtDeleteByReview.run(reviewId);
+			return Number(result.changes);
+		});
+		const countByReview = (reviewId) => Effect.sync(() => {
+			const row = stmtCountByReview.get(reviewId);
+			return {
+				resolved: row.resolved,
+				total: row.total,
+				unresolved: row.unresolved,
+				withSuggestions: row.with_suggestions
+			};
+		});
+		return {
+			countByReview,
+			create,
+			findByFile,
+			findById,
+			findByReview,
+			remove,
+			removeByReview,
+			setResolved,
+			update
+		};
+	})
+}) {};
+//#endregion
+//#region ../../packages/core/src/schemas/comment.ts
+const CommentId = Schema.String.pipe(Schema.brand("CommentId"));
+const LineType = Schema.Literal("added", "removed", "context");
+Schema.Struct({
+	content: Schema.String,
+	createdAt: Schema.String,
+	filePath: Schema.String,
+	id: CommentId,
+	lineNumber: Schema.NullOr(Schema.Number),
+	lineType: Schema.NullOr(LineType),
+	resolved: Schema.Boolean,
+	reviewId: ReviewId,
+	suggestion: Schema.NullOr(Schema.String),
+	updatedAt: Schema.String
+});
+Schema.Struct({
+	content: Schema.String.pipe(Schema.minLength(1)),
+	filePath: Schema.String.pipe(Schema.minLength(1)),
+	lineNumber: Schema.optionalWith(Schema.NullOr(Schema.Number), { default: () => null }),
+	lineType: Schema.optionalWith(Schema.NullOr(LineType), { default: () => null }),
+	suggestion: Schema.optionalWith(Schema.NullOr(Schema.String), { default: () => null })
+});
+Schema.Struct({
+	content: Schema.optionalWith(Schema.String.pipe(Schema.minLength(1)), { as: "Option" }),
+	suggestion: Schema.optionalWith(Schema.NullOr(Schema.String), { as: "Option" })
+});
+var CommentNotFound = class extends Schema.TaggedError()("CommentNotFound", { id: CommentId }, HttpApiSchema.annotations({ status: 404 })) {};
+//#endregion
+//#region ../../packages/core/src/services/comment.service.ts
+var CommentService = class extends Effect.Service()("@ringi/CommentService", {
+	dependencies: [CommentRepo.Default],
+	effect: Effect.sync(() => {
+		const create = Effect.fn("CommentService.create")(function* create(reviewId, input) {
+			const repo = yield* CommentRepo;
+			const id = randomUUID();
+			return yield* repo.create({
+				content: input.content,
+				filePath: input.filePath,
+				id,
+				lineNumber: input.lineNumber,
+				lineType: input.lineType,
+				reviewId,
+				suggestion: input.suggestion
+			});
+		});
+		const getById = Effect.fn("CommentService.getById")(function* getById(id) {
+			const comment = yield* (yield* CommentRepo).findById(id);
+			if (!comment) return yield* new CommentNotFound({ id });
+			return comment;
+		});
+		const getByReview = Effect.fn("CommentService.getByReview")(function* getByReview(reviewId) {
+			return yield* (yield* CommentRepo).findByReview(reviewId);
+		});
+		const getByFile = Effect.fn("CommentService.getByFile")(function* getByFile(reviewId, filePath) {
+			return yield* (yield* CommentRepo).findByFile(reviewId, filePath);
+		});
+		const update = Effect.fn("CommentService.update")(function* update(id, input) {
+			const repo = yield* CommentRepo;
+			const updates = {};
+			if (Option.isSome(input.content)) updates.content = input.content.value;
+			if (Option.isSome(input.suggestion)) updates.suggestion = input.suggestion.value;
+			const comment = yield* repo.update(id, updates);
+			if (!comment) return yield* new CommentNotFound({ id });
+			return comment;
+		});
+		const resolve = Effect.fn("CommentService.resolve")(function* resolve(id) {
+			const comment = yield* (yield* CommentRepo).setResolved(id, true);
+			if (!comment) return yield* new CommentNotFound({ id });
+			return comment;
+		});
+		const unresolve = Effect.fn("CommentService.unresolve")(function* unresolve(id) {
+			const comment = yield* (yield* CommentRepo).setResolved(id, false);
+			if (!comment) return yield* new CommentNotFound({ id });
+			return comment;
+		});
+		const remove = Effect.fn("CommentService.remove")(function* remove(id) {
+			if (!(yield* (yield* CommentRepo).remove(id))) return yield* new CommentNotFound({ id });
+			return { success: true };
+		});
+		return {
+			create,
+			getByFile,
+			getById,
+			getByReview,
+			getStats: Effect.fn("CommentService.getStats")(function* getStats(reviewId) {
+				return yield* (yield* CommentRepo).countByReview(reviewId);
+			}),
+			remove,
+			resolve,
+			unresolve,
+			update
+		};
+	})
+}) {};
+//#endregion
+//#region ../../packages/core/src/services/diff.service.ts
+const HUNK_HEADER = /@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+const splitIntoFiles = (diffText) => {
+	const files = [];
+	const lines = diffText.split("\n");
+	let current = [];
+	for (const line of lines) if (line.startsWith("diff --git")) {
+		if (current.length > 0) files.push(current.join("\n"));
+		current = [line];
+	} else current.push(line);
+	if (current.length > 0) files.push(current.join("\n"));
+	return files;
+};
+const parseHunks$1 = (lines) => {
+	const hunks = [];
+	let currentHunk = null;
+	let oldLineNum = 0;
+	let newLineNum = 0;
+	for (const line of lines) {
+		const match = line.match(HUNK_HEADER);
+		if (match) {
+			if (currentHunk) hunks.push(currentHunk);
+			const oldStart = Number.parseInt(match[1], 10);
+			const oldLines = Number.parseInt(match[2] ?? "1", 10);
+			const newStart = Number.parseInt(match[3], 10);
+			currentHunk = {
+				lines: [],
+				newLines: Number.parseInt(match[4] ?? "1", 10),
+				newStart,
+				oldLines,
+				oldStart
+			};
+			oldLineNum = oldStart;
+			newLineNum = newStart;
+			continue;
+		}
+		if (!currentHunk) continue;
+		if (line.startsWith("+") && !line.startsWith("+++")) currentHunk.lines.push({
+			content: line.slice(1),
+			newLineNumber: newLineNum++,
+			oldLineNumber: null,
+			type: "added"
+		});
+		else if (line.startsWith("-") && !line.startsWith("---")) currentHunk.lines.push({
+			content: line.slice(1),
+			newLineNumber: null,
+			oldLineNumber: oldLineNum++,
+			type: "removed"
+		});
+		else if (line.startsWith(" ")) currentHunk.lines.push({
+			content: line.slice(1),
+			newLineNumber: newLineNum++,
+			oldLineNumber: oldLineNum++,
+			type: "context"
+		});
+	}
+	if (currentHunk) hunks.push(currentHunk);
+	return hunks;
+};
+const parseFileDiff = (fileDiff) => {
+	const lines = fileDiff.split("\n");
+	const diffLine = lines.find((l) => l.startsWith("diff --git"));
+	if (!diffLine) return null;
+	const pathMatch = diffLine.match(/diff --git a\/(.+) b\/(.+)/);
+	if (!pathMatch) return null;
+	const oldPath = pathMatch[1];
+	const newPath = pathMatch[2];
+	let status = "modified";
+	if (lines.some((l) => l.startsWith("deleted file mode"))) status = "deleted";
+	else if (lines.some((l) => l.startsWith("new file mode"))) status = "added";
+	else if (lines.some((l) => l.startsWith("rename from")) || oldPath !== newPath) status = "renamed";
+	const hunks = parseHunks$1(lines);
+	let additions = 0;
+	let deletions = 0;
+	for (const hunk of hunks) for (const line of hunk.lines) if (line.type === "added") additions++;
+	else if (line.type === "removed") deletions++;
+	return {
+		additions,
+		deletions,
+		hunks,
+		newPath,
+		oldPath,
+		status
+	};
+};
+/** Parse a full multi-file unified diff into structured DiffFile objects. */
+const parseDiff = (diffText) => {
+	if (!diffText.trim()) return [];
+	const blocks = splitIntoFiles(diffText);
+	const files = [];
+	for (const block of blocks) {
+		const parsed = parseFileDiff(block);
+		if (parsed) files.push(parsed);
+	}
+	return files;
+};
+/** Aggregate stats from already-parsed files. */
+const getDiffSummary = (files) => {
+	let totalAdditions = 0;
+	let totalDeletions = 0;
+	for (const file of files) {
+		totalAdditions += file.additions;
+		totalDeletions += file.deletions;
+	}
+	return {
+		filesAdded: files.filter((f) => f.status === "added").length,
+		filesDeleted: files.filter((f) => f.status === "deleted").length,
+		filesModified: files.filter((f) => f.status === "modified").length,
+		filesRenamed: files.filter((f) => f.status === "renamed").length,
+		totalAdditions,
+		totalDeletions,
+		totalFiles: files.length
+	};
+};
+//#endregion
+//#region ../../packages/core/src/repos/review-file.repo.ts
+const parseHunks = (hunksData) => hunksData == null ? Effect.succeed([]) : Effect.try(() => JSON.parse(hunksData)).pipe(Effect.orElseSucceed(() => []));
+const serializeHunks = (hunks) => JSON.stringify(hunks);
+var ReviewFileRepo = class extends Effect.Service()("@ringi/ReviewFileRepo", {
+	dependencies: [SqliteService.Default],
+	effect: Effect.gen(function* effect() {
+		const { db } = yield* SqliteService;
+		const stmtFindByReview = db.prepare(`SELECT id, review_id, file_path, old_path, status, additions, deletions, created_at
+         FROM review_files WHERE review_id = ? ORDER BY file_path`);
+		const stmtFindByReviewAndPath = db.prepare("SELECT * FROM review_files WHERE review_id = ? AND file_path = ?");
+		const stmtInsert = db.prepare(`INSERT INTO review_files (id, review_id, file_path, old_path, status, additions, deletions, hunks_data, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`);
+		const stmtDeleteByReview = db.prepare("DELETE FROM review_files WHERE review_id = ?");
+		const stmtCountByReview = db.prepare("SELECT COUNT(*) as count FROM review_files WHERE review_id = ?");
+		const findByReview = (reviewId) => Effect.sync(() => stmtFindByReview.all(reviewId));
+		const findByReviewAndPath = (reviewId, filePath) => Effect.sync(() => {
+			return stmtFindByReviewAndPath.get(reviewId, filePath) ?? null;
+		});
+		const createBulk = (files) => withTransaction(db, Effect.sync(() => {
+			for (const f of files) stmtInsert.run(randomUUID(), f.reviewId, f.filePath, f.oldPath, f.status, f.additions, f.deletions, f.hunksData);
+		}));
+		const deleteByReview = (reviewId) => Effect.sync(() => {
+			const result = stmtDeleteByReview.run(reviewId);
+			return Number(result.changes);
+		});
+		const countByReview = (reviewId) => Effect.sync(() => {
+			return stmtCountByReview.get(reviewId).count;
+		});
+		return {
+			countByReview,
+			createBulk,
+			deleteByReview,
+			findByReview,
+			findByReviewAndPath
+		};
+	})
+}) {};
+//#endregion
+//#region ../../packages/core/src/repos/review.repo.ts
+const rowToReview = (row) => ({
+	baseRef: row.base_ref,
+	createdAt: row.created_at,
+	id: row.id,
+	repositoryPath: row.repository_path,
+	snapshotData: row.snapshot_data,
+	sourceRef: row.source_ref,
+	sourceType: row.source_type,
+	status: row.status,
+	updatedAt: row.updated_at
+});
+var ReviewRepo = class extends Effect.Service()("@ringi/ReviewRepo", {
+	dependencies: [SqliteService.Default],
+	effect: Effect.gen(function* effect() {
+		const { db } = yield* SqliteService;
+		const stmtFindById = db.prepare("SELECT * FROM reviews WHERE id = ?");
+		const stmtInsert = db.prepare(`INSERT INTO reviews (id, repository_path, base_ref, source_type, source_ref, snapshot_data, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))`);
+		const stmtUpdate = db.prepare(`UPDATE reviews SET status = COALESCE(?, status), updated_at = datetime('now') WHERE id = ?`);
+		const stmtDelete = db.prepare("DELETE FROM reviews WHERE id = ?");
+		const stmtCountAll = db.prepare("SELECT COUNT(*) as count FROM reviews");
+		const stmtCountByStatus = db.prepare("SELECT COUNT(*) as count FROM reviews WHERE status = ?");
+		const findById = (id) => Effect.sync(() => {
+			const row = stmtFindById.get(id);
+			return row ? rowToReview(row) : null;
+		});
+		const findAll = (opts = {}) => Effect.sync(() => {
+			const conditions = [];
+			const params = [];
+			if (opts.status != null) {
+				conditions.push("status = ?");
+				params.push(opts.status);
+			}
+			if (opts.repositoryPath != null) {
+				conditions.push("repository_path = ?");
+				params.push(opts.repositoryPath);
+			}
+			if (opts.sourceType != null) {
+				conditions.push("source_type = ?");
+				params.push(opts.sourceType);
+			}
+			const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+			const page = opts.page ?? 1;
+			const pageSize = opts.pageSize ?? 20;
+			const offset = (page - 1) * pageSize;
+			const totalRow = db.prepare(`SELECT COUNT(*) as count FROM reviews${where}`).get(...params);
+			return {
+				data: db.prepare(`SELECT * FROM reviews${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, pageSize, offset).map(rowToReview),
+				total: totalRow.count
+			};
+		});
+		const create = (input) => Effect.sync(() => {
+			stmtInsert.run(input.id, input.repositoryPath, input.baseRef, input.sourceType, input.sourceRef, input.snapshotData, input.status);
+			return rowToReview(stmtFindById.get(input.id));
+		});
+		const update = (id, status) => Effect.sync(() => {
+			stmtUpdate.run(status, id);
+			const row = stmtFindById.get(id);
+			return row ? rowToReview(row) : null;
+		});
+		const remove = (id) => Effect.sync(() => {
+			const result = stmtDelete.run(id);
+			return Number(result.changes) > 0;
+		});
+		const countAll = () => Effect.sync(() => {
+			return stmtCountAll.get().count;
+		});
+		const countByStatus = (status) => Effect.sync(() => {
+			return stmtCountByStatus.get(status).count;
+		});
+		return {
+			countAll,
+			countByStatus,
+			create,
+			findAll,
+			findById,
+			remove,
+			update
+		};
+	})
+}) {};
+//#endregion
+//#region ../../packages/core/src/services/git.service.ts
+var GitError = class extends Schema.TaggedError()("GitError", { message: Schema.String }, HttpApiSchema.annotations({ status: 500 })) {};
+/** Max bytes to collect from a git command before truncating (200 MB). */
+const MAX_STDOUT_BYTES = 200 * 1024 * 1024;
+const execGit = (args, repoPath) => Effect.tryPromise({
+	catch: (error) => new GitError({ message: String(error) }),
+	try: () => new Promise((resolve, reject) => {
+		const child = spawn("git", [...args], { cwd: repoPath });
+		const chunks = [];
+		let bytes = 0;
+		let truncated = false;
+		child.stdout.on("data", (chunk) => {
+			if (truncated) return;
+			bytes += chunk.length;
+			if (bytes > MAX_STDOUT_BYTES) {
+				truncated = true;
+				child.kill();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		let stderr = "";
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (truncated) {
+				resolve(Buffer.concat(chunks).toString("utf8"));
+				return;
+			}
+			if (code !== 0) reject(/* @__PURE__ */ new Error(`git ${args[0]} exited with code ${code}: ${stderr}`));
+			else resolve(Buffer.concat(chunks).toString("utf8"));
+		});
+	})
+});
+/** Split git output into non-empty lines. */
+const lines = (output) => output.trim().split("\n").filter(Boolean);
+/** Parse name-status output (e.g. `M\tfile.ts`). */
+const parseNameStatus = (output) => lines(output).map((line) => {
+	const [status, ...rest] = line.split("	");
+	return {
+		path: rest.join("	"),
+		status
+	};
+});
+var GitService = class extends Effect.Service()("@ringi/GitService", { effect: Effect.gen(function* effect() {
+	const repoPath = yield* Config.string("REPOSITORY_PATH").pipe(Config.withDefault(process.cwd()));
+	const hasCommits = execGit(["rev-parse", "HEAD"], repoPath).pipe(Effect.as(true), Effect.catchTag("GitError", () => Effect.succeed(false)), Effect.withSpan("GitService.hasCommits"));
+	const getRepositoryInfo = Effect.gen(function* getRepositoryInfo() {
+		const name = yield* execGit(["rev-parse", "--show-toplevel"], repoPath).pipe(Effect.map((s) => s.trim().split("/").pop() ?? "unknown"));
+		return {
+			branch: yield* execGit([
+				"rev-parse",
+				"--abbrev-ref",
+				"HEAD"
+			], repoPath).pipe(Effect.map((s) => s.trim())),
+			name,
+			path: repoPath,
+			remote: yield* execGit([
+				"config",
+				"--get",
+				"remote.origin.url"
+			], repoPath).pipe(Effect.map((s) => s.trim() || null), Effect.catchTag("GitError", () => Effect.succeed(null)))
+		};
+	}).pipe(Effect.withSpan("GitService.getRepositoryInfo"));
+	const getStagedDiff = execGit([
+		"diff",
+		"--cached",
+		"--no-color",
+		"--unified=3"
+	], repoPath).pipe(Effect.withSpan("GitService.getStagedDiff"));
+	const getUncommittedDiff = hasCommits.pipe(Effect.flatMap((has) => has ? execGit([
+		"diff",
+		"HEAD",
+		"--no-color",
+		"--unified=3"
+	], repoPath) : Effect.succeed("")), Effect.withSpan("GitService.getUncommittedDiff"));
+	const getUnstagedDiff = execGit([
+		"diff",
+		"--no-color",
+		"--unified=3"
+	], repoPath).pipe(Effect.withSpan("GitService.getUnstagedDiff"));
+	const getLastCommitDiff = hasCommits.pipe(Effect.flatMap((has) => has ? execGit([
+		"show",
+		"HEAD",
+		"--format=",
+		"--no-color",
+		"--unified=3"
+	], repoPath) : Effect.succeed("")), Effect.withSpan("GitService.getLastCommitDiff"));
+	const getBranchDiff = Effect.fn("GitService.getBranchDiff")(function* getBranchDiff(branch) {
+		return yield* execGit([
+			"diff",
+			`${branch}...HEAD`,
+			"--no-color",
+			"--unified=3"
+		], repoPath);
+	});
+	const getCommitDiff = Effect.fn("GitService.getCommitDiff")(function* getCommitDiff(shas) {
+		if (shas.length === 1) return yield* execGit([
+			"show",
+			shas[0],
+			"--format=",
+			"--no-color",
+			"--unified=3"
+		], repoPath);
+		const first = shas.at(-1);
+		const last = shas[0];
+		return yield* execGit([
+			"diff",
+			`${first}~1..${last}`,
+			"--no-color",
+			"--unified=3"
+		], repoPath);
+	});
+	const getStagedFiles = execGit([
+		"diff",
+		"--cached",
+		"--name-status"
+	], repoPath).pipe(Effect.map(parseNameStatus), Effect.withSpan("GitService.getStagedFiles"));
+	const getUncommittedFiles = hasCommits.pipe(Effect.flatMap((has) => has ? execGit([
+		"diff",
+		"HEAD",
+		"--name-status"
+	], repoPath).pipe(Effect.map(parseNameStatus)) : Effect.succeed([])), Effect.withSpan("GitService.getUncommittedFiles"));
+	const getUnstagedFiles = execGit(["diff", "--name-status"], repoPath).pipe(Effect.map(parseNameStatus), Effect.withSpan("GitService.getUnstagedFiles"));
+	const getLastCommitFiles = hasCommits.pipe(Effect.flatMap((has) => has ? execGit([
+		"show",
+		"HEAD",
+		"--format=",
+		"--name-status"
+	], repoPath).pipe(Effect.map(parseNameStatus)) : Effect.succeed([])), Effect.withSpan("GitService.getLastCommitFiles"));
+	const getFileContent = Effect.fn("GitService.getFileContent")(function* getFileContent(filePath, version) {
+		switch (version) {
+			case "staged": return yield* execGit(["show", `:${filePath}`], repoPath);
+			case "head": return yield* execGit(["show", `HEAD:${filePath}`], repoPath);
+			default: return yield* Effect.tryPromise({
+				catch: (error) => new GitError({ message: `Failed to read ${filePath}: ${String(error)}` }),
+				try: () => readFile(join(repoPath, filePath), "utf8")
+			});
+		}
+	});
+	const getFileTree = Effect.fn("GitService.getFileTree")(function* getFileTree(ref) {
+		return yield* execGit([
+			"ls-tree",
+			"-r",
+			"--name-only",
+			ref
+		], repoPath).pipe(Effect.map(lines));
+	});
+	const getBranches = execGit(["branch", "--format=%(refname:short)	%(HEAD)"], repoPath).pipe(Effect.map((output) => lines(output).map((line) => {
+		const [name, head] = line.split("	");
+		return {
+			current: head === "*",
+			name
+		};
+	})), Effect.withSpan("GitService.getBranches"));
+	const getCommits = Effect.fn("GitService.getCommits")(function* getCommits(opts) {
+		const limit = (opts.limit ?? 20) + 1;
+		const args = [
+			"log",
+			`--max-count=${limit}`,
+			`--skip=${opts.offset ?? 0}`,
+			"--format=%H	%s	%an	%aI"
+		];
+		if (opts.search) args.push(`--grep=${opts.search}`, "-i");
+		const rows = lines(yield* execGit(args, repoPath));
+		const hasMore = rows.length === limit;
+		return {
+			commits: (hasMore ? rows.slice(0, -1) : rows).map((line) => {
+				const [hash, message, author, date] = line.split("	");
+				return {
+					author,
+					date,
+					hash,
+					message
+				};
+			}),
+			hasMore
+		};
+	});
+	const stageFiles = Effect.fn("GitService.stageFiles")(function* stageFiles(files) {
+		return yield* execGit([
+			"add",
+			"--",
+			...files
+		], repoPath).pipe(Effect.as(files));
+	});
+	const stageAll = execGit(["add", "-A"], repoPath).pipe(Effect.flatMap(() => getStagedFiles), Effect.map((files) => files.map((f) => f.path)), Effect.withSpan("GitService.stageAll"));
+	const unstageFiles = Effect.fn("GitService.unstageFiles")(function* unstageFiles(files) {
+		return yield* execGit([
+			"reset",
+			"HEAD",
+			"--",
+			...files
+		], repoPath).pipe(Effect.as(files));
+	});
+	return {
+		getBranchDiff,
+		getBranches,
+		getCommitDiff,
+		getCommits,
+		getFileContent,
+		getFileTree,
+		getLastCommitDiff,
+		getLastCommitFiles,
+		getRepositoryInfo,
+		getRepositoryPath: execGit(["rev-parse", "--show-toplevel"], repoPath).pipe(Effect.map((s) => s.trim()), Effect.withSpan("GitService.getRepositoryPath")),
+		getStagedDiff,
+		getStagedFiles,
+		getUncommittedDiff,
+		getUncommittedFiles,
+		getUnstagedDiff,
+		getUnstagedFiles,
+		hasCommits,
+		stageAll,
+		stageFiles,
+		unstageFiles
+	};
+}) }) {};
+//#endregion
+//#region ../../packages/core/src/services/review.service.ts
+var ReviewError = class extends Schema.TaggedError()("ReviewError", {
+	code: Schema.String,
+	message: Schema.String
+}, HttpApiSchema.annotations({ status: 400 })) {};
+/** Get HEAD SHA via git rev-parse. */
+const getHeadSha = (repoPath) => Effect.tryPromise({
+	catch: () => new ReviewError({
+		code: "GIT_ERROR",
+		message: "Failed to get HEAD"
+	}),
+	try: () => new Promise((resolve, reject) => {
+		execFile("git", ["rev-parse", "HEAD"], { cwd: repoPath }, (err, stdout) => {
+			if (err) reject(err);
+			else resolve(stdout.trim());
+		});
+	})
+});
+/**
+* Parse snapshotData JSON. Handles both v1 and v2 formats gracefully.
+* v1: { files: DiffFile[], repository: {...} }
+* v2: { repository: {...}, version: 2 }
+*/
+const parseSnapshotData = (s) => Effect.try(() => JSON.parse(s)).pipe(Effect.orElseSucceed(() => ({})));
+var ReviewService = class extends Effect.Service()("@ringi/ReviewService", {
+	dependencies: [
+		ReviewRepo.Default,
+		ReviewFileRepo.Default,
+		GitService.Default
+	],
+	effect: Effect.sync(() => {
+		const create = Effect.fn("ReviewService.create")(function* create(input) {
+			const git = yield* GitService;
+			const repo = yield* ReviewRepo;
+			const fileRepo = yield* ReviewFileRepo;
+			const repoPath = yield* git.getRepositoryPath;
+			if (!(yield* git.hasCommits)) return yield* new ReviewError({
+				code: "NO_COMMITS",
+				message: "Repository has no commits"
+			});
+			let diffText;
+			let baseRef = null;
+			const { sourceType, sourceRef } = input;
+			switch (sourceType) {
+				case "staged":
+					diffText = yield* git.getStagedDiff;
+					if (!diffText.trim()) return yield* new ReviewError({
+						code: "NO_STAGED_CHANGES",
+						message: "No staged changes"
+					});
+					baseRef = yield* getHeadSha(repoPath);
+					break;
+				case "branch":
+					if (!sourceRef) return yield* new ReviewError({
+						code: "INVALID_SOURCE",
+						message: "Branch name required"
+					});
+					diffText = yield* git.getBranchDiff(sourceRef);
+					baseRef = sourceRef;
+					break;
+				case "commits": {
+					if (!sourceRef) return yield* new ReviewError({
+						code: "INVALID_SOURCE",
+						message: "Commit SHAs required"
+					});
+					const shas = sourceRef.split(",").map((s) => s.trim()).filter(Boolean);
+					if (shas.length === 0) return yield* new ReviewError({
+						code: "INVALID_SOURCE",
+						message: "No valid commit SHAs"
+					});
+					diffText = yield* git.getCommitDiff(shas);
+					baseRef = shas.at(-1) ?? null;
+					break;
+				}
+				default: return yield* new ReviewError({
+					code: "INVALID_SOURCE",
+					message: "Unsupported review source"
+				});
+			}
+			const files = parseDiff(diffText);
+			if (files.length === 0) return yield* new ReviewError({
+				code: "NO_CHANGES",
+				message: "No changes found"
+			});
+			const repoInfo = yield* git.getRepositoryInfo;
+			const reviewId = crypto.randomUUID();
+			const storeHunks = sourceType === "staged";
+			const fileInputs = files.map((f) => ({
+				additions: f.additions,
+				deletions: f.deletions,
+				filePath: f.newPath,
+				hunksData: storeHunks ? serializeHunks(f.hunks) : null,
+				oldPath: f.oldPath !== f.newPath ? f.oldPath : null,
+				reviewId,
+				status: f.status
+			}));
+			const snapshotData = JSON.stringify({
+				repository: repoInfo,
+				version: 2
+			});
+			const review = yield* repo.create({
+				baseRef,
+				id: reviewId,
+				repositoryPath: repoPath,
+				snapshotData,
+				sourceRef: sourceRef ?? null,
+				sourceType,
+				status: "in_progress"
+			});
+			yield* fileRepo.createBulk(fileInputs);
+			return review;
+		});
+		const list = Effect.fn("ReviewService.list")(function* list(opts) {
+			const repo = yield* ReviewRepo;
+			const fileRepo = yield* ReviewFileRepo;
+			const page = opts.page ?? 1;
+			const pageSize = opts.pageSize ?? 20;
+			const result = yield* repo.findAll({
+				page,
+				pageSize,
+				repositoryPath: opts.repositoryPath,
+				sourceType: opts.sourceType,
+				status: opts.status
+			});
+			const reviews = [];
+			for (const review of result.data) {
+				const fileCount = yield* fileRepo.countByReview(review.id);
+				const snapshot = yield* parseSnapshotData(review.snapshotData);
+				reviews.push({
+					...review,
+					fileCount,
+					repository: snapshot.repository ?? null
+				});
+			}
+			return {
+				hasMore: page * pageSize < result.total,
+				page,
+				pageSize,
+				reviews,
+				total: result.total
+			};
+		});
+		const getById = Effect.fn("ReviewService.getById")(function* getById(id) {
+			const repo = yield* ReviewRepo;
+			const fileRepo = yield* ReviewFileRepo;
+			const review = yield* repo.findById(id);
+			if (!review) return yield* new ReviewNotFound({ id });
+			const files = (yield* fileRepo.findByReview(id)).map((r) => ({
+				additions: r.additions,
+				deletions: r.deletions,
+				filePath: r.file_path,
+				id: r.id,
+				oldPath: r.old_path,
+				status: r.status
+			}));
+			const snapshot = yield* parseSnapshotData(review.snapshotData);
+			const summary = getDiffSummary(files.map((f) => ({
+				additions: f.additions,
+				deletions: f.deletions,
+				hunks: [],
+				newPath: f.filePath,
+				oldPath: f.oldPath ?? f.filePath,
+				status: f.status
+			})));
+			return {
+				...review,
+				files,
+				repository: snapshot.repository ?? null,
+				summary
+			};
+		});
+		const getFileHunks = Effect.fn("ReviewService.getFileHunks")(function* getFileHunks(reviewId, filePath) {
+			const repo = yield* ReviewRepo;
+			const fileRepo = yield* ReviewFileRepo;
+			const git = yield* GitService;
+			const review = yield* repo.findById(reviewId);
+			if (!review) return yield* new ReviewNotFound({ id: reviewId });
+			const fileRecord = yield* fileRepo.findByReviewAndPath(reviewId, filePath);
+			if (fileRecord?.hunks_data) return yield* parseHunks(fileRecord.hunks_data);
+			if (review.sourceType === "branch" && review.sourceRef) return parseDiff(yield* git.getBranchDiff(review.sourceRef)).find((f) => f.newPath === filePath)?.hunks ?? [];
+			if (review.sourceType === "commits" && review.sourceRef) {
+				const shas = review.sourceRef.split(",").map((s) => s.trim());
+				return parseDiff(yield* git.getCommitDiff(shas)).find((f) => f.newPath === filePath)?.hunks ?? [];
+			}
+			const snapshot = yield* parseSnapshotData(review.snapshotData);
+			if (snapshot.files) return snapshot.files.find((f) => f.newPath === filePath)?.hunks ?? [];
+			return [];
+		});
+		const update = Effect.fn("ReviewService.update")(function* update(id, input) {
+			const repo = yield* ReviewRepo;
+			if (!(yield* repo.findById(id))) return yield* new ReviewNotFound({ id });
+			const status = Option.getOrNull(input.status);
+			const review = yield* repo.update(id, status);
+			if (!review) return yield* new ReviewNotFound({ id });
+			return review;
+		});
+		const remove = Effect.fn("ReviewService.remove")(function* remove(id) {
+			const repo = yield* ReviewRepo;
+			const fileRepo = yield* ReviewFileRepo;
+			if (!(yield* repo.findById(id))) return yield* new ReviewNotFound({ id });
+			yield* fileRepo.deleteByReview(id);
+			yield* repo.remove(id);
+			return { success: true };
+		});
+		return {
+			create,
+			getById,
+			getFileHunks,
+			getStats: Effect.fn("ReviewService.getStats")(function* getStats() {
+				const repo = yield* ReviewRepo;
+				const total = yield* repo.countAll();
+				const inProgress = yield* repo.countByStatus("in_progress");
+				return {
+					approved: yield* repo.countByStatus("approved"),
+					changesRequested: yield* repo.countByStatus("changes_requested"),
+					inProgress,
+					total
+				};
+			}),
+			list,
+			remove,
+			update
+		};
+	})
+}) {};
+//#endregion
+//#region ../../packages/core/src/repos/todo.repo.ts
+const rowToTodo = (row) => ({
+	completed: row.completed === 1,
+	content: row.content,
+	createdAt: row.created_at,
+	id: row.id,
+	position: row.position,
+	reviewId: row.review_id,
+	updatedAt: row.updated_at
+});
+var TodoRepo = class extends Effect.Service()("@ringi/TodoRepo", {
+	dependencies: [SqliteService.Default],
+	effect: Effect.gen(function* effect() {
+		const { db } = yield* SqliteService;
+		const stmtFindById = db.prepare("SELECT * FROM todos WHERE id = ?");
+		const stmtInsert = db.prepare(`INSERT INTO todos (id, content, completed, review_id, position, created_at, updated_at)
+       VALUES (?, ?, 0, ?, ?, datetime('now'), datetime('now'))`);
+		const stmtDelete = db.prepare("DELETE FROM todos WHERE id = ?");
+		const stmtDeleteCompleted = db.prepare("DELETE FROM todos WHERE completed = 1");
+		const stmtNextPosition = db.prepare("SELECT COALESCE(MAX(position), -1) + 1 AS next_pos FROM todos");
+		const stmtCountAll = db.prepare("SELECT COUNT(*) as count FROM todos");
+		const stmtCountCompleted = db.prepare("SELECT COUNT(*) as count FROM todos WHERE completed = 1");
+		const stmtCountPending = db.prepare("SELECT COUNT(*) as count FROM todos WHERE completed = 0");
+		const findById = (id) => Effect.sync(() => {
+			const row = stmtFindById.get(id);
+			return row ? rowToTodo(row) : null;
+		});
+		const findAll = (opts = {}) => Effect.sync(() => {
+			const conditions = [];
+			const params = [];
+			if (opts.reviewId != null) {
+				conditions.push("review_id = ?");
+				params.push(opts.reviewId);
+			}
+			if (opts.completed != null) {
+				conditions.push("completed = ?");
+				params.push(opts.completed ? 1 : 0);
+			}
+			const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+			const totalRow = db.prepare(`SELECT COUNT(*) as count FROM todos${where}`).get(...params);
+			const limitClause = opts.limit != null ? ` LIMIT ? OFFSET ?` : "";
+			const queryParams = opts.limit != null ? [
+				...params,
+				opts.limit,
+				opts.offset ?? 0
+			] : params;
+			return {
+				data: db.prepare(`SELECT * FROM todos${where} ORDER BY position ASC${limitClause}`).all(...queryParams).map(rowToTodo),
+				total: totalRow.count
+			};
+		});
+		const create = (input) => Effect.sync(() => {
+			const { next_pos } = stmtNextPosition.get();
+			stmtInsert.run(input.id, input.content, input.reviewId, next_pos);
+			return rowToTodo(stmtFindById.get(input.id));
+		});
+		const update = (id, updates) => Effect.sync(() => {
+			const sets = [];
+			const params = [];
+			if (updates.content != null) {
+				sets.push("content = ?");
+				params.push(updates.content);
+			}
+			if (updates.completed != null) {
+				sets.push("completed = ?");
+				params.push(updates.completed ? 1 : 0);
+			}
+			if (sets.length === 0) {
+				const row = stmtFindById.get(id);
+				return row ? rowToTodo(row) : null;
+			}
+			sets.push("updated_at = datetime('now')");
+			params.push(id);
+			db.prepare(`UPDATE todos SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+			const row = stmtFindById.get(id);
+			return row ? rowToTodo(row) : null;
+		});
+		const toggle = (id) => Effect.sync(() => {
+			const row = stmtFindById.get(id);
+			if (!row) return null;
+			const newCompleted = row.completed === 1 ? 0 : 1;
+			db.prepare("UPDATE todos SET completed = ?, updated_at = datetime('now') WHERE id = ?").run(newCompleted, id);
+			return rowToTodo(stmtFindById.get(id));
+		});
+		const remove = (id) => Effect.sync(() => {
+			const result = stmtDelete.run(id);
+			return Number(result.changes) > 0;
+		});
+		const removeCompleted = () => Effect.sync(() => {
+			const result = stmtDeleteCompleted.run();
+			return Number(result.changes);
+		});
+		const reorder = (orderedIds) => withTransaction(db, Effect.sync(() => {
+			const stmt = db.prepare("UPDATE todos SET position = ?, updated_at = datetime('now') WHERE id = ?");
+			let updated = 0;
+			for (let i = 0; i < orderedIds.length; i++) {
+				const result = stmt.run(i, orderedIds[i]);
+				updated += Number(result.changes);
+			}
+			return updated;
+		}));
+		const move = (id, newPosition) => Effect.gen(function* move() {
+			const row = stmtFindById.get(id);
+			if (!row) return null;
+			const oldPosition = row.position;
+			yield* withTransaction(db, Effect.sync(() => {
+				if (newPosition < oldPosition) db.prepare("UPDATE todos SET position = position + 1, updated_at = datetime('now') WHERE position >= ? AND position < ? AND id != ?").run(newPosition, oldPosition, id);
+				else if (newPosition > oldPosition) db.prepare("UPDATE todos SET position = position - 1, updated_at = datetime('now') WHERE position > ? AND position <= ? AND id != ?").run(oldPosition, newPosition, id);
+				db.prepare("UPDATE todos SET position = ?, updated_at = datetime('now') WHERE id = ?").run(newPosition, id);
+			}));
+			return rowToTodo(stmtFindById.get(id));
+		});
+		const countAll = () => Effect.sync(() => {
+			return stmtCountAll.get().count;
+		});
+		const countCompleted = () => Effect.sync(() => {
+			return stmtCountCompleted.get().count;
+		});
+		const countPending = () => Effect.sync(() => {
+			return stmtCountPending.get().count;
+		});
+		return {
+			countAll,
+			countCompleted,
+			countPending,
+			create,
+			findAll,
+			findById,
+			move,
+			remove,
+			removeCompleted,
+			reorder,
+			toggle,
+			update
+		};
+	})
+}) {};
+//#endregion
+//#region ../../packages/core/src/services/todo.service.ts
+var TodoService = class extends Effect.Service()("@ringi/TodoService", {
+	dependencies: [TodoRepo.Default],
+	effect: Effect.sync(() => {
+		const create = Effect.fn("TodoService.create")(function* create(input) {
+			const repo = yield* TodoRepo;
+			const id = randomUUID();
+			return yield* repo.create({
+				content: input.content,
+				id,
+				reviewId: input.reviewId
+			});
+		});
+		const getById = Effect.fn("TodoService.getById")(function* getById(id) {
+			const todo = yield* (yield* TodoRepo).findById(id);
+			if (!todo) return yield* new TodoNotFound({ id });
+			return todo;
+		});
+		const list = Effect.fn("TodoService.list")(function* list(opts = {}) {
+			const result = yield* (yield* TodoRepo).findAll(opts);
+			return {
+				data: result.data,
+				limit: opts.limit ?? null,
+				offset: opts.offset ?? 0,
+				total: result.total
+			};
+		});
+		const update = Effect.fn("TodoService.update")(function* update(id, input) {
+			const repo = yield* TodoRepo;
+			if (!(yield* repo.findById(id))) return yield* new TodoNotFound({ id });
+			const updates = {};
+			if (Option.isSome(input.content)) updates.content = input.content.value;
+			if (Option.isSome(input.completed)) updates.completed = input.completed.value;
+			const todo = yield* repo.update(id, updates);
+			if (!todo) return yield* new TodoNotFound({ id });
+			return todo;
+		});
+		const toggle = Effect.fn("TodoService.toggle")(function* toggle(id) {
+			const todo = yield* (yield* TodoRepo).toggle(id);
+			if (!todo) return yield* new TodoNotFound({ id });
+			return todo;
+		});
+		const remove = Effect.fn("TodoService.remove")(function* remove(id) {
+			const repo = yield* TodoRepo;
+			if (!(yield* repo.findById(id))) return yield* new TodoNotFound({ id });
+			yield* repo.remove(id);
+			return { success: true };
+		});
+		const removeCompleted = Effect.fn("TodoService.removeCompleted")(function* removeCompleted() {
+			return { deleted: yield* (yield* TodoRepo).removeCompleted() };
+		});
+		const reorder = Effect.fn("TodoService.reorder")(function* reorder(orderedIds) {
+			return { updated: yield* (yield* TodoRepo).reorder(orderedIds) };
+		});
+		const move = Effect.fn("TodoService.move")(function* move(id, position) {
+			const todo = yield* (yield* TodoRepo).move(id, position);
+			if (!todo) return yield* new TodoNotFound({ id });
+			return todo;
+		});
+		return {
+			create,
+			getById,
+			getStats: Effect.fn("TodoService.getStats")(function* getStats() {
+				const repo = yield* TodoRepo;
+				const total = yield* repo.countAll();
+				return {
+					completed: yield* repo.countCompleted(),
+					pending: yield* repo.countPending(),
+					total
+				};
+			}),
+			list,
+			move,
+			remove,
+			removeCompleted,
+			reorder,
+			toggle,
+			update
+		};
+	})
+}) {};
+//#endregion
+//#region ../../packages/core/src/services/export.service.ts
+var ExportService = class extends Effect.Service()("@ringi/ExportService", {
+	dependencies: [
+		ReviewService.Default,
+		CommentService.Default,
+		TodoService.Default
+	],
+	effect: Effect.sync(() => {
+		return { exportReview: Effect.fn("ExportService.exportReview")(function* exportReview(reviewId) {
+			const reviewSvc = yield* ReviewService;
+			const commentSvc = yield* CommentService;
+			const todoSvc = yield* TodoService;
+			const review = yield* reviewSvc.getById(reviewId);
+			const repo = review.repository;
+			const repoName = repo?.name ?? "Unknown";
+			const branch = repo?.branch ?? "unknown";
+			const comments = yield* commentSvc.getByReview(reviewId);
+			const commentStats = yield* commentSvc.getStats(reviewId);
+			const todos = yield* todoSvc.list({ reviewId });
+			const lines = [];
+			lines.push(`# Code Review: ${repoName}`);
+			lines.push("");
+			lines.push(`**Status:** ${review.status}`);
+			lines.push(`**Branch:** ${branch}`);
+			lines.push(`**Created:** ${review.createdAt}`);
+			if (review.files && review.files.length > 0) {
+				lines.push("");
+				lines.push("## Files Changed");
+				lines.push("");
+				lines.push("| File | Status | Additions | Deletions |");
+				lines.push("|------|--------|-----------|-----------|");
+				for (const f of review.files) {
+					const statusLabel = f.status === "modified" ? "M" : f.status === "added" ? "A" : f.status === "deleted" ? "D" : f.status;
+					lines.push(`| ${f.filePath} | ${statusLabel} | +${f.additions} | -${f.deletions} |`);
+				}
+			}
+			if (comments.length > 0) {
+				lines.push("");
+				lines.push(`## Comments (${commentStats.total} total, ${commentStats.resolved} resolved)`);
+				const byFile = /* @__PURE__ */ new Map();
+				for (const c of comments) {
+					const key = c.filePath ?? "(general)";
+					const arr = byFile.get(key) ?? [];
+					arr.push(c);
+					byFile.set(key, arr);
+				}
+				for (const [filePath, fileComments] of byFile) {
+					lines.push("");
+					lines.push(`### ${filePath}`);
+					for (const c of fileComments) {
+						lines.push("");
+						lines.push(`**Line ${c.lineNumber ?? "–"}** (${c.lineType ?? "context"})`);
+						lines.push(`> ${c.content}`);
+						if (c.suggestion) {
+							lines.push("");
+							lines.push("```suggestion");
+							lines.push(c.suggestion);
+							lines.push("```");
+						}
+					}
+				}
+			}
+			if (todos.data.length > 0) {
+				const completed = todos.data.filter((t) => t.completed).length;
+				lines.push("");
+				lines.push("---");
+				lines.push("");
+				lines.push(`## Todos (${todos.total} total, ${completed} completed)`);
+				lines.push("");
+				for (const t of todos.data) {
+					const check = t.completed ? "x" : " ";
+					lines.push(`- [${check}] ${t.content}`);
+				}
+			}
+			lines.push("");
+			return lines.join("\n");
+		}) };
+	})
+}) {};
+//#endregion
+//#region ../../node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
+const EntryTypes = {
+	FILE_TYPE: "files",
+	DIR_TYPE: "directories",
+	FILE_DIR_TYPE: "files_directories",
+	EVERYTHING_TYPE: "all"
+};
+const defaultOptions = {
+	root: ".",
+	fileFilter: (_entryInfo) => true,
+	directoryFilter: (_entryInfo) => true,
+	type: EntryTypes.FILE_TYPE,
+	lstat: false,
+	depth: 2147483648,
+	alwaysStat: false,
+	highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+const NORMAL_FLOW_ERRORS = new Set([
+	"ENOENT",
+	"EPERM",
+	"EACCES",
+	"ELOOP",
+	RECURSIVE_ERROR_CODE
+]);
+const ALL_TYPES = [
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+];
+const DIR_TYPES = new Set([
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE
+]);
+const FILE_TYPES = new Set([
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === "win32";
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+	if (filter === void 0) return emptyFn;
+	if (typeof filter === "function") return filter;
+	if (typeof filter === "string") {
+		const fl = filter.trim();
+		return (entry) => entry.basename === fl;
+	}
+	if (Array.isArray(filter)) {
+		const trItems = filter.map((item) => item.trim());
+		return (entry) => trItems.some((f) => entry.basename === f);
+	}
+	return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+var ReaddirpStream = class extends Readable {
+	parents;
+	reading;
+	parent;
+	_stat;
+	_maxDepth;
+	_wantsDir;
+	_wantsFile;
+	_wantsEverything;
+	_root;
+	_isDirent;
+	_statsProp;
+	_rdOptions;
+	_fileFilter;
+	_directoryFilter;
+	constructor(options = {}) {
+		super({
+			objectMode: true,
+			autoDestroy: true,
+			highWaterMark: options.highWaterMark
+		});
+		const opts = {
+			...defaultOptions,
+			...options
+		};
+		const { root, type } = opts;
+		this._fileFilter = normalizeFilter(opts.fileFilter);
+		this._directoryFilter = normalizeFilter(opts.directoryFilter);
+		const statMethod = opts.lstat ? lstat : stat$1;
+		if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
+		else this._stat = statMethod;
+		this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+		this._wantsDir = type ? DIR_TYPES.has(type) : false;
+		this._wantsFile = type ? FILE_TYPES.has(type) : false;
+		this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+		this._root = resolve(root);
+		this._isDirent = !opts.alwaysStat;
+		this._statsProp = this._isDirent ? "dirent" : "stats";
+		this._rdOptions = {
+			encoding: "utf8",
+			withFileTypes: this._isDirent
+		};
+		this.parents = [this._exploreDir(root, 1)];
+		this.reading = false;
+		this.parent = void 0;
+	}
+	async _read(batch) {
+		if (this.reading) return;
+		this.reading = true;
+		try {
+			while (!this.destroyed && batch > 0) {
+				const par = this.parent;
+				const fil = par && par.files;
+				if (fil && fil.length > 0) {
+					const { path, depth } = par;
+					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+					const awaited = await Promise.all(slice);
+					for (const entry of awaited) {
+						if (!entry) continue;
+						if (this.destroyed) return;
+						const entryType = await this._getEntryType(entry);
+						if (entryType === "directory" && this._directoryFilter(entry)) {
+							if (depth <= this._maxDepth) this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+							if (this._wantsDir) {
+								this.push(entry);
+								batch--;
+							}
+						} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+							if (this._wantsFile) {
+								this.push(entry);
+								batch--;
+							}
+						}
+					}
+				} else {
+					const parent = this.parents.pop();
+					if (!parent) {
+						this.push(null);
+						break;
+					}
+					this.parent = await parent;
+					if (this.destroyed) return;
+				}
+			}
+		} catch (error) {
+			this.destroy(error);
+		} finally {
+			this.reading = false;
+		}
+	}
+	async _exploreDir(path, depth) {
+		let files;
+		try {
+			files = await readdir(path, this._rdOptions);
+		} catch (error) {
+			this._onError(error);
+		}
+		return {
+			files,
+			depth,
+			path
+		};
+	}
+	async _formatEntry(dirent, path) {
+		let entry;
+		const basename = this._isDirent ? dirent.name : dirent;
+		try {
+			const fullPath = resolve(join(path, basename));
+			entry = {
+				path: relative(this._root, fullPath),
+				fullPath,
+				basename
+			};
+			entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+		} catch (err) {
+			this._onError(err);
+			return;
+		}
+		return entry;
+	}
+	_onError(err) {
+		if (isNormalFlowError(err) && !this.destroyed) this.emit("warn", err);
+		else this.destroy(err);
+	}
+	async _getEntryType(entry) {
+		if (!entry && this._statsProp in entry) return "";
+		const stats = entry[this._statsProp];
+		if (stats.isFile()) return "file";
+		if (stats.isDirectory()) return "directory";
+		if (stats && stats.isSymbolicLink()) {
+			const full = entry.fullPath;
+			try {
+				const entryRealPath = await realpath(full);
+				const entryRealPathStats = await lstat(entryRealPath);
+				if (entryRealPathStats.isFile()) return "file";
+				if (entryRealPathStats.isDirectory()) {
+					const len = entryRealPath.length;
+					if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
+						const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+						recursiveError.code = RECURSIVE_ERROR_CODE;
+						return this._onError(recursiveError);
+					}
+					return "directory";
+				}
+			} catch (error) {
+				this._onError(error);
+				return "";
+			}
+		}
+	}
+	_includeAsFile(entry) {
+		const stats = entry && entry[this._statsProp];
+		return stats && this._wantsEverything && !stats.isDirectory();
+	}
+};
+/**
+* Streaming version: Reads all files and directories in given root recursively.
+* Consumes ~constant small amount of RAM.
+* @param root Root directory
+* @param options Options to specify root (start directory), filters and recursion depth
+*/
+function readdirp(root, options = {}) {
+	let type = options.entryType || options.type;
+	if (type === "both") type = EntryTypes.FILE_DIR_TYPE;
+	if (type) options.type = type;
+	if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+	else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+	else if (type && !ALL_TYPES.includes(type)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+	options.root = root;
+	return new ReaddirpStream(options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
+const STR_DATA = "data";
+const STR_CLOSE = "close";
+const EMPTY_FN = () => {};
+const pl = process.platform;
+const isWindows = pl === "win32";
+const isMacos = pl === "darwin";
+const isLinux = pl === "linux";
+const isFreeBSD = pl === "freebsd";
+const isIBMi = type() === "OS400";
+const EVENTS = {
+	ALL: "all",
+	READY: "ready",
+	ADD: "add",
+	CHANGE: "change",
+	ADD_DIR: "addDir",
+	UNLINK: "unlink",
+	UNLINK_DIR: "unlinkDir",
+	RAW: "raw",
+	ERROR: "error"
+};
+const EV = EVENTS;
+const THROTTLE_MODE_WATCH = "watch";
+const statMethods = {
+	lstat,
+	stat: stat$1
+};
+const KEY_LISTENERS = "listeners";
+const KEY_ERR = "errHandlers";
+const KEY_RAW = "rawEmitters";
+const HANDLER_KEYS = [
+	KEY_LISTENERS,
+	KEY_ERR,
+	KEY_RAW
+];
+const binaryExtensions = new Set([
+	"3dm",
+	"3ds",
+	"3g2",
+	"3gp",
+	"7z",
+	"a",
+	"aac",
+	"adp",
+	"afdesign",
+	"afphoto",
+	"afpub",
+	"ai",
+	"aif",
+	"aiff",
+	"alz",
+	"ape",
+	"apk",
+	"appimage",
+	"ar",
+	"arj",
+	"asf",
+	"au",
+	"avi",
+	"bak",
+	"baml",
+	"bh",
+	"bin",
+	"bk",
+	"bmp",
+	"btif",
+	"bz2",
+	"bzip2",
+	"cab",
+	"caf",
+	"cgm",
+	"class",
+	"cmx",
+	"cpio",
+	"cr2",
+	"cur",
+	"dat",
+	"dcm",
+	"deb",
+	"dex",
+	"djvu",
+	"dll",
+	"dmg",
+	"dng",
+	"doc",
+	"docm",
+	"docx",
+	"dot",
+	"dotm",
+	"dra",
+	"DS_Store",
+	"dsk",
+	"dts",
+	"dtshd",
+	"dvb",
+	"dwg",
+	"dxf",
+	"ecelp4800",
+	"ecelp7470",
+	"ecelp9600",
+	"egg",
+	"eol",
+	"eot",
+	"epub",
+	"exe",
+	"f4v",
+	"fbs",
+	"fh",
+	"fla",
+	"flac",
+	"flatpak",
+	"fli",
+	"flv",
+	"fpx",
+	"fst",
+	"fvt",
+	"g3",
+	"gh",
+	"gif",
+	"graffle",
+	"gz",
+	"gzip",
+	"h261",
+	"h263",
+	"h264",
+	"icns",
+	"ico",
+	"ief",
+	"img",
+	"ipa",
+	"iso",
+	"jar",
+	"jpeg",
+	"jpg",
+	"jpgv",
+	"jpm",
+	"jxr",
+	"key",
+	"ktx",
+	"lha",
+	"lib",
+	"lvp",
+	"lz",
+	"lzh",
+	"lzma",
+	"lzo",
+	"m3u",
+	"m4a",
+	"m4v",
+	"mar",
+	"mdi",
+	"mht",
+	"mid",
+	"midi",
+	"mj2",
+	"mka",
+	"mkv",
+	"mmr",
+	"mng",
+	"mobi",
+	"mov",
+	"movie",
+	"mp3",
+	"mp4",
+	"mp4a",
+	"mpeg",
+	"mpg",
+	"mpga",
+	"mxu",
+	"nef",
+	"npx",
+	"numbers",
+	"nupkg",
+	"o",
+	"odp",
+	"ods",
+	"odt",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"ott",
+	"pages",
+	"pbm",
+	"pcx",
+	"pdb",
+	"pdf",
+	"pea",
+	"pgm",
+	"pic",
+	"png",
+	"pnm",
+	"pot",
+	"potm",
+	"potx",
+	"ppa",
+	"ppam",
+	"ppm",
+	"pps",
+	"ppsm",
+	"ppsx",
+	"ppt",
+	"pptm",
+	"pptx",
+	"psd",
+	"pya",
+	"pyc",
+	"pyo",
+	"pyv",
+	"qt",
+	"rar",
+	"ras",
+	"raw",
+	"resources",
+	"rgb",
+	"rip",
+	"rlc",
+	"rmf",
+	"rmvb",
+	"rpm",
+	"rtf",
+	"rz",
+	"s3m",
+	"s7z",
+	"scpt",
+	"sgi",
+	"shar",
+	"snap",
+	"sil",
+	"sketch",
+	"slk",
+	"smv",
+	"snk",
+	"so",
+	"stl",
+	"suo",
+	"sub",
+	"swf",
+	"tar",
+	"tbz",
+	"tbz2",
+	"tga",
+	"tgz",
+	"thmx",
+	"tif",
+	"tiff",
+	"tlz",
+	"ttc",
+	"ttf",
+	"txz",
+	"udf",
+	"uvh",
+	"uvi",
+	"uvm",
+	"uvp",
+	"uvs",
+	"uvu",
+	"viv",
+	"vob",
+	"war",
+	"wav",
+	"wax",
+	"wbmp",
+	"wdp",
+	"weba",
+	"webm",
+	"webp",
+	"whl",
+	"wim",
+	"wm",
+	"wma",
+	"wmv",
+	"wmx",
+	"woff",
+	"woff2",
+	"wrm",
+	"wvx",
+	"xbm",
+	"xif",
+	"xla",
+	"xlam",
+	"xls",
+	"xlsb",
+	"xlsm",
+	"xlsx",
+	"xlt",
+	"xltm",
+	"xltx",
+	"xm",
+	"xmind",
+	"xpi",
+	"xpm",
+	"xwd",
+	"xz",
+	"z",
+	"zip",
+	"zipx"
+]);
+const isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+const foreach = (val, fn) => {
+	if (val instanceof Set) val.forEach(fn);
+	else fn(val);
+};
+const addAndConvert = (main, prop, item) => {
+	let container = main[prop];
+	if (!(container instanceof Set)) main[prop] = container = new Set([container]);
+	container.add(item);
+};
+const clearItem = (cont) => (key) => {
+	const set = cont[key];
+	if (set instanceof Set) set.clear();
+	else delete cont[key];
+};
+const delFromSet = (main, prop, item) => {
+	const container = main[prop];
+	if (container instanceof Set) container.delete(item);
+	else if (container === item) delete main[prop];
+};
+const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+const FsWatchInstances = /* @__PURE__ */ new Map();
+/**
+* Instantiates the fs_watch interface
+* @param path to be watched
+* @param options to be passed to fs_watch
+* @param listener main event handler
+* @param errHandler emits info about errors
+* @param emitRaw emits raw event data
+* @returns {NativeFsWatcher}
+*/
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+	const handleEvent = (rawEvent, evPath) => {
+		listener(path);
+		emitRaw(rawEvent, evPath, { watchedPath: path });
+		if (evPath && path !== evPath) fsWatchBroadcast(sp.resolve(path, evPath), KEY_LISTENERS, sp.join(path, evPath));
+	};
+	try {
+		return watch(path, { persistent: options.persistent }, handleEvent);
+	} catch (error) {
+		errHandler(error);
+		return;
+	}
+}
+/**
+* Helper for passing fs_watch event data to a collection of listeners
+* @param fullPath absolute path bound to fs_watch instance
+*/
+const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+	const cont = FsWatchInstances.get(fullPath);
+	if (!cont) return;
+	foreach(cont[listenerType], (listener) => {
+		listener(val1, val2, val3);
+	});
+};
+/**
+* Instantiates the fs_watch interface or binds listeners
+* to an existing one covering the same file system entry
+* @param path
+* @param fullPath absolute path
+* @param options to be passed to fs_watch
+* @param handlers container for event listener functions
+*/
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+	const { listener, errHandler, rawEmitter } = handlers;
+	let cont = FsWatchInstances.get(fullPath);
+	let watcher;
+	if (!options.persistent) {
+		watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+		if (!watcher) return;
+		return watcher.close.bind(watcher);
+	}
+	if (cont) {
+		addAndConvert(cont, KEY_LISTENERS, listener);
+		addAndConvert(cont, KEY_ERR, errHandler);
+		addAndConvert(cont, KEY_RAW, rawEmitter);
+	} else {
+		watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+		if (!watcher) return;
+		watcher.on(EV.ERROR, async (error) => {
+			const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+			if (cont) cont.watcherUnusable = true;
+			if (isWindows && error.code === "EPERM") try {
+				await (await open(path, "r")).close();
+				broadcastErr(error);
+			} catch (err) {}
+			else broadcastErr(error);
+		});
+		cont = {
+			listeners: listener,
+			errHandlers: errHandler,
+			rawEmitters: rawEmitter,
+			watcher
+		};
+		FsWatchInstances.set(fullPath, cont);
+	}
+	return () => {
+		delFromSet(cont, KEY_LISTENERS, listener);
+		delFromSet(cont, KEY_ERR, errHandler);
+		delFromSet(cont, KEY_RAW, rawEmitter);
+		if (isEmptySet(cont.listeners)) {
+			cont.watcher.close();
+			FsWatchInstances.delete(fullPath);
+			HANDLER_KEYS.forEach(clearItem(cont));
+			cont.watcher = void 0;
+			Object.freeze(cont);
+		}
+	};
+};
+const FsWatchFileInstances = /* @__PURE__ */ new Map();
+/**
+* Instantiates the fs_watchFile interface or binds listeners
+* to an existing one covering the same file system entry
+* @param path to be watched
+* @param fullPath absolute path
+* @param options options to be passed to fs_watchFile
+* @param handlers container for event listener functions
+* @returns closer
+*/
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+	const { listener, rawEmitter } = handlers;
+	let cont = FsWatchFileInstances.get(fullPath);
+	const copts = cont && cont.options;
+	if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+		unwatchFile(fullPath);
+		cont = void 0;
+	}
+	if (cont) {
+		addAndConvert(cont, KEY_LISTENERS, listener);
+		addAndConvert(cont, KEY_RAW, rawEmitter);
+	} else {
+		cont = {
+			listeners: listener,
+			rawEmitters: rawEmitter,
+			options,
+			watcher: watchFile(fullPath, options, (curr, prev) => {
+				foreach(cont.rawEmitters, (rawEmitter) => {
+					rawEmitter(EV.CHANGE, fullPath, {
+						curr,
+						prev
+					});
+				});
+				const currmtime = curr.mtimeMs;
+				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener) => listener(path, curr));
+			})
+		};
+		FsWatchFileInstances.set(fullPath, cont);
+	}
+	return () => {
+		delFromSet(cont, KEY_LISTENERS, listener);
+		delFromSet(cont, KEY_RAW, rawEmitter);
+		if (isEmptySet(cont.listeners)) {
+			FsWatchFileInstances.delete(fullPath);
+			unwatchFile(fullPath);
+			cont.options = cont.watcher = void 0;
+			Object.freeze(cont);
+		}
+	};
+};
+/**
+* @mixin
+*/
+var NodeFsHandler = class {
+	fsw;
+	_boundHandleError;
+	constructor(fsW) {
+		this.fsw = fsW;
+		this._boundHandleError = (error) => fsW._handleError(error);
+	}
+	/**
+	* Watch file for changes with fs_watchFile or fs_watch.
+	* @param path to file or dir
+	* @param listener on fs change
+	* @returns closer for the watcher instance
+	*/
+	_watchWithNodeFs(path, listener) {
+		const opts = this.fsw.options;
+		const directory = sp.dirname(path);
+		const basename = sp.basename(path);
+		this.fsw._getWatchedDir(directory).add(basename);
+		const absolutePath = sp.resolve(path);
+		const options = { persistent: opts.persistent };
+		if (!listener) listener = EMPTY_FN;
+		let closer;
+		if (opts.usePolling) {
+			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+			closer = setFsWatchFileListener(path, absolutePath, options, {
+				listener,
+				rawEmitter: this.fsw._emitRaw
+			});
+		} else closer = setFsWatchListener(path, absolutePath, options, {
+			listener,
+			errHandler: this._boundHandleError,
+			rawEmitter: this.fsw._emitRaw
+		});
+		return closer;
+	}
+	/**
+	* Watch a file and emit add event if warranted.
+	* @returns closer for the watcher instance
+	*/
+	_handleFile(file, stats, initialAdd) {
+		if (this.fsw.closed) return;
+		const dirname = sp.dirname(file);
+		const basename = sp.basename(file);
+		const parent = this.fsw._getWatchedDir(dirname);
+		let prevStats = stats;
+		if (parent.has(basename)) return;
+		const listener = async (path, newStats) => {
+			if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+			if (!newStats || newStats.mtimeMs === 0) try {
+				const newStats = await stat$1(file);
+				if (this.fsw.closed) return;
+				const at = newStats.atimeMs;
+				const mt = newStats.mtimeMs;
+				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
+				if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) {
+					this.fsw._closeFile(path);
+					prevStats = newStats;
+					const closer = this._watchWithNodeFs(file, listener);
+					if (closer) this.fsw._addPathCloser(path, closer);
+				} else prevStats = newStats;
+			} catch (error) {
+				this.fsw._remove(dirname, basename);
+			}
+			else if (parent.has(basename)) {
+				const at = newStats.atimeMs;
+				const mt = newStats.mtimeMs;
+				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
+				prevStats = newStats;
+			}
+		};
+		const closer = this._watchWithNodeFs(file, listener);
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+			if (!this.fsw._throttle(EV.ADD, file, 0)) return;
+			this.fsw._emit(EV.ADD, file, stats);
+		}
+		return closer;
+	}
+	/**
+	* Handle symlinks encountered while reading a dir.
+	* @param entry returned by readdirp
+	* @param directory path of dir being read
+	* @param path of this item
+	* @param item basename of this item
+	* @returns true if no more processing is needed for this entry.
+	*/
+	async _handleSymlink(entry, directory, path, item) {
+		if (this.fsw.closed) return;
+		const full = entry.fullPath;
+		const dir = this.fsw._getWatchedDir(directory);
+		if (!this.fsw.options.followSymlinks) {
+			this.fsw._incrReadyCount();
+			let linkPath;
+			try {
+				linkPath = await realpath(path);
+			} catch (e) {
+				this.fsw._emitReady();
+				return true;
+			}
+			if (this.fsw.closed) return;
+			if (dir.has(item)) {
+				if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+					this.fsw._symlinkPaths.set(full, linkPath);
+					this.fsw._emit(EV.CHANGE, path, entry.stats);
+				}
+			} else {
+				dir.add(item);
+				this.fsw._symlinkPaths.set(full, linkPath);
+				this.fsw._emit(EV.ADD, path, entry.stats);
+			}
+			this.fsw._emitReady();
+			return true;
+		}
+		if (this.fsw._symlinkPaths.has(full)) return true;
+		this.fsw._symlinkPaths.set(full, true);
+	}
+	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+		directory = sp.join(directory, "");
+		const throttleKey = target ? `${directory}:${target}` : directory;
+		throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
+		if (!throttler) return;
+		const previous = this.fsw._getWatchedDir(wh.path);
+		const current = /* @__PURE__ */ new Set();
+		let stream = this.fsw._readdirp(directory, {
+			fileFilter: (entry) => wh.filterPath(entry),
+			directoryFilter: (entry) => wh.filterDir(entry)
+		});
+		if (!stream) return;
+		stream.on(STR_DATA, async (entry) => {
+			if (this.fsw.closed) {
+				stream = void 0;
+				return;
+			}
+			const item = entry.path;
+			let path = sp.join(directory, item);
+			current.add(item);
+			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) return;
+			if (this.fsw.closed) {
+				stream = void 0;
+				return;
+			}
+			if (item === target || !target && !previous.has(item)) {
+				this.fsw._incrReadyCount();
+				path = sp.join(dir, sp.relative(dir, path));
+				this._addToNodeFs(path, initialAdd, wh, depth + 1);
+			}
+		}).on(EV.ERROR, this._boundHandleError);
+		return new Promise((resolve, reject) => {
+			if (!stream) return reject();
+			stream.once("end", () => {
+				if (this.fsw.closed) {
+					stream = void 0;
+					return;
+				}
+				const wasThrottled = throttler ? throttler.clear() : false;
+				resolve(void 0);
+				previous.getChildren().filter((item) => {
+					return item !== directory && !current.has(item);
+				}).forEach((item) => {
+					this.fsw._remove(directory, item);
+				});
+				stream = void 0;
+				if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+			});
+		});
+	}
+	/**
+	* Read directory to add / remove files from `@watched` list and re-read it on change.
+	* @param dir fs path
+	* @param stats
+	* @param initialAdd
+	* @param depth relative to user-supplied path
+	* @param target child path targeted for watch
+	* @param wh Common watch helpers for this path
+	* @param realpath
+	* @returns closer for the watcher instance.
+	*/
+	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+		const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+		const tracked = parentDir.has(sp.basename(dir));
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV.ADD_DIR, dir, stats);
+		parentDir.add(sp.basename(dir));
+		this.fsw._getWatchedDir(dir);
+		let throttler;
+		let closer;
+		const oDepth = this.fsw.options.depth;
+		if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+			if (!target) {
+				await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+				if (this.fsw.closed) return;
+			}
+			closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+				if (stats && stats.mtimeMs === 0) return;
+				this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+			});
+		}
+		return closer;
+	}
+	/**
+	* Handle added file, directory, or glob pattern.
+	* Delegates call to _handleFile / _handleDir after checks.
+	* @param path to file or ir
+	* @param initialAdd was the file added at watch instantiation?
+	* @param priorWh depth relative to user-supplied path
+	* @param depth Child path actually targeted for watch
+	* @param target Child path actually targeted for watch
+	*/
+	async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+		const ready = this.fsw._emitReady;
+		if (this.fsw._isIgnored(path) || this.fsw.closed) {
+			ready();
+			return false;
+		}
+		const wh = this.fsw._getWatchHelpers(path);
+		if (priorWh) {
+			wh.filterPath = (entry) => priorWh.filterPath(entry);
+			wh.filterDir = (entry) => priorWh.filterDir(entry);
+		}
+		try {
+			const stats = await statMethods[wh.statMethod](wh.watchPath);
+			if (this.fsw.closed) return;
+			if (this.fsw._isIgnored(wh.watchPath, stats)) {
+				ready();
+				return false;
+			}
+			const follow = this.fsw.options.followSymlinks;
+			let closer;
+			if (stats.isDirectory()) {
+				const absPath = sp.resolve(path);
+				const targetPath = follow ? await realpath(path) : path;
+				if (this.fsw.closed) return;
+				closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+				if (this.fsw.closed) return;
+				if (absPath !== targetPath && targetPath !== void 0) this.fsw._symlinkPaths.set(absPath, targetPath);
+			} else if (stats.isSymbolicLink()) {
+				const targetPath = follow ? await realpath(path) : path;
+				if (this.fsw.closed) return;
+				const parent = sp.dirname(wh.watchPath);
+				this.fsw._getWatchedDir(parent).add(wh.watchPath);
+				this.fsw._emit(EV.ADD, wh.watchPath, stats);
+				closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+				if (this.fsw.closed) return;
+				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sp.resolve(path), targetPath);
+			} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
+			ready();
+			if (closer) this.fsw._addPathCloser(path, closer);
+			return false;
+		} catch (error) {
+			if (this.fsw._handleError(error)) {
+				ready();
+				return path;
+			}
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+const SLASH = "/";
+const SLASH_SLASH = "//";
+const ONE_DOT = ".";
+const TWO_DOTS = "..";
+const STRING_TYPE = "string";
+const BACK_SLASH_RE = /\\/g;
+const DOUBLE_SLASH_RE = /\/\//g;
+const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+	return Array.isArray(item) ? item : [item];
+}
+const isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+	if (typeof matcher === "function") return matcher;
+	if (typeof matcher === "string") return (string) => matcher === string;
+	if (matcher instanceof RegExp) return (string) => matcher.test(string);
+	if (typeof matcher === "object" && matcher !== null) return (string) => {
+		if (matcher.path === string) return true;
+		if (matcher.recursive) {
+			const relative = sp.relative(matcher.path, string);
+			if (!relative) return false;
+			return !relative.startsWith("..") && !sp.isAbsolute(relative);
+		}
+		return false;
+	};
+	return () => false;
+}
+function normalizePath(path) {
+	if (typeof path !== "string") throw new Error("string expected");
+	path = sp.normalize(path);
+	path = path.replace(/\\/g, "/");
+	let prepend = false;
+	if (path.startsWith("//")) prepend = true;
+	path = path.replace(DOUBLE_SLASH_RE, "/");
+	if (prepend) path = "/" + path;
+	return path;
+}
+function matchPatterns(patterns, testString, stats) {
+	const path = normalizePath(testString);
+	for (let index = 0; index < patterns.length; index++) {
+		const pattern = patterns[index];
+		if (pattern(path, stats)) return true;
+	}
+	return false;
+}
+function anymatch(matchers, testString) {
+	if (matchers == null) throw new TypeError("anymatch: specify first argument");
+	const patterns = arrify(matchers).map((matcher) => createPattern(matcher));
+	if (testString == null) return (testString, stats) => {
+		return matchPatterns(patterns, testString, stats);
+	};
+	return matchPatterns(patterns, testString);
+}
+const unifyPaths = (paths_) => {
+	const paths = arrify(paths_).flat();
+	if (!paths.every((p) => typeof p === STRING_TYPE)) throw new TypeError(`Non-string provided as watch path: ${paths}`);
+	return paths.map(normalizePathToUnix);
+};
+const toUnix = (string) => {
+	let str = string.replace(BACK_SLASH_RE, SLASH);
+	let prepend = false;
+	if (str.startsWith(SLASH_SLASH)) prepend = true;
+	str = str.replace(DOUBLE_SLASH_RE, SLASH);
+	if (prepend) str = SLASH + str;
+	return str;
+};
+const normalizePathToUnix = (path) => toUnix(sp.normalize(toUnix(path)));
+const normalizeIgnored = (cwd = "") => (path) => {
+	if (typeof path === "string") return normalizePathToUnix(sp.isAbsolute(path) ? path : sp.join(cwd, path));
+	else return path;
+};
+const getAbsolutePath = (path, cwd) => {
+	if (sp.isAbsolute(path)) return path;
+	return sp.join(cwd, path);
+};
+const EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+/**
+* Directory entry.
+*/
+var DirEntry = class {
+	path;
+	_removeWatcher;
+	items;
+	constructor(dir, removeWatcher) {
+		this.path = dir;
+		this._removeWatcher = removeWatcher;
+		this.items = /* @__PURE__ */ new Set();
+	}
+	add(item) {
+		const { items } = this;
+		if (!items) return;
+		if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+	}
+	async remove(item) {
+		const { items } = this;
+		if (!items) return;
+		items.delete(item);
+		if (items.size > 0) return;
+		const dir = this.path;
+		try {
+			await readdir(dir);
+		} catch (err) {
+			if (this._removeWatcher) this._removeWatcher(sp.dirname(dir), sp.basename(dir));
+		}
+	}
+	has(item) {
+		const { items } = this;
+		if (!items) return;
+		return items.has(item);
+	}
+	getChildren() {
+		const { items } = this;
+		if (!items) return [];
+		return [...items.values()];
+	}
+	dispose() {
+		this.items.clear();
+		this.path = "";
+		this._removeWatcher = EMPTY_FN;
+		this.items = EMPTY_SET;
+		Object.freeze(this);
+	}
+};
+const STAT_METHOD_F = "stat";
+const STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+	fsw;
+	path;
+	watchPath;
+	fullWatchPath;
+	dirParts;
+	followSymlinks;
+	statMethod;
+	constructor(path, follow, fsw) {
+		this.fsw = fsw;
+		const watchPath = path;
+		this.path = path = path.replace(REPLACER_RE, "");
+		this.watchPath = watchPath;
+		this.fullWatchPath = sp.resolve(watchPath);
+		this.dirParts = [];
+		this.dirParts.forEach((parts) => {
+			if (parts.length > 1) parts.pop();
+		});
+		this.followSymlinks = follow;
+		this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+	}
+	entryPath(entry) {
+		return sp.join(this.watchPath, sp.relative(this.watchPath, entry.fullPath));
+	}
+	filterPath(entry) {
+		const { stats } = entry;
+		if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+		const resolvedPath = this.entryPath(entry);
+		return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+	}
+	filterDir(entry) {
+		return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+	}
+};
+/**
+* Watches files & directories for changes. Emitted events:
+* `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+*
+*     new FSWatcher()
+*       .add(directories)
+*       .on('add', path => log('File', path, 'was added'))
+*/
+var FSWatcher = class extends EventEmitter {
+	closed;
+	options;
+	_closers;
+	_ignoredPaths;
+	_throttled;
+	_streams;
+	_symlinkPaths;
+	_watched;
+	_pendingWrites;
+	_pendingUnlinks;
+	_readyCount;
+	_emitReady;
+	_closePromise;
+	_userIgnored;
+	_readyEmitted;
+	_emitRaw;
+	_boundRemove;
+	_nodeFsHandler;
+	constructor(_opts = {}) {
+		super();
+		this.closed = false;
+		this._closers = /* @__PURE__ */ new Map();
+		this._ignoredPaths = /* @__PURE__ */ new Set();
+		this._throttled = /* @__PURE__ */ new Map();
+		this._streams = /* @__PURE__ */ new Set();
+		this._symlinkPaths = /* @__PURE__ */ new Map();
+		this._watched = /* @__PURE__ */ new Map();
+		this._pendingWrites = /* @__PURE__ */ new Map();
+		this._pendingUnlinks = /* @__PURE__ */ new Map();
+		this._readyCount = 0;
+		this._readyEmitted = false;
+		const awf = _opts.awaitWriteFinish;
+		const DEF_AWF = {
+			stabilityThreshold: 2e3,
+			pollInterval: 100
+		};
+		const opts = {
+			persistent: true,
+			ignoreInitial: false,
+			ignorePermissionErrors: false,
+			interval: 100,
+			binaryInterval: 300,
+			followSymlinks: true,
+			usePolling: false,
+			atomic: true,
+			..._opts,
+			ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+			awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? {
+				...DEF_AWF,
+				...awf
+			} : false
+		};
+		if (isIBMi) opts.usePolling = true;
+		if (opts.atomic === void 0) opts.atomic = !opts.usePolling;
+		const envPoll = process.env.CHOKIDAR_USEPOLLING;
+		if (envPoll !== void 0) {
+			const envLower = envPoll.toLowerCase();
+			if (envLower === "false" || envLower === "0") opts.usePolling = false;
+			else if (envLower === "true" || envLower === "1") opts.usePolling = true;
+			else opts.usePolling = !!envLower;
+		}
+		const envInterval = process.env.CHOKIDAR_INTERVAL;
+		if (envInterval) opts.interval = Number.parseInt(envInterval, 10);
+		let readyCalls = 0;
+		this._emitReady = () => {
+			readyCalls++;
+			if (readyCalls >= this._readyCount) {
+				this._emitReady = EMPTY_FN;
+				this._readyEmitted = true;
+				process.nextTick(() => this.emit(EVENTS.READY));
+			}
+		};
+		this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+		this._boundRemove = this._remove.bind(this);
+		this.options = opts;
+		this._nodeFsHandler = new NodeFsHandler(this);
+		Object.freeze(opts);
+	}
+	_addIgnoredPath(matcher) {
+		if (isMatcherObject(matcher)) {
+			for (const ignored of this._ignoredPaths) if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) return;
+		}
+		this._ignoredPaths.add(matcher);
+	}
+	_removeIgnoredPath(matcher) {
+		this._ignoredPaths.delete(matcher);
+		if (typeof matcher === "string") {
+			for (const ignored of this._ignoredPaths) if (isMatcherObject(ignored) && ignored.path === matcher) this._ignoredPaths.delete(ignored);
+		}
+	}
+	/**
+	* Adds paths to be watched on an existing FSWatcher instance.
+	* @param paths_ file or file list. Other arguments are unused
+	*/
+	add(paths_, _origAdd, _internal) {
+		const { cwd } = this.options;
+		this.closed = false;
+		this._closePromise = void 0;
+		let paths = unifyPaths(paths_);
+		if (cwd) paths = paths.map((path) => {
+			return getAbsolutePath(path, cwd);
+		});
+		paths.forEach((path) => {
+			this._removeIgnoredPath(path);
+		});
+		this._userIgnored = void 0;
+		if (!this._readyCount) this._readyCount = 0;
+		this._readyCount += paths.length;
+		Promise.all(paths.map(async (path) => {
+			const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
+			if (res) this._emitReady();
+			return res;
+		})).then((results) => {
+			if (this.closed) return;
+			results.forEach((item) => {
+				if (item) this.add(sp.dirname(item), sp.basename(_origAdd || item));
+			});
+		});
+		return this;
+	}
+	/**
+	* Close watchers or start ignoring events from specified paths.
+	*/
+	unwatch(paths_) {
+		if (this.closed) return this;
+		const paths = unifyPaths(paths_);
+		const { cwd } = this.options;
+		paths.forEach((path) => {
+			if (!sp.isAbsolute(path) && !this._closers.has(path)) {
+				if (cwd) path = sp.join(cwd, path);
+				path = sp.resolve(path);
+			}
+			this._closePath(path);
+			this._addIgnoredPath(path);
+			if (this._watched.has(path)) this._addIgnoredPath({
+				path,
+				recursive: true
+			});
+			this._userIgnored = void 0;
+		});
+		return this;
+	}
+	/**
+	* Close watchers and remove all listeners from watched paths.
+	*/
+	close() {
+		if (this._closePromise) return this._closePromise;
+		this.closed = true;
+		this.removeAllListeners();
+		const closers = [];
+		this._closers.forEach((closerList) => closerList.forEach((closer) => {
+			const promise = closer();
+			if (promise instanceof Promise) closers.push(promise);
+		}));
+		this._streams.forEach((stream) => stream.destroy());
+		this._userIgnored = void 0;
+		this._readyCount = 0;
+		this._readyEmitted = false;
+		this._watched.forEach((dirent) => dirent.dispose());
+		this._closers.clear();
+		this._watched.clear();
+		this._streams.clear();
+		this._symlinkPaths.clear();
+		this._throttled.clear();
+		this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+		return this._closePromise;
+	}
+	/**
+	* Expose list of watched paths
+	* @returns for chaining
+	*/
+	getWatched() {
+		const watchList = {};
+		this._watched.forEach((entry, dir) => {
+			const index = (this.options.cwd ? sp.relative(this.options.cwd, dir) : dir) || ONE_DOT;
+			watchList[index] = entry.getChildren().sort();
+		});
+		return watchList;
+	}
+	emitWithAll(event, args) {
+		this.emit(event, ...args);
+		if (event !== EVENTS.ERROR) this.emit(EVENTS.ALL, event, ...args);
+	}
+	/**
+	* Normalize and emit events.
+	* Calling _emit DOES NOT MEAN emit() would be called!
+	* @param event Type of event
+	* @param path File or directory path
+	* @param stats arguments to be passed with event
+	* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	*/
+	async _emit(event, path, stats) {
+		if (this.closed) return;
+		const opts = this.options;
+		if (isWindows) path = sp.normalize(path);
+		if (opts.cwd) path = sp.relative(opts.cwd, path);
+		const args = [path];
+		if (stats != null) args.push(stats);
+		const awf = opts.awaitWriteFinish;
+		let pw;
+		if (awf && (pw = this._pendingWrites.get(path))) {
+			pw.lastChange = /* @__PURE__ */ new Date();
+			return this;
+		}
+		if (opts.atomic) {
+			if (event === EVENTS.UNLINK) {
+				this._pendingUnlinks.set(path, [event, ...args]);
+				setTimeout(() => {
+					this._pendingUnlinks.forEach((entry, path) => {
+						this.emit(...entry);
+						this.emit(EVENTS.ALL, ...entry);
+						this._pendingUnlinks.delete(path);
+					});
+				}, typeof opts.atomic === "number" ? opts.atomic : 100);
+				return this;
+			}
+			if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+				event = EVENTS.CHANGE;
+				this._pendingUnlinks.delete(path);
+			}
+		}
+		if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+			const awfEmit = (err, stats) => {
+				if (err) {
+					event = EVENTS.ERROR;
+					args[0] = err;
+					this.emitWithAll(event, args);
+				} else if (stats) {
+					if (args.length > 1) args[1] = stats;
+					else args.push(stats);
+					this.emitWithAll(event, args);
+				}
+			};
+			this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+			return this;
+		}
+		if (event === EVENTS.CHANGE) {
+			if (!this._throttle(EVENTS.CHANGE, path, 50)) return this;
+		}
+		if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+			const fullPath = opts.cwd ? sp.join(opts.cwd, path) : path;
+			let stats;
+			try {
+				stats = await stat$1(fullPath);
+			} catch (err) {}
+			if (!stats || this.closed) return;
+			args.push(stats);
+		}
+		this.emitWithAll(event, args);
+		return this;
+	}
+	/**
+	* Common handler for errors
+	* @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	*/
+	_handleError(error) {
+		const code = error && error.code;
+		if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) this.emit(EVENTS.ERROR, error);
+		return error || this.closed;
+	}
+	/**
+	* Helper utility for throttling
+	* @param actionType type being throttled
+	* @param path being acted upon
+	* @param timeout duration of time to suppress duplicate actions
+	* @returns tracking object or false if action should be suppressed
+	*/
+	_throttle(actionType, path, timeout) {
+		if (!this._throttled.has(actionType)) this._throttled.set(actionType, /* @__PURE__ */ new Map());
+		const action = this._throttled.get(actionType);
+		if (!action) throw new Error("invalid throttle");
+		const actionPath = action.get(path);
+		if (actionPath) {
+			actionPath.count++;
+			return false;
+		}
+		let timeoutObject;
+		const clear = () => {
+			const item = action.get(path);
+			const count = item ? item.count : 0;
+			action.delete(path);
+			clearTimeout(timeoutObject);
+			if (item) clearTimeout(item.timeoutObject);
+			return count;
+		};
+		timeoutObject = setTimeout(clear, timeout);
+		const thr = {
+			timeoutObject,
+			clear,
+			count: 0
+		};
+		action.set(path, thr);
+		return thr;
+	}
+	_incrReadyCount() {
+		return this._readyCount++;
+	}
+	/**
+	* Awaits write operation to finish.
+	* Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+	* @param path being acted upon
+	* @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+	* @param event
+	* @param awfEmit Callback to be called when ready for event to be emitted.
+	*/
+	_awaitWriteFinish(path, threshold, event, awfEmit) {
+		const awf = this.options.awaitWriteFinish;
+		if (typeof awf !== "object") return;
+		const pollInterval = awf.pollInterval;
+		let timeoutHandler;
+		let fullPath = path;
+		if (this.options.cwd && !sp.isAbsolute(path)) fullPath = sp.join(this.options.cwd, path);
+		const now = /* @__PURE__ */ new Date();
+		const writes = this._pendingWrites;
+		function awaitWriteFinishFn(prevStat) {
+			stat(fullPath, (err, curStat) => {
+				if (err || !writes.has(path)) {
+					if (err && err.code !== "ENOENT") awfEmit(err);
+					return;
+				}
+				const now = Number(/* @__PURE__ */ new Date());
+				if (prevStat && curStat.size !== prevStat.size) writes.get(path).lastChange = now;
+				if (now - writes.get(path).lastChange >= threshold) {
+					writes.delete(path);
+					awfEmit(void 0, curStat);
+				} else timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+			});
+		}
+		if (!writes.has(path)) {
+			writes.set(path, {
+				lastChange: now,
+				cancelWait: () => {
+					writes.delete(path);
+					clearTimeout(timeoutHandler);
+					return event;
+				}
+			});
+			timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+		}
+	}
+	/**
+	* Determines whether user has asked to ignore this path.
+	*/
+	_isIgnored(path, stats) {
+		if (this.options.atomic && DOT_RE.test(path)) return true;
+		if (!this._userIgnored) {
+			const { cwd } = this.options;
+			const ignored = (this.options.ignored || []).map(normalizeIgnored(cwd));
+			this._userIgnored = anymatch([...[...this._ignoredPaths].map(normalizeIgnored(cwd)), ...ignored], void 0);
+		}
+		return this._userIgnored(path, stats);
+	}
+	_isntIgnored(path, stat) {
+		return !this._isIgnored(path, stat);
+	}
+	/**
+	* Provides a set of common helpers and properties relating to symlink handling.
+	* @param path file or directory pattern being watched
+	*/
+	_getWatchHelpers(path) {
+		return new WatchHelper(path, this.options.followSymlinks, this);
+	}
+	/**
+	* Provides directory tracking objects
+	* @param directory path of the directory
+	*/
+	_getWatchedDir(directory) {
+		const dir = sp.resolve(directory);
+		if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+		return this._watched.get(dir);
+	}
+	/**
+	* Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+	*/
+	_hasReadPermissions(stats) {
+		if (this.options.ignorePermissionErrors) return true;
+		return Boolean(Number(stats.mode) & 256);
+	}
+	/**
+	* Handles emitting unlink events for
+	* files and directories, and via recursion, for
+	* files and directories within directories that are unlinked
+	* @param directory within which the following item is located
+	* @param item      base path of item/directory
+	*/
+	_remove(directory, item, isDirectory) {
+		const path = sp.join(directory, item);
+		const fullPath = sp.resolve(path);
+		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+		if (!this._throttle("remove", path, 100)) return;
+		if (!isDirectory && this._watched.size === 1) this.add(directory, item, true);
+		this._getWatchedDir(path).getChildren().forEach((nested) => this._remove(path, nested));
+		const parent = this._getWatchedDir(directory);
+		const wasTracked = parent.has(item);
+		parent.remove(item);
+		if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
+		let relPath = path;
+		if (this.options.cwd) relPath = sp.relative(this.options.cwd, path);
+		if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+			if (this._pendingWrites.get(relPath).cancelWait() === EVENTS.ADD) return;
+		}
+		this._watched.delete(path);
+		this._watched.delete(fullPath);
+		const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+		if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+		this._closePath(path);
+	}
+	/**
+	* Closes all watchers for a path
+	*/
+	_closePath(path) {
+		this._closeFile(path);
+		const dir = sp.dirname(path);
+		this._getWatchedDir(dir).remove(sp.basename(path));
+	}
+	/**
+	* Closes only file-specific watchers
+	*/
+	_closeFile(path) {
+		const closers = this._closers.get(path);
+		if (!closers) return;
+		closers.forEach((closer) => closer());
+		this._closers.delete(path);
+	}
+	_addPathCloser(path, closer) {
+		if (!closer) return;
+		let list = this._closers.get(path);
+		if (!list) {
+			list = [];
+			this._closers.set(path, list);
+		}
+		list.push(closer);
+	}
+	_readdirp(root, opts) {
+		if (this.closed) return;
+		let stream = readdirp(root, {
+			type: EVENTS.ALL,
+			alwaysStat: true,
+			lstat: true,
+			...opts,
+			depth: 0
+		});
+		this._streams.add(stream);
+		stream.once(STR_CLOSE, () => {
+			stream = void 0;
+		});
+		stream.once("end", () => {
+			if (stream) {
+				this._streams.delete(stream);
+				stream = void 0;
+			}
+		});
+		return stream;
+	}
+};
+/**
+* Instantiates watcher with paths to be tracked.
+* @param paths file / directory paths
+* @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+* @returns an instance of FSWatcher for chaining.
+* @example
+* const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+* watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+*/
+function watch$1(paths, options = {}) {
+	const watcher = new FSWatcher(options);
+	watcher.add(paths);
+	return watcher;
+}
+var chokidar_default = {
+	watch: watch$1,
+	FSWatcher
+};
+//#endregion
+//#region ../../packages/core/src/services/event.service.ts
+var EventService = class extends Effect.Service()("@ringi/EventService", { effect: Effect.gen(function* effect() {
+	const rt = yield* Effect.runtime();
+	const runFork = Runtime.runFork(rt);
+	const subscribers = /* @__PURE__ */ new Set();
+	const broadcast = Effect.fn("EventService.broadcast")(function* broadcast(type, data) {
+		const event = {
+			data,
+			timestamp: Date.now(),
+			type
+		};
+		for (const queue of subscribers) yield* Queue.offer(queue, event);
+	});
+	const subscribe = Effect.fn("EventService.subscribe")(function* subscribe() {
+		const queue = yield* Queue.sliding(100);
+		subscribers.add(queue);
+		return {
+			stream: Stream.fromQueue(queue),
+			unsubscribe: Effect.sync(() => {
+				subscribers.delete(queue);
+			}).pipe(Effect.andThen(Queue.shutdown(queue)))
+		};
+	});
+	const startFileWatcher = (repoPath) => Effect.acquireRelease(Effect.sync(() => {
+		let debounceTimer = null;
+		const watcher = chokidar_default.watch(repoPath, {
+			ignoreInitial: true,
+			ignored: [
+				"**/node_modules/**",
+				"**/.git/**",
+				"**/.ringi/**",
+				"**/dist/**"
+			],
+			persistent: true,
+			...platform() === "darwin" ? {
+				interval: 1e3,
+				usePolling: true
+			} : {}
+		});
+		const debouncedBroadcast = (filePath) => {
+			if (debounceTimer) clearTimeout(debounceTimer);
+			debounceTimer = setTimeout(() => {
+				runFork(broadcast("files", { path: relative(repoPath, filePath) }));
+			}, 300);
+		};
+		watcher.on("add", debouncedBroadcast);
+		watcher.on("change", debouncedBroadcast);
+		watcher.on("unlink", debouncedBroadcast);
+		return watcher;
+	}), (watcher) => Effect.promise(() => watcher.close()));
+	const getClientCount = () => Effect.sync(() => subscribers.size);
+	return {
+		broadcast,
+		getClientCount,
+		startFileWatcher,
+		subscribe
+	};
+}) }) {};
+//#endregion
+//#region ../../packages/core/src/runtime.ts
+const CoreLive = Layer.mergeAll(ReviewService.Default, ReviewRepo.Default, ReviewFileRepo.Default, CommentService.Default, CommentRepo.Default, TodoService.Default, TodoRepo.Default, GitService.Default, EventService.Default, ExportService.Default, SqliteService.Default);
+//#endregion
+export { GitService as a, CommentService as c, ReviewId as d, ReviewNotFound as f, ReviewService as i, TodoId as l, ExportService as n, getDiffSummary as o, ReviewSourceType as p, TodoService as r, parseDiff as s, CoreLive as t, TodoNotFound as u };
+
+//# sourceMappingURL=runtime.mjs.map