@sanurb/ringi 0.2.0 → 0.2.1

package/dist/chunk-KMYSGMD3.js

@@ -1,3526 +0,0 @@
-import * as HttpApiSchema from '@effect/platform/HttpApiSchema';
-import * as Schema3 from 'effect/Schema';
-import { randomUUID } from 'node:crypto';
-import * as Effect4 from 'effect/Effect';
-import * as Option from 'effect/Option';
-import { mkdirSync, stat as stat$1, unwatchFile, watchFile, watch as watch$1 } from 'node:fs';
-import * as sp2 from 'node:path';
-import { dirname, join, relative, resolve, sep } from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import * as Config from 'effect/Config';
-import * as Exit from 'effect/Exit';
-import { spawn, execFile } from 'node:child_process';
-import { readFile, stat, realpath, lstat, readdir, open } from 'node:fs/promises';
-import * as Layer from 'effect/Layer';
-import 'effect/ManagedRuntime';
-import { type, platform } 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';
-
-// ../../packages/core/src/schemas/review.ts
-var ReviewId = Schema3.String.pipe(Schema3.brand("ReviewId"));
-var ReviewStatus = Schema3.Literal(
-  "in_progress",
-  "approved",
-  "changes_requested"
-);
-var ReviewSourceType = Schema3.Literal("staged", "branch", "commits");
-Schema3.Struct({
-  baseRef: Schema3.NullOr(Schema3.String),
-  createdAt: Schema3.String,
-  id: ReviewId,
-  repositoryPath: Schema3.String,
-  snapshotData: Schema3.String,
-  sourceRef: Schema3.NullOr(Schema3.String),
-  sourceType: ReviewSourceType,
-  status: ReviewStatus,
-  updatedAt: Schema3.String
-});
-Schema3.Struct({
-  sourceRef: Schema3.optionalWith(Schema3.NullOr(Schema3.String), {
-    default: () => null
-  }),
-  sourceType: Schema3.optionalWith(ReviewSourceType, {
-    default: () => "staged"
-  })
-});
-Schema3.Struct({
-  status: Schema3.optionalWith(ReviewStatus, { as: "Option" })
-});
-var ReviewNotFound = class extends Schema3.TaggedError()(
-  "ReviewNotFound",
-  { id: ReviewId },
-  HttpApiSchema.annotations({ status: 404 })
-) {
-};
-var TodoId = Schema3.String.pipe(Schema3.brand("TodoId"));
-Schema3.Struct({
-  completed: Schema3.Boolean,
-  content: Schema3.String,
-  createdAt: Schema3.String,
-  id: TodoId,
-  position: Schema3.Number,
-  reviewId: Schema3.NullOr(ReviewId),
-  updatedAt: Schema3.String
-});
-Schema3.Struct({
-  content: Schema3.String.pipe(Schema3.minLength(1)),
-  reviewId: Schema3.optionalWith(Schema3.NullOr(ReviewId), {
-    default: () => null
-  })
-});
-Schema3.Struct({
-  completed: Schema3.optionalWith(Schema3.Boolean, { as: "Option" }),
-  content: Schema3.optionalWith(Schema3.String.pipe(Schema3.minLength(1)), {
-    as: "Option"
-  })
-});
-var TodoNotFound = class extends Schema3.TaggedError()(
-  "TodoNotFound",
-  { id: TodoId },
-  HttpApiSchema.annotations({ status: 404 })
-) {
-};
-
-// ../../packages/core/src/db/migrations.ts
-var migrations = [
-  // v1: reviews table
-  `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`,
-  // v2: comments table
-  `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`,
-  // v3: add source_type and source_ref to reviews
-  `ALTER TABLE reviews ADD COLUMN source_type TEXT DEFAULT 'staged';
-   ALTER TABLE reviews ADD COLUMN source_ref TEXT`,
-  // v4: todos table
-  `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`,
-  // v5: add position to todos
-  `ALTER TABLE todos ADD COLUMN position INTEGER DEFAULT 0`,
-  // v6: review_files table
-  `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`
-];
-var 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}`);
-  }
-};
-
-// ../../packages/core/src/db/database.ts
-var withTransaction = (db, body) => Effect4.acquireUseRelease(
-  Effect4.sync(() => db.exec("BEGIN")),
-  () => body,
-  (_, exit) => Effect4.sync(() => {
-    if (Exit.isSuccess(exit)) {
-      db.exec("COMMIT");
-    } else {
-      db.exec("ROLLBACK");
-    }
-  })
-);
-var SqliteService = class extends Effect4.Service()(
-  "@ringi/SqliteService",
-  {
-    effect: Effect4.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 };
-    })
-  }
-) {
-};
-
-// ../../packages/core/src/repos/comment.repo.ts
-var 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 Effect4.Service()(
-  "@ringi/CommentRepo",
-  {
-    dependencies: [SqliteService.Default],
-    effect: Effect4.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) => Effect4.sync(() => {
-        const row = stmtFindById.get(id);
-        return row ? rowToComment(row) : null;
-      });
-      const findByReview = (reviewId) => Effect4.sync(() => {
-        const rows = stmtFindByReview.all(
-          reviewId
-        );
-        return rows.map(rowToComment);
-      });
-      const findByFile = (reviewId, filePath) => Effect4.sync(() => {
-        const rows = stmtFindByFile.all(
-          reviewId,
-          filePath
-        );
-        return rows.map(rowToComment);
-      });
-      const create = (input) => Effect4.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) => Effect4.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 row2 = stmtFindById.get(id);
-          return row2 ? rowToComment(row2) : 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) => Effect4.sync(() => {
-        stmtSetResolved.run(resolved ? 1 : 0, id);
-        const row = stmtFindById.get(id);
-        return row ? rowToComment(row) : null;
-      });
-      const remove = (id) => Effect4.sync(() => {
-        const result = stmtDelete.run(id);
-        return Number(result.changes) > 0;
-      });
-      const removeByReview = (reviewId) => Effect4.sync(() => {
-        const result = stmtDeleteByReview.run(reviewId);
-        return Number(result.changes);
-      });
-      const countByReview = (reviewId) => Effect4.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
-      };
-    })
-  }
-) {
-};
-var CommentId = Schema3.String.pipe(Schema3.brand("CommentId"));
-var LineType = Schema3.Literal("added", "removed", "context");
-Schema3.Struct({
-  content: Schema3.String,
-  createdAt: Schema3.String,
-  filePath: Schema3.String,
-  id: CommentId,
-  lineNumber: Schema3.NullOr(Schema3.Number),
-  lineType: Schema3.NullOr(LineType),
-  resolved: Schema3.Boolean,
-  reviewId: ReviewId,
-  suggestion: Schema3.NullOr(Schema3.String),
-  updatedAt: Schema3.String
-});
-Schema3.Struct({
-  content: Schema3.String.pipe(Schema3.minLength(1)),
-  filePath: Schema3.String.pipe(Schema3.minLength(1)),
-  lineNumber: Schema3.optionalWith(Schema3.NullOr(Schema3.Number), {
-    default: () => null
-  }),
-  lineType: Schema3.optionalWith(Schema3.NullOr(LineType), {
-    default: () => null
-  }),
-  suggestion: Schema3.optionalWith(Schema3.NullOr(Schema3.String), {
-    default: () => null
-  })
-});
-Schema3.Struct({
-  content: Schema3.optionalWith(Schema3.String.pipe(Schema3.minLength(1)), {
-    as: "Option"
-  }),
-  suggestion: Schema3.optionalWith(Schema3.NullOr(Schema3.String), {
-    as: "Option"
-  })
-});
-var CommentNotFound = class extends Schema3.TaggedError()(
-  "CommentNotFound",
-  { id: CommentId },
-  HttpApiSchema.annotations({ status: 404 })
-) {
-};
-
-// ../../packages/core/src/services/comment.service.ts
-var CommentService = class extends Effect4.Service()(
-  "@ringi/CommentService",
-  {
-    dependencies: [CommentRepo.Default],
-    effect: Effect4.sync(() => {
-      const create = Effect4.fn("CommentService.create")(function* create2(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 = Effect4.fn("CommentService.getById")(function* getById2(id) {
-        const repo = yield* CommentRepo;
-        const comment = yield* repo.findById(id);
-        if (!comment) {
-          return yield* new CommentNotFound({ id });
-        }
-        return comment;
-      });
-      const getByReview = Effect4.fn("CommentService.getByReview")(
-        function* getByReview2(reviewId) {
-          const repo = yield* CommentRepo;
-          return yield* repo.findByReview(reviewId);
-        }
-      );
-      const getByFile = Effect4.fn("CommentService.getByFile")(
-        function* getByFile2(reviewId, filePath) {
-          const repo = yield* CommentRepo;
-          return yield* repo.findByFile(reviewId, filePath);
-        }
-      );
-      const update = Effect4.fn("CommentService.update")(function* update2(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 resolve3 = Effect4.fn("CommentService.resolve")(function* resolve4(id) {
-        const repo = yield* CommentRepo;
-        const comment = yield* repo.setResolved(id, true);
-        if (!comment) {
-          return yield* new CommentNotFound({ id });
-        }
-        return comment;
-      });
-      const unresolve = Effect4.fn("CommentService.unresolve")(
-        function* unresolve2(id) {
-          const repo = yield* CommentRepo;
-          const comment = yield* repo.setResolved(id, false);
-          if (!comment) {
-            return yield* new CommentNotFound({ id });
-          }
-          return comment;
-        }
-      );
-      const remove = Effect4.fn("CommentService.remove")(function* remove2(id) {
-        const repo = yield* CommentRepo;
-        const existed = yield* repo.remove(id);
-        if (!existed) {
-          return yield* new CommentNotFound({ id });
-        }
-        return { success: true };
-      });
-      const getStats = Effect4.fn("CommentService.getStats")(function* getStats2(reviewId) {
-        const repo = yield* CommentRepo;
-        return yield* repo.countByReview(reviewId);
-      });
-      return {
-        create,
-        getByFile,
-        getById,
-        getByReview,
-        getStats,
-        remove,
-        resolve: resolve3,
-        unresolve,
-        update
-      };
-    })
-  }
-) {
-};
-
-// ../../packages/core/src/services/diff.service.ts
-var HUNK_HEADER = /@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
-var splitIntoFiles = (diffText) => {
-  const files = [];
-  const lines2 = diffText.split("\n");
-  let current = [];
-  for (const line of lines2) {
-    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;
-};
-var parseHunks = (lines2) => {
-  const hunks = [];
-  let currentHunk = null;
-  let oldLineNum = 0;
-  let newLineNum = 0;
-  for (const line of lines2) {
-    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);
-      const newLines = Number.parseInt(match[4] ?? "1", 10);
-      currentHunk = { lines: [], newLines, 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;
-};
-var parseFileDiff = (fileDiff) => {
-  const lines2 = fileDiff.split("\n");
-  const diffLine = lines2.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 (lines2.some((l) => l.startsWith("deleted file mode"))) {
-    status = "deleted";
-  } else if (lines2.some((l) => l.startsWith("new file mode"))) {
-    status = "added";
-  } else if (lines2.some((l) => l.startsWith("rename from")) || oldPath !== newPath) {
-    status = "renamed";
-  }
-  const hunks = parseHunks(lines2);
-  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 };
-};
-var 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;
-};
-var 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
-  };
-};
-var GitError = class extends Schema3.TaggedError()(
-  "GitError",
-  { message: Schema3.String },
-  HttpApiSchema.annotations({ status: 500 })
-) {
-};
-var MAX_STDOUT_BYTES = 200 * 1024 * 1024;
-var execGit = (args, repoPath) => Effect4.tryPromise({
-  catch: (error) => new GitError({ message: String(error) }),
-  try: () => new Promise((resolve3, 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) {
-        resolve3(Buffer.concat(chunks).toString("utf8"));
-        return;
-      }
-      if (code !== 0) {
-        reject(
-          new Error(`git ${args[0]} exited with code ${code}: ${stderr}`)
-        );
-      } else {
-        resolve3(Buffer.concat(chunks).toString("utf8"));
-      }
-    });
-  })
-});
-var lines = (output) => output.trim().split("\n").filter(Boolean);
-var parseNameStatus = (output) => lines(output).map((line) => {
-  const [status, ...rest] = line.split("	");
-  return { path: rest.join("	"), status };
-});
-var GitService = class extends Effect4.Service()(
-  "@ringi/GitService",
-  {
-    effect: Effect4.gen(function* effect() {
-      const repoPath = yield* Config.string("REPOSITORY_PATH").pipe(
-        Config.withDefault(process.cwd())
-      );
-      const hasCommits = execGit(["rev-parse", "HEAD"], repoPath).pipe(
-        Effect4.as(true),
-        Effect4.catchTag("GitError", () => Effect4.succeed(false)),
-        Effect4.withSpan("GitService.hasCommits")
-      );
-      const getRepositoryInfo = Effect4.gen(function* getRepositoryInfo2() {
-        const name = yield* execGit(
-          ["rev-parse", "--show-toplevel"],
-          repoPath
-        ).pipe(Effect4.map((s) => s.trim().split("/").pop() ?? "unknown"));
-        const branch = yield* execGit(
-          ["rev-parse", "--abbrev-ref", "HEAD"],
-          repoPath
-        ).pipe(Effect4.map((s) => s.trim()));
-        const remote = yield* execGit(
-          ["config", "--get", "remote.origin.url"],
-          repoPath
-        ).pipe(
-          Effect4.map((s) => s.trim() || null),
-          Effect4.catchTag("GitError", () => Effect4.succeed(null))
-        );
-        return { branch, name, path: repoPath, remote };
-      }).pipe(Effect4.withSpan("GitService.getRepositoryInfo"));
-      const getStagedDiff = execGit(
-        ["diff", "--cached", "--no-color", "--unified=3"],
-        repoPath
-      ).pipe(Effect4.withSpan("GitService.getStagedDiff"));
-      const getUncommittedDiff = hasCommits.pipe(
-        Effect4.flatMap(
-          (has) => has ? execGit(["diff", "HEAD", "--no-color", "--unified=3"], repoPath) : Effect4.succeed("")
-        ),
-        Effect4.withSpan("GitService.getUncommittedDiff")
-      );
-      const getUnstagedDiff = execGit(
-        ["diff", "--no-color", "--unified=3"],
-        repoPath
-      ).pipe(Effect4.withSpan("GitService.getUnstagedDiff"));
-      const getLastCommitDiff = hasCommits.pipe(
-        Effect4.flatMap(
-          (has) => has ? execGit(
-            ["show", "HEAD", "--format=", "--no-color", "--unified=3"],
-            repoPath
-          ) : Effect4.succeed("")
-        ),
-        Effect4.withSpan("GitService.getLastCommitDiff")
-      );
-      const getBranchDiff = Effect4.fn("GitService.getBranchDiff")(
-        function* getBranchDiff2(branch) {
-          return yield* execGit(
-            ["diff", `${branch}...HEAD`, "--no-color", "--unified=3"],
-            repoPath
-          );
-        }
-      );
-      const getCommitDiff = Effect4.fn("GitService.getCommitDiff")(
-        function* getCommitDiff2(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(
-        Effect4.map(parseNameStatus),
-        Effect4.withSpan("GitService.getStagedFiles")
-      );
-      const getUncommittedFiles = hasCommits.pipe(
-        Effect4.flatMap(
-          (has) => has ? execGit(["diff", "HEAD", "--name-status"], repoPath).pipe(
-            Effect4.map(parseNameStatus)
-          ) : Effect4.succeed([])
-        ),
-        Effect4.withSpan("GitService.getUncommittedFiles")
-      );
-      const getUnstagedFiles = execGit(
-        ["diff", "--name-status"],
-        repoPath
-      ).pipe(
-        Effect4.map(parseNameStatus),
-        Effect4.withSpan("GitService.getUnstagedFiles")
-      );
-      const getLastCommitFiles = hasCommits.pipe(
-        Effect4.flatMap(
-          (has) => has ? execGit(
-            ["show", "HEAD", "--format=", "--name-status"],
-            repoPath
-          ).pipe(Effect4.map(parseNameStatus)) : Effect4.succeed([])
-        ),
-        Effect4.withSpan("GitService.getLastCommitFiles")
-      );
-      const getFileContent = Effect4.fn("GitService.getFileContent")(
-        function* getFileContent2(filePath, version) {
-          switch (version) {
-            case "staged": {
-              return yield* execGit(["show", `:${filePath}`], repoPath);
-            }
-            case "head": {
-              return yield* execGit(["show", `HEAD:${filePath}`], repoPath);
-            }
-            case "working":
-            default: {
-              return yield* Effect4.tryPromise({
-                catch: (error) => new GitError({
-                  message: `Failed to read ${filePath}: ${String(error)}`
-                }),
-                try: () => readFile(join(repoPath, filePath), "utf8")
-              });
-            }
-          }
-        }
-      );
-      const getFileTree = Effect4.fn("GitService.getFileTree")(
-        function* getFileTree2(ref) {
-          return yield* execGit(
-            ["ls-tree", "-r", "--name-only", ref],
-            repoPath
-          ).pipe(Effect4.map(lines));
-        }
-      );
-      const getBranches = execGit(
-        ["branch", "--format=%(refname:short)	%(HEAD)"],
-        repoPath
-      ).pipe(
-        Effect4.map(
-          (output) => lines(output).map((line) => {
-            const [name, head] = line.split("	");
-            return { current: head === "*", name };
-          })
-        ),
-        Effect4.withSpan("GitService.getBranches")
-      );
-      const getCommits = Effect4.fn("GitService.getCommits")(
-        function* getCommits2(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 output = yield* execGit(args, repoPath);
-          const rows = lines(output);
-          const hasMore = rows.length === limit;
-          const commits = (hasMore ? rows.slice(0, -1) : rows).map((line) => {
-            const [hash, message, author, date] = line.split("	");
-            return {
-              author,
-              date,
-              hash,
-              message
-            };
-          });
-          return { commits, hasMore };
-        }
-      );
-      const stageFiles = Effect4.fn("GitService.stageFiles")(
-        function* stageFiles2(files) {
-          return yield* execGit(["add", "--", ...files], repoPath).pipe(
-            Effect4.as(files)
-          );
-        }
-      );
-      const stageAll = execGit(["add", "-A"], repoPath).pipe(
-        Effect4.flatMap(() => getStagedFiles),
-        Effect4.map((files) => files.map((f) => f.path)),
-        Effect4.withSpan("GitService.stageAll")
-      );
-      const unstageFiles = Effect4.fn("GitService.unstageFiles")(
-        function* unstageFiles2(files) {
-          return yield* execGit(
-            ["reset", "HEAD", "--", ...files],
-            repoPath
-          ).pipe(Effect4.as(files));
-        }
-      );
-      const getRepositoryPath = execGit(
-        ["rev-parse", "--show-toplevel"],
-        repoPath
-      ).pipe(
-        Effect4.map((s) => s.trim()),
-        Effect4.withSpan("GitService.getRepositoryPath")
-      );
-      return {
-        getBranchDiff,
-        getBranches,
-        getCommitDiff,
-        getCommits,
-        getFileContent,
-        getFileTree,
-        getLastCommitDiff,
-        getLastCommitFiles,
-        getRepositoryInfo,
-        getRepositoryPath,
-        getStagedDiff,
-        getStagedFiles,
-        getUncommittedDiff,
-        getUncommittedFiles,
-        getUnstagedDiff,
-        getUnstagedFiles,
-        hasCommits,
-        stageAll,
-        stageFiles,
-        unstageFiles
-      };
-    })
-  }
-) {
-};
-var parseHunks2 = (hunksData) => hunksData == null ? Effect4.succeed([]) : Effect4.try(() => JSON.parse(hunksData)).pipe(
-  Effect4.orElseSucceed(() => [])
-);
-var serializeHunks = (hunks) => JSON.stringify(hunks);
-var ReviewFileRepo = class extends Effect4.Service()(
-  "@ringi/ReviewFileRepo",
-  {
-    dependencies: [SqliteService.Default],
-    effect: Effect4.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) => Effect4.sync(
-        () => stmtFindByReview.all(reviewId)
-      );
-      const findByReviewAndPath = (reviewId, filePath) => Effect4.sync(() => {
-        const row = stmtFindByReviewAndPath.get(
-          reviewId,
-          filePath
-        );
-        return row ?? null;
-      });
-      const createBulk = (files) => withTransaction(
-        db,
-        Effect4.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) => Effect4.sync(() => {
-        const result = stmtDeleteByReview.run(reviewId);
-        return Number(result.changes);
-      });
-      const countByReview = (reviewId) => Effect4.sync(() => {
-        const row = stmtCountByReview.get(reviewId);
-        return row.count;
-      });
-      return {
-        countByReview,
-        createBulk,
-        deleteByReview,
-        findByReview,
-        findByReviewAndPath
-      };
-    })
-  }
-) {
-};
-var 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 Effect4.Service()(
-  "@ringi/ReviewRepo",
-  {
-    dependencies: [SqliteService.Default],
-    effect: Effect4.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) => Effect4.sync(() => {
-        const row = stmtFindById.get(id);
-        return row ? rowToReview(row) : null;
-      });
-      const findAll = (opts = {}) => Effect4.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
-        );
-        const rows = db.prepare(
-          `SELECT * FROM reviews${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`
-        ).all(
-          ...params,
-          pageSize,
-          offset
-        );
-        return { data: rows.map(rowToReview), total: totalRow.count };
-      });
-      const create = (input) => Effect4.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) => Effect4.sync(() => {
-        stmtUpdate.run(status, id);
-        const row = stmtFindById.get(id);
-        return row ? rowToReview(row) : null;
-      });
-      const remove = (id) => Effect4.sync(() => {
-        const result = stmtDelete.run(id);
-        return Number(result.changes) > 0;
-      });
-      const countAll = () => Effect4.sync(() => {
-        const row = stmtCountAll.get();
-        return row.count;
-      });
-      const countByStatus = (status) => Effect4.sync(() => {
-        const row = stmtCountByStatus.get(status);
-        return row.count;
-      });
-      return {
-        countAll,
-        countByStatus,
-        create,
-        findAll,
-        findById,
-        remove,
-        update
-      };
-    })
-  }
-) {
-};
-
-// ../../packages/core/src/services/review.service.ts
-var ReviewError = class extends Schema3.TaggedError()(
-  "ReviewError",
-  { code: Schema3.String, message: Schema3.String },
-  HttpApiSchema.annotations({ status: 400 })
-) {
-};
-var getHeadSha = (repoPath) => Effect4.tryPromise({
-  catch: () => new ReviewError({ code: "GIT_ERROR", message: "Failed to get HEAD" }),
-  try: () => new Promise((resolve3, reject) => {
-    execFile(
-      "git",
-      ["rev-parse", "HEAD"],
-      { cwd: repoPath },
-      (err, stdout) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve3(stdout.trim());
-        }
-      }
-    );
-  })
-});
-var parseSnapshotData = (s) => Effect4.try(() => JSON.parse(s)).pipe(
-  Effect4.orElseSucceed(() => ({}))
-);
-var ReviewService = class extends Effect4.Service()(
-  "@ringi/ReviewService",
-  {
-    dependencies: [
-      ReviewRepo.Default,
-      ReviewFileRepo.Default,
-      GitService.Default
-    ],
-    effect: Effect4.sync(() => {
-      const create = Effect4.fn("ReviewService.create")(function* create2(input) {
-        const git = yield* GitService;
-        const repo = yield* ReviewRepo;
-        const fileRepo = yield* ReviewFileRepo;
-        const repoPath = yield* git.getRepositoryPath;
-        const hasCommitsResult = yield* git.hasCommits;
-        if (!hasCommitsResult) {
-          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 = Effect4.fn("ReviewService.list")(function* list2(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 = Effect4.fn("ReviewService.getById")(function* getById2(id) {
-        const repo = yield* ReviewRepo;
-        const fileRepo = yield* ReviewFileRepo;
-        const review = yield* repo.findById(id);
-        if (!review) {
-          return yield* new ReviewNotFound({ id });
-        }
-        const fileRows = yield* fileRepo.findByReview(id);
-        const files = fileRows.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 = Effect4.fn("ReviewService.getFileHunks")(
-        function* getFileHunks2(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* parseHunks2(fileRecord.hunks_data);
-          }
-          if (review.sourceType === "branch" && review.sourceRef) {
-            const diff = yield* git.getBranchDiff(review.sourceRef);
-            const diffFiles = parseDiff(diff);
-            const file = diffFiles.find((f) => f.newPath === filePath);
-            return file?.hunks ?? [];
-          }
-          if (review.sourceType === "commits" && review.sourceRef) {
-            const shas = review.sourceRef.split(",").map((s) => s.trim());
-            const diff = yield* git.getCommitDiff(shas);
-            const diffFiles = parseDiff(diff);
-            const file = diffFiles.find((f) => f.newPath === filePath);
-            return file?.hunks ?? [];
-          }
-          const snapshot = yield* parseSnapshotData(review.snapshotData);
-          if (snapshot.files) {
-            const legacyFile = snapshot.files.find(
-              (f) => f.newPath === filePath
-            );
-            return legacyFile?.hunks ?? [];
-          }
-          return [];
-        }
-      );
-      const update = Effect4.fn("ReviewService.update")(function* update2(id, input) {
-        const repo = yield* ReviewRepo;
-        const existing = yield* repo.findById(id);
-        if (!existing) {
-          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 = Effect4.fn("ReviewService.remove")(function* remove2(id) {
-        const repo = yield* ReviewRepo;
-        const fileRepo = yield* ReviewFileRepo;
-        const existing = yield* repo.findById(id);
-        if (!existing) {
-          return yield* new ReviewNotFound({ id });
-        }
-        yield* fileRepo.deleteByReview(id);
-        yield* repo.remove(id);
-        return { success: true };
-      });
-      const getStats = Effect4.fn("ReviewService.getStats")(
-        function* getStats2() {
-          const repo = yield* ReviewRepo;
-          const total = yield* repo.countAll();
-          const inProgress = yield* repo.countByStatus("in_progress");
-          const approved = yield* repo.countByStatus("approved");
-          const changesRequested = yield* repo.countByStatus("changes_requested");
-          return { approved, changesRequested, inProgress, total };
-        }
-      );
-      return {
-        create,
-        getById,
-        getFileHunks,
-        getStats,
-        list,
-        remove,
-        update
-      };
-    })
-  }
-) {
-};
-var 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 Effect4.Service()("@ringi/TodoRepo", {
-  dependencies: [SqliteService.Default],
-  effect: Effect4.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) => Effect4.sync(() => {
-      const row = stmtFindById.get(id);
-      return row ? rowToTodo(row) : null;
-    });
-    const findAll = (opts = {}) => Effect4.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;
-      const rows = db.prepare(
-        `SELECT * FROM todos${where} ORDER BY position ASC${limitClause}`
-      ).all(
-        ...queryParams
-      );
-      return { data: rows.map(rowToTodo), total: totalRow.count };
-    });
-    const create = (input) => Effect4.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) => Effect4.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 row2 = stmtFindById.get(id);
-        return row2 ? rowToTodo(row2) : 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) => Effect4.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) => Effect4.sync(() => {
-      const result = stmtDelete.run(id);
-      return Number(result.changes) > 0;
-    });
-    const removeCompleted = () => Effect4.sync(() => {
-      const result = stmtDeleteCompleted.run();
-      return Number(result.changes);
-    });
-    const reorder = (orderedIds) => withTransaction(
-      db,
-      Effect4.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) => Effect4.gen(function* move2() {
-      const row = stmtFindById.get(id);
-      if (!row) {
-        return null;
-      }
-      const oldPosition = row.position;
-      yield* withTransaction(
-        db,
-        Effect4.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 = () => Effect4.sync(() => {
-      const row = stmtCountAll.get();
-      return row.count;
-    });
-    const countCompleted = () => Effect4.sync(() => {
-      const row = stmtCountCompleted.get();
-      return row.count;
-    });
-    const countPending = () => Effect4.sync(() => {
-      const row = stmtCountPending.get();
-      return row.count;
-    });
-    return {
-      countAll,
-      countCompleted,
-      countPending,
-      create,
-      findAll,
-      findById,
-      move,
-      remove,
-      removeCompleted,
-      reorder,
-      toggle,
-      update
-    };
-  })
-}) {
-};
-
-// ../../packages/core/src/services/todo.service.ts
-var TodoService = class extends Effect4.Service()(
-  "@ringi/TodoService",
-  {
-    dependencies: [TodoRepo.Default],
-    effect: Effect4.sync(() => {
-      const create = Effect4.fn("TodoService.create")(function* create2(input) {
-        const repo = yield* TodoRepo;
-        const id = randomUUID();
-        return yield* repo.create({
-          content: input.content,
-          id,
-          reviewId: input.reviewId
-        });
-      });
-      const getById = Effect4.fn("TodoService.getById")(function* getById2(id) {
-        const repo = yield* TodoRepo;
-        const todo = yield* repo.findById(id);
-        if (!todo) {
-          return yield* new TodoNotFound({ id });
-        }
-        return todo;
-      });
-      const list = Effect4.fn("TodoService.list")(function* list2(opts = {}) {
-        const repo = yield* TodoRepo;
-        const result = yield* repo.findAll(opts);
-        return {
-          data: result.data,
-          limit: opts.limit ?? null,
-          offset: opts.offset ?? 0,
-          total: result.total
-        };
-      });
-      const update = Effect4.fn("TodoService.update")(function* update2(id, input) {
-        const repo = yield* TodoRepo;
-        const existing = yield* repo.findById(id);
-        if (!existing) {
-          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 = Effect4.fn("TodoService.toggle")(function* toggle2(id) {
-        const repo = yield* TodoRepo;
-        const todo = yield* repo.toggle(id);
-        if (!todo) {
-          return yield* new TodoNotFound({ id });
-        }
-        return todo;
-      });
-      const remove = Effect4.fn("TodoService.remove")(function* remove2(id) {
-        const repo = yield* TodoRepo;
-        const existing = yield* repo.findById(id);
-        if (!existing) {
-          return yield* new TodoNotFound({ id });
-        }
-        yield* repo.remove(id);
-        return { success: true };
-      });
-      const removeCompleted = Effect4.fn("TodoService.removeCompleted")(
-        function* removeCompleted2() {
-          const repo = yield* TodoRepo;
-          const deleted = yield* repo.removeCompleted();
-          return { deleted };
-        }
-      );
-      const reorder = Effect4.fn("TodoService.reorder")(function* reorder2(orderedIds) {
-        const repo = yield* TodoRepo;
-        const updated = yield* repo.reorder(orderedIds);
-        return { updated };
-      });
-      const move = Effect4.fn("TodoService.move")(function* move2(id, position) {
-        const repo = yield* TodoRepo;
-        const todo = yield* repo.move(id, position);
-        if (!todo) {
-          return yield* new TodoNotFound({ id });
-        }
-        return todo;
-      });
-      const getStats = Effect4.fn("TodoService.getStats")(function* getStats2() {
-        const repo = yield* TodoRepo;
-        const total = yield* repo.countAll();
-        const completed = yield* repo.countCompleted();
-        const pending = yield* repo.countPending();
-        return { completed, pending, total };
-      });
-      return {
-        create,
-        getById,
-        getStats,
-        list,
-        move,
-        remove,
-        removeCompleted,
-        reorder,
-        toggle,
-        update
-      };
-    })
-  }
-) {
-};
-var ExportService = class extends Effect4.Service()(
-  "@ringi/ExportService",
-  {
-    dependencies: [
-      ReviewService.Default,
-      CommentService.Default,
-      TodoService.Default
-    ],
-    effect: Effect4.sync(() => {
-      const exportReview = Effect4.fn("ExportService.exportReview")(
-        function* exportReview2(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 lines2 = [];
-          lines2.push(`# Code Review: ${repoName}`);
-          lines2.push("");
-          lines2.push(`**Status:** ${review.status}`);
-          lines2.push(`**Branch:** ${branch}`);
-          lines2.push(`**Created:** ${review.createdAt}`);
-          if (review.files && review.files.length > 0) {
-            lines2.push("");
-            lines2.push("## Files Changed");
-            lines2.push("");
-            lines2.push("| File | Status | Additions | Deletions |");
-            lines2.push("|------|--------|-----------|-----------|");
-            for (const f of review.files) {
-              const statusLabel = f.status === "modified" ? "M" : f.status === "added" ? "A" : f.status === "deleted" ? "D" : f.status;
-              lines2.push(
-                `| ${f.filePath} | ${statusLabel} | +${f.additions} | -${f.deletions} |`
-              );
-            }
-          }
-          if (comments.length > 0) {
-            lines2.push("");
-            lines2.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) {
-              lines2.push("");
-              lines2.push(`### ${filePath}`);
-              for (const c of fileComments) {
-                lines2.push("");
-                lines2.push(
-                  `**Line ${c.lineNumber ?? "\u2013"}** (${c.lineType ?? "context"})`
-                );
-                lines2.push(`> ${c.content}`);
-                if (c.suggestion) {
-                  lines2.push("");
-                  lines2.push("```suggestion");
-                  lines2.push(c.suggestion);
-                  lines2.push("```");
-                }
-              }
-            }
-          }
-          if (todos.data.length > 0) {
-            const completed = todos.data.filter((t) => t.completed).length;
-            lines2.push("");
-            lines2.push("---");
-            lines2.push("");
-            lines2.push(
-              `## Todos (${todos.total} total, ${completed} completed)`
-            );
-            lines2.push("");
-            for (const t of todos.data) {
-              const check = t.completed ? "x" : " ";
-              lines2.push(`- [${check}] ${t.content}`);
-            }
-          }
-          lines2.push("");
-          return lines2.join("\n");
-        }
-      );
-      return { exportReview };
-    })
-  }
-) {
-};
-var EntryTypes = {
-  FILE_TYPE: "files",
-  DIR_TYPE: "directories",
-  FILE_DIR_TYPE: "files_directories",
-  EVERYTHING_TYPE: "all"
-};
-var defaultOptions = {
-  root: ".",
-  fileFilter: (_entryInfo) => true,
-  directoryFilter: (_entryInfo) => true,
-  type: EntryTypes.FILE_TYPE,
-  lstat: false,
-  depth: 2147483648,
-  alwaysStat: false,
-  highWaterMark: 4096
-};
-Object.freeze(defaultOptions);
-var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
-var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
-var ALL_TYPES = [
-  EntryTypes.DIR_TYPE,
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE,
-  EntryTypes.FILE_TYPE
-];
-var DIR_TYPES = /* @__PURE__ */ new Set([
-  EntryTypes.DIR_TYPE,
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE
-]);
-var FILE_TYPES = /* @__PURE__ */ new Set([
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE,
-  EntryTypes.FILE_TYPE
-]);
-var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
-var wantBigintFsStats = process.platform === "win32";
-var emptyFn = (_entryInfo) => true;
-var 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;
-};
-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;
-    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 basename3 = this._isDirent ? dirent.name : dirent;
-    try {
-      const fullPath = resolve(join(path, basename3));
-      entry = { path: relative(this._root, fullPath), fullPath, basename: basename3 };
-      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 = 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();
-  }
-};
-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);
-}
-var STR_DATA = "data";
-var STR_END = "end";
-var STR_CLOSE = "close";
-var EMPTY_FN = () => {
-};
-var pl = process.platform;
-var isWindows = pl === "win32";
-var isMacos = pl === "darwin";
-var isLinux = pl === "linux";
-var isFreeBSD = pl === "freebsd";
-var isIBMi = type() === "OS400";
-var EVENTS = {
-  ALL: "all",
-  READY: "ready",
-  ADD: "add",
-  CHANGE: "change",
-  ADD_DIR: "addDir",
-  UNLINK: "unlink",
-  UNLINK_DIR: "unlinkDir",
-  RAW: "raw",
-  ERROR: "error"
-};
-var EV = EVENTS;
-var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat, stat: stat };
-var KEY_LISTENERS = "listeners";
-var KEY_ERR = "errHandlers";
-var KEY_RAW = "rawEmitters";
-var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
-var binaryExtensions = /* @__PURE__ */ 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"
-]);
-var isBinaryPath = (filePath) => binaryExtensions.has(sp2.extname(filePath).slice(1).toLowerCase());
-var foreach = (val, fn7) => {
-  if (val instanceof Set) {
-    val.forEach(fn7);
-  } else {
-    fn7(val);
-  }
-};
-var addAndConvert = (main, prop, item) => {
-  let container = main[prop];
-  if (!(container instanceof Set)) {
-    main[prop] = container = /* @__PURE__ */ new Set([container]);
-  }
-  container.add(item);
-};
-var clearItem = (cont) => (key) => {
-  const set = cont[key];
-  if (set instanceof Set) {
-    set.clear();
-  } else {
-    delete cont[key];
-  }
-};
-var delFromSet = (main, prop, item) => {
-  const container = main[prop];
-  if (container instanceof Set) {
-    container.delete(item);
-  } else if (container === item) {
-    delete main[prop];
-  }
-};
-var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
-var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
-  const handleEvent = (rawEvent, evPath) => {
-    listener(path);
-    emitRaw(rawEvent, evPath, { watchedPath: path });
-    if (evPath && path !== evPath) {
-      fsWatchBroadcast(sp2.resolve(path, evPath), KEY_LISTENERS, sp2.join(path, evPath));
-    }
-  };
-  try {
-    return watch$1(path, {
-      persistent: options.persistent
-    }, handleEvent);
-  } catch (error) {
-    errHandler(error);
-    return void 0;
-  }
-}
-var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
-  const cont = FsWatchInstances.get(fullPath);
-  if (!cont)
-    return;
-  foreach(cont[listenerType], (listener) => {
-    listener(val1, val2, val3);
-  });
-};
-var 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,
-      // no need to use broadcast here
-      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 {
-          const fd = await open(path, "r");
-          await fd.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);
-    }
-  };
-};
-var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var 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, (rawEmitter2) => {
-          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
-        });
-        const currmtime = curr.mtimeMs;
-        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(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);
-    }
-  };
-};
-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 = sp2.dirname(path);
-    const basename3 = sp2.basename(path);
-    const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename3);
-    const absolutePath = sp2.resolve(path);
-    const options = {
-      persistent: opts.persistent
-    };
-    if (!listener)
-      listener = EMPTY_FN;
-    let closer;
-    if (opts.usePolling) {
-      const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename3) ? 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 dirname4 = sp2.dirname(file);
-    const basename3 = sp2.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname4);
-    let prevStats = stats;
-    if (parent.has(basename3))
-      return;
-    const listener = async (path, newStats) => {
-      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
-        return;
-      if (!newStats || newStats.mtimeMs === 0) {
-        try {
-          const newStats2 = await stat(file);
-          if (this.fsw.closed)
-            return;
-          const at = newStats2.atimeMs;
-          const mt = newStats2.mtimeMs;
-          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-            this.fsw._emit(EV.CHANGE, file, newStats2);
-          }
-          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path);
-            prevStats = newStats2;
-            const closer2 = this._watchWithNodeFs(file, listener);
-            if (closer2)
-              this.fsw._addPathCloser(path, closer2);
-          } else {
-            prevStats = newStats2;
-          }
-        } catch (error) {
-          this.fsw._remove(dirname4, basename3);
-        }
-      } else if (parent.has(basename3)) {
-        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 = sp2.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 = sp2.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 = sp2.join(dir, sp2.relative(dir, path));
-        this._addToNodeFs(path, initialAdd, wh, depth + 1);
-      }
-    }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve3, reject) => {
-      if (!stream)
-        return reject();
-      stream.once(STR_END, () => {
-        if (this.fsw.closed) {
-          stream = void 0;
-          return;
-        }
-        const wasThrottled = throttler ? throttler.clear() : false;
-        resolve3(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, realpath2) {
-    const parentDir = this.fsw._getWatchedDir(sp2.dirname(dir));
-    const tracked = parentDir.has(sp2.basename(dir));
-    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
-      this.fsw._emit(EV.ADD_DIR, dir, stats);
-    }
-    parentDir.add(sp2.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(realpath2)) {
-      if (!target) {
-        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
-        if (this.fsw.closed)
-          return;
-      }
-      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
-        if (stats2 && stats2.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 = sp2.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 = sp2.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(sp2.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;
-      }
-    }
-  }
-};
-
-// ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
-var SLASH = "/";
-var SLASH_SLASH = "//";
-var ONE_DOT = ".";
-var TWO_DOTS = "..";
-var STRING_TYPE = "string";
-var BACK_SLASH_RE = /\\/g;
-var DOUBLE_SLASH_RE = /\/\//g;
-var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
-var REPLACER_RE = /^\.[/\\]/;
-function arrify(item) {
-  return Array.isArray(item) ? item : [item];
-}
-var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
-function createPattern(matcher) {
-  if (typeof matcher === "function")
-    return matcher;
-  if (typeof matcher === "string")
-    return (string3) => matcher === string3;
-  if (matcher instanceof RegExp)
-    return (string3) => matcher.test(string3);
-  if (typeof matcher === "object" && matcher !== null) {
-    return (string3) => {
-      if (matcher.path === string3)
-        return true;
-      if (matcher.recursive) {
-        const relative4 = sp2.relative(matcher.path, string3);
-        if (!relative4) {
-          return false;
-        }
-        return !relative4.startsWith("..") && !sp2.isAbsolute(relative4);
-      }
-      return false;
-    };
-  }
-  return () => false;
-}
-function normalizePath(path) {
-  if (typeof path !== "string")
-    throw new Error("string expected");
-  path = sp2.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 matchersArray = arrify(matchers);
-  const patterns = matchersArray.map((matcher) => createPattern(matcher));
-  {
-    return (testString2, stats) => {
-      return matchPatterns(patterns, testString2, stats);
-    };
-  }
-}
-var 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);
-};
-var toUnix = (string3) => {
-  let str = string3.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;
-};
-var normalizePathToUnix = (path) => toUnix(sp2.normalize(toUnix(path)));
-var normalizeIgnored = (cwd = "") => (path) => {
-  if (typeof path === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path) ? path : sp2.join(cwd, path));
-  } else {
-    return path;
-  }
-};
-var getAbsolutePath = (path, cwd) => {
-  if (sp2.isAbsolute(path)) {
-    return path;
-  }
-  return sp2.join(cwd, path);
-};
-var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
-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(sp2.dirname(dir), sp2.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);
-  }
-};
-var STAT_METHOD_F = "stat";
-var 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 = sp2.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 sp2.join(this.watchPath, sp2.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);
-  }
-};
-var FSWatcher = class extends EventEmitter {
-  closed;
-  options;
-  _closers;
-  _ignoredPaths;
-  _throttled;
-  _streams;
-  _symlinkPaths;
-  _watched;
-  _pendingWrites;
-  _pendingUnlinks;
-  _readyCount;
-  _emitReady;
-  _closePromise;
-  _userIgnored;
-  _readyEmitted;
-  _emitRaw;
-  _boundRemove;
-  _nodeFsHandler;
-  // Not indenting methods for history sake; for now.
-  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 = {
-      // Defaults
-      persistent: true,
-      ignoreInitial: false,
-      ignorePermissionErrors: false,
-      interval: 100,
-      binaryInterval: 300,
-      followSymlinks: true,
-      usePolling: false,
-      // useAsync: false,
-      atomic: true,
-      // NOTE: overwritten later (depends on usePolling)
-      ..._opts,
-      // Change format
-      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);
-        }
-      }
-    }
-  }
-  // Public methods
-  /**
-   * 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) => {
-        const absPath = getAbsolutePath(path, cwd);
-        return absPath;
-      });
-    }
-    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(sp2.dirname(item), sp2.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 (!sp2.isAbsolute(path) && !this._closers.has(path)) {
-        if (cwd)
-          path = sp2.join(cwd, path);
-        path = sp2.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 promise2 = closer();
-      if (promise2 instanceof Promise)
-        closers.push(promise2);
-    }));
-    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 key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
-      const index = key || 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);
-  }
-  // Common helpers
-  // --------------
-  /**
-   * 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 = sp2.normalize(path);
-    if (opts.cwd)
-      path = sp2.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, path2) => {
-            this.emit(...entry);
-            this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path2);
-          });
-        }, 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, stats2) => {
-        if (err) {
-          event = EVENTS.ERROR;
-          args[0] = err;
-          this.emitWithAll(event, args);
-        } else if (stats2) {
-          if (args.length > 1) {
-            args[1] = stats2;
-          } else {
-            args.push(stats2);
-          }
-          this.emitWithAll(event, args);
-        }
-      };
-      this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
-      return this;
-    }
-    if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path, 50);
-      if (isThrottled)
-        return this;
-    }
-    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path) : path;
-      let stats2;
-      try {
-        stats2 = await stat(fullPath);
-      } catch (err) {
-      }
-      if (!stats2 || this.closed)
-        return;
-      args.push(stats2);
-    }
-    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 && !sp2.isAbsolute(path)) {
-      fullPath = sp2.join(this.options.cwd, path);
-    }
-    const now = /* @__PURE__ */ new Date();
-    const writes = this._pendingWrites;
-    function awaitWriteFinishFn(prevStat) {
-      stat$1(fullPath, (err, curStat) => {
-        if (err || !writes.has(path)) {
-          if (err && err.code !== "ENOENT")
-            awfEmit(err);
-          return;
-        }
-        const now2 = Number(/* @__PURE__ */ new Date());
-        if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path).lastChange = now2;
-        }
-        const pw = writes.get(path);
-        const df = now2 - pw.lastChange;
-        if (df >= 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 ign = this.options.ignored;
-      const ignored = (ign || []).map(normalizeIgnored(cwd));
-      const ignoredPaths = [...this._ignoredPaths];
-      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
-      this._userIgnored = anymatch(list);
-    }
-    return this._userIgnored(path, stats);
-  }
-  _isntIgnored(path, stat4) {
-    return !this._isIgnored(path, stat4);
-  }
-  /**
-   * 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);
-  }
-  // Directory helpers
-  // -----------------
-  /**
-   * Provides directory tracking objects
-   * @param directory path of the directory
-   */
-  _getWatchedDir(directory) {
-    const dir = sp2.resolve(directory);
-    if (!this._watched.has(dir))
-      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
-    return this._watched.get(dir);
-  }
-  // File helpers
-  // ------------
-  /**
-   * 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 = sp2.join(directory, item);
-    const fullPath = sp2.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);
-    }
-    const wp = this._getWatchedDir(path);
-    const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.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 = sp2.relative(this.options.cwd, path);
-    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
-      const event = this._pendingWrites.get(relPath).cancelWait();
-      if (event === 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 = sp2.dirname(path);
-    this._getWatchedDir(dir).remove(sp2.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;
-    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
-    let stream = readdirp(root, options);
-    this._streams.add(stream);
-    stream.once(STR_CLOSE, () => {
-      stream = void 0;
-    });
-    stream.once(STR_END, () => {
-      if (stream) {
-        this._streams.delete(stream);
-        stream = void 0;
-      }
-    });
-    return stream;
-  }
-};
-function watch(paths, options = {}) {
-  const watcher = new FSWatcher(options);
-  watcher.add(paths);
-  return watcher;
-}
-var chokidar_default = { watch, FSWatcher };
-var EventService = class extends Effect4.Service()(
-  "@ringi/EventService",
-  {
-    effect: Effect4.gen(function* effect() {
-      const rt = yield* Effect4.runtime();
-      const runFork2 = Runtime.runFork(rt);
-      const subscribers = /* @__PURE__ */ new Set();
-      const broadcast = Effect4.fn("EventService.broadcast")(function* broadcast2(type, data) {
-        const event = { data, timestamp: Date.now(), type };
-        for (const queue of subscribers) {
-          yield* Queue.offer(queue, event);
-        }
-      });
-      const subscribe = Effect4.fn("EventService.subscribe")(
-        function* subscribe2() {
-          const queue = yield* Queue.sliding(100);
-          subscribers.add(queue);
-          const stream = Stream.fromQueue(queue);
-          const unsubscribe = Effect4.sync(() => {
-            subscribers.delete(queue);
-          }).pipe(Effect4.andThen(Queue.shutdown(queue)));
-          return { stream, unsubscribe };
-        }
-      );
-      const startFileWatcher = (repoPath) => Effect4.acquireRelease(
-        Effect4.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(() => {
-              const rel = relative(repoPath, filePath);
-              runFork2(broadcast("files", { path: rel }));
-            }, 300);
-          };
-          watcher.on("add", debouncedBroadcast);
-          watcher.on("change", debouncedBroadcast);
-          watcher.on("unlink", debouncedBroadcast);
-          return watcher;
-        }),
-        (watcher) => Effect4.promise(() => watcher.close())
-      );
-      const getClientCount = () => Effect4.sync(() => subscribers.size);
-      return {
-        broadcast,
-        getClientCount,
-        startFileWatcher,
-        subscribe
-      };
-    })
-  }
-) {
-};
-
-// ../../packages/core/src/runtime.ts
-var 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
-);
-/*! Bundled license information:
-
-chokidar/index.js:
-  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
-*/
-
-export { CommentService, CoreLive, ExportService, GitService, ReviewId, ReviewNotFound, ReviewService, ReviewSourceType, TodoId, TodoNotFound, TodoService, getDiffSummary, parseDiff };
-//# sourceMappingURL=chunk-KMYSGMD3.js.map
-//# sourceMappingURL=chunk-KMYSGMD3.js.map