@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/chunks/canvas-preview-8xc0vn7v.js

@@ -0,0 +1,458 @@
+import {
+  run2,
+  spawnCommand2,
+  killTree2,
+  findExecutable2
+} from "./canvas-preview-bxnqt8cd.js";
+
+// src/local/github.ts
+import { homedir } from "node:os";
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+import { dev } from "@nyte-ai/core";
+var ENV = {
+  GH_PROMPT_DISABLED: "1",
+  GH_NO_UPDATE_NOTIFIER: "1",
+  GIT_TERMINAL_PROMPT: "0",
+  NO_COLOR: "1",
+  LC_ALL: "C"
+};
+var OUTPUT_LIMIT = 1e6;
+var QUERY_TIMEOUT_MS = 1e4;
+var CREATE_TIMEOUT_MS = 60000;
+var SIGN_IN_CODE_TIMEOUT_MS = 30000;
+var SIGN_IN_LIFETIME_MS = 15 * 60000;
+var NO_PULL_REQUEST = { kind: "none" };
+var PULL_REQUEST_FIELDS = "number,title,url,state,isDraft,headRefName,baseRefName,statusCheckRollup";
+var REMOTE_PRIORITY = ["upstream", "github", "origin"];
+var RECOVERY = {
+  update: "Update the GitHub CLI (gh), then try again.",
+  signIn: "GitHub rejected the CLI's login. Run gh auth login in a terminal, then try again.",
+  signOut: "Couldn't sign out of GitHub. Run gh auth logout in a terminal, then try again.",
+  account: "Couldn't reach GitHub. Try again.",
+  pullRequest: "Couldn't read this branch's pull request. Try again.",
+  createPullRequest: "Couldn't open a pull request. Run gh pr create in a terminal to see why."
+};
+var authSchema = Compile(Type.Array(Type.Object({ active: Type.Boolean(), state: Type.String(), login: Type.String() })));
+var accountSchema = Compile(Type.Object({
+  login: Type.String({ minLength: 1 }),
+  name: Type.Union([Type.String(), Type.Null()]),
+  avatar_url: Type.Union([Type.String(), Type.Null()])
+}));
+var optionalText = Type.Optional(Type.Union([Type.String(), Type.Null()]));
+var PullRequestJson = Type.Object({
+  number: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+  title: Type.String(),
+  url: Type.String(),
+  state: Type.Enum(["OPEN", "CLOSED", "MERGED"]),
+  isDraft: Type.Boolean(),
+  headRefName: Type.String({ minLength: 1 }),
+  baseRefName: Type.String({ minLength: 1 }),
+  statusCheckRollup: Type.Union([
+    Type.Null(),
+    Type.Array(Type.Object({
+      __typename: Type.String(),
+      name: optionalText,
+      context: optionalText,
+      status: optionalText,
+      conclusion: optionalText,
+      state: optionalText,
+      detailsUrl: optionalText,
+      targetUrl: optionalText
+    }))
+  ])
+});
+var pullRequestSchema = Compile(PullRequestJson);
+function parseJson(validator, text) {
+  try {
+    return validator.Parse(JSON.parse(text));
+  } catch {
+    return;
+  }
+}
+function safeUrl(value, hostnames) {
+  const url = URL.parse(value ?? "");
+  if (url === null || url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.port !== "" || hostnames !== undefined && !hostnames.includes(url.hostname))
+    return;
+  return url.href;
+}
+var REPOSITORY_PART = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/u;
+function parseRemote(remoteName, remote) {
+  const scp = /^(?:[^@\s]+@)?github\.com:([^/\s]+)\/([^/\s]+?)\/?$/iu.exec(remote);
+  const url = scp === null ? URL.parse(remote) : null;
+  const parts = scp === null ? url !== null && url.hostname.toLowerCase() === "github.com" ? url.pathname.split("/").filter((segment) => segment !== "") : [] : [scp[1] ?? "", scp[2] ?? ""];
+  if (parts.length !== 2)
+    return;
+  const owner = parts[0] ?? "";
+  const name = (parts[1] ?? "").replace(/\.git$/iu, "");
+  if (!REPOSITORY_PART.test(owner) || !REPOSITORY_PART.test(name))
+    return;
+  return { owner, name, remoteName, url: `https://github.com/${owner}/${name}` };
+}
+function checkState(entry) {
+  if (entry.__typename === "StatusContext") {
+    if (entry.state === "SUCCESS")
+      return "passed";
+    return entry.state === "ERROR" || entry.state === "FAILURE" ? "failed" : "pending";
+  }
+  if (entry.status !== "COMPLETED")
+    return "pending";
+  switch (entry.conclusion) {
+    case "SUCCESS":
+    case "NEUTRAL":
+      return "passed";
+    case "SKIPPED":
+    case "STALE":
+      return "skipped";
+    default:
+      return "failed";
+  }
+}
+function readCheck(entry) {
+  const url = safeUrl(entry.detailsUrl ?? entry.targetUrl);
+  const check = { name: entry.name ?? entry.context ?? "Check", state: checkState(entry) };
+  return url === undefined ? check : { ...check, url };
+}
+function readPullRequestJson(text) {
+  const pull = parseJson(pullRequestSchema, text);
+  const url = safeUrl(pull?.url, ["github.com"]);
+  if (pull === undefined || url === undefined)
+    return;
+  return {
+    number: pull.number,
+    title: pull.title,
+    url,
+    state: pull.state,
+    draft: pull.isDraft,
+    headRefName: pull.headRefName,
+    baseRefName: pull.baseRefName,
+    checks: (pull.statusCheckRollup ?? []).map(readCheck)
+  };
+}
+function readAccountJson(text) {
+  const account = parseJson(accountSchema, text);
+  if (account === undefined)
+    return;
+  const avatarUrl = safeUrl(account.avatar_url, ["avatars.githubusercontent.com"]);
+  return {
+    login: account.login,
+    ...account.name === null || account.name === "" ? {} : { name: account.name },
+    ...avatarUrl === undefined ? {} : { avatarUrl }
+  };
+}
+var USER_CODE = /one-time code\W*([A-Z0-9]{4}-[A-Z0-9]{4})\b/iu;
+var PRINTED_URL = /https:\/\/\S+/u;
+var SIGN_IN_LINE_LIMIT = 4096;
+function startSignIn(file, cwd, ended) {
+  const started = Promise.withResolvers();
+  const expiresAt = Date.now() + SIGN_IN_LIFETIME_MS;
+  let userCode;
+  let verificationUri;
+  let done = false;
+  const child = spawnCommand2(file, [
+    "auth",
+    "login",
+    "--hostname",
+    "github.com",
+    "--web",
+    "--git-protocol",
+    "https",
+    "--skip-ssh-key"
+  ], { cwd, env: { ...process.env, ...ENV }, stdio: ["ignore", "pipe", "pipe"] });
+  const end = (start) => {
+    if (done)
+      return;
+    done = true;
+    clearTimeout(codeTimer);
+    clearTimeout(lifetime);
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+    if (child.exitCode === null && child.signalCode === null)
+      killTree2(child, "SIGKILL");
+    started.resolve(start);
+    ended();
+  };
+  const readLine = (line) => {
+    userCode ??= USER_CODE.exec(line)?.[1]?.toUpperCase();
+    const printed = PRINTED_URL.exec(line)?.[0];
+    if (verificationUri === undefined && printed !== undefined) {
+      verificationUri = safeUrl(printed, ["github.com"]);
+      if (verificationUri === undefined)
+        end({ kind: "failed" });
+    }
+    if (userCode === undefined || verificationUri === undefined)
+      return;
+    clearTimeout(codeTimer);
+    started.resolve({ kind: "code", deviceCode: { userCode, verificationUri } });
+  };
+  for (const stream of [child.stdout, child.stderr]) {
+    let pending = "";
+    stream?.setEncoding("utf8");
+    stream?.on("data", (chunk) => {
+      const lines = (pending + chunk).split(/\r?\n/u);
+      pending = (lines.pop() ?? "").slice(-SIGN_IN_LINE_LIMIT);
+      for (const line of lines)
+        if (!done)
+          readLine(line);
+    });
+  }
+  child.on("error", () => end({ kind: "failed" }));
+  child.on("close", (code) => end(code === 0 ? { kind: "ended" } : { kind: "failed" }));
+  const codeTimer = setTimeout(() => end({ kind: "failed" }), SIGN_IN_CODE_TIMEOUT_MS);
+  const lifetime = setTimeout(() => end({ kind: "failed" }), SIGN_IN_LIFETIME_MS);
+  return { started: started.promise, expiresAt, cancel: () => end({ kind: "ended" }) };
+}
+function ghCommand(binary) {
+  return async (cwd, args, extra) => {
+    const file = await findExecutable2(binary);
+    if (file === null)
+      return { kind: "missing" };
+    const started = Date.now();
+    const ran = await run2(file, args, {
+      cwd,
+      env: ENV,
+      input: extra?.input,
+      limit: OUTPUT_LIMIT,
+      timeoutMs: extra?.timeoutMs ?? QUERY_TIMEOUT_MS
+    }).catch(() => null);
+    dev("github", "run", {
+      command: args.slice(0, 2).join(" "),
+      code: ran?.code ?? null,
+      ms: Date.now() - started
+    });
+    if (ran === null || ran.code === null || ran.truncated)
+      return { kind: "failed" };
+    return {
+      kind: "completed",
+      code: ran.code,
+      stdout: ran.stdout.toString("utf8"),
+      stderr: ran.stderr
+    };
+  };
+}
+async function readAuth(gh, cwd) {
+  const result = await gh(cwd, [
+    "auth",
+    "status",
+    "--hostname",
+    "github.com",
+    "--json",
+    "hosts",
+    "--jq",
+    '[(.hosts["github.com"] // [])[] | {active, state, login}]'
+  ]);
+  if (result.kind === "missing")
+    return result;
+  if (result.kind === "failed")
+    return { kind: "error", message: RECOVERY.account };
+  if (result.code !== 0)
+    return {
+      kind: "error",
+      message: /unknown flag: --(?:json|jq)\b/u.test(result.stderr) ? RECOVERY.update : RECOVERY.account
+    };
+  const entries = parseJson(authSchema, result.stdout);
+  if (entries === undefined)
+    return { kind: "error", message: RECOVERY.update };
+  const active = entries.find((entry) => entry.active);
+  if (active === undefined)
+    return { kind: "signed_out" };
+  if (active.state !== "success")
+    return {
+      kind: "error",
+      message: active.state === "error" ? RECOVERY.signIn : RECOVERY.account
+    };
+  return { kind: "ready", login: active.login };
+}
+async function readAccountState(gh, cwd) {
+  const auth = await readAuth(gh, cwd);
+  if (auth.kind === "missing")
+    return { kind: "cli_missing" };
+  if (auth.kind !== "ready")
+    return auth;
+  const result = await gh(cwd, ["api", "--hostname", "github.com", "user"]);
+  const account = result.kind === "completed" && result.code === 0 ? readAccountJson(result.stdout) : undefined;
+  return account === undefined ? { kind: "error", message: RECOVERY.account } : { kind: "ready", account };
+}
+function localGitHubAccount2(options) {
+  const binary = options?.gh ?? "gh";
+  const gh = ghCommand(binary);
+  const home = options?.home ?? homedir();
+  let signing;
+  const signingState = async (attempt) => {
+    const start = await attempt.started;
+    if (start.kind !== "code") {
+      const state = await readAccountState(gh, home);
+      return start.kind === "failed" && state.kind === "signed_out" ? { kind: "error", message: RECOVERY.signIn } : state;
+    }
+    return {
+      kind: "signing_in",
+      deviceCode: {
+        ...start.deviceCode,
+        expiresInSeconds: Math.max(0, Math.ceil((attempt.expiresAt - Date.now()) / 1000))
+      }
+    };
+  };
+  return {
+    account: () => signing === undefined ? readAccountState(gh, home) : signingState(signing),
+    async signIn() {
+      if (signing !== undefined)
+        return signingState(signing);
+      const state = await readAccountState(gh, home);
+      if (state.kind !== "signed_out" && state.kind !== "error")
+        return state;
+      if (signing !== undefined)
+        return signingState(signing);
+      const file = await findExecutable2(binary);
+      if (file === null)
+        return { kind: "cli_missing" };
+      const attempt = startSignIn(file, home, () => {
+        if (signing === attempt)
+          signing = undefined;
+      });
+      signing = attempt;
+      return signingState(attempt);
+    },
+    async signOut() {
+      if (signing !== undefined) {
+        signing.cancel();
+        signing = undefined;
+        return readAccountState(gh, home);
+      }
+      const auth = await readAuth(gh, home);
+      if (auth.kind !== "ready")
+        return readAccountState(gh, home);
+      const result = await gh(home, [
+        "auth",
+        "logout",
+        "--hostname",
+        "github.com",
+        "--user",
+        auth.login
+      ]);
+      const state = await readAccountState(gh, home);
+      if (result.kind === "completed" && result.code === 0 || state.kind !== "ready")
+        return state;
+      return { kind: "error", message: RECOVERY.signOut };
+    }
+  };
+}
+function localGitHub2(options) {
+  const gh = ghCommand(options?.gh ?? "gh");
+  const gitBinary = options?.git ?? "git";
+  const git = async (cwd, args) => {
+    const ran = await run2(gitBinary, args, {
+      cwd,
+      env: ENV,
+      timeoutMs: QUERY_TIMEOUT_MS
+    }).catch(() => null);
+    return ran?.code === 0 ? ran.stdout.toString("utf8").trim() : null;
+  };
+  const remotes = async (cwd) => {
+    const listed = await git(cwd, ["remote", "-v"]) ?? "";
+    const found = new Map;
+    for (const line of listed.split(`
+`)) {
+      const [name = "", url = ""] = line.split(/\s+/u);
+      const repository = found.has(name) ? undefined : parseRemote(name, url);
+      if (repository !== undefined)
+        found.set(name, repository);
+    }
+    const rank = (name) => {
+      const position = REMOTE_PRIORITY.findIndex((candidate) => candidate === name);
+      return position < 0 ? REMOTE_PRIORITY.length : position;
+    };
+    return [...found.values()].sort((left, right) => rank(left.remoteName) - rank(right.remoteName));
+  };
+  const readHead = async (cwd, repository, found) => {
+    const branch = await git(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+    if (branch === null || branch === "")
+      return;
+    const tracked = await git(cwd, ["config", "--get", `branch.${branch}.remote`]);
+    const owner = found.find((candidate) => candidate.remoteName === tracked)?.owner;
+    return owner === undefined || owner === repository.owner ? branch : `${owner}:${branch}`;
+  };
+  const readPullRequest = async (cwd, repository, head) => {
+    if (head === undefined)
+      return { kind: "none" };
+    const result = await gh(cwd, [
+      "pr",
+      "view",
+      head,
+      "--repo",
+      `${repository.owner}/${repository.name}`,
+      "--json",
+      PULL_REQUEST_FIELDS
+    ]);
+    if (result.kind === "completed" && result.code === 0) {
+      const pullRequest = readPullRequestJson(result.stdout);
+      return pullRequest === undefined ? { kind: "error", message: RECOVERY.pullRequest } : { kind: "ready", pullRequest };
+    }
+    if (result.kind === "completed" && /no (?:open )?pull requests? found/iu.test(result.stderr))
+      return { kind: "none" };
+    return { kind: "error", message: RECOVERY.pullRequest };
+  };
+  const readState = async (cwd) => {
+    const [found, auth] = await Promise.all([remotes(cwd), readAuth(gh, cwd)]);
+    const repository = found[0];
+    const located = repository === undefined ? {} : { repository };
+    if (auth.kind !== "ready")
+      return { state: { ...located, pullRequest: { kind: "unavailable" } }, auth, head: undefined };
+    if (repository === undefined)
+      return { state: { pullRequest: NO_PULL_REQUEST }, auth, head: undefined };
+    const head = await readHead(cwd, repository, found);
+    return {
+      state: { repository, pullRequest: await readPullRequest(cwd, repository, head) },
+      auth,
+      head
+    };
+  };
+  const createPullRequest = async (cwd, input) => {
+    const { state, auth, head } = await readState(cwd);
+    if (auth.kind === "missing")
+      return { kind: "cli_missing" };
+    if (auth.kind === "signed_out")
+      return { kind: "signed_out" };
+    if (auth.kind === "error")
+      return { kind: "failed", message: auth.message };
+    const { repository, pullRequest } = state;
+    if (repository === undefined)
+      return { kind: "no_remote" };
+    if (head === undefined)
+      return { kind: "detached" };
+    if (pullRequest.kind === "ready" && pullRequest.pullRequest.state === "OPEN")
+      return { kind: "exists", pullRequest: pullRequest.pullRequest };
+    const title = input.title?.trim() ?? "";
+    const body = input.body ?? "";
+    const result = await gh(cwd, [
+      "pr",
+      "create",
+      "--repo",
+      `${repository.owner}/${repository.name}`,
+      "--head",
+      head,
+      ...title === "" ? [] : ["--title", title],
+      ...body === "" ? [] : ["--body-file", "-"],
+      ...title === "" || body === "" ? ["--fill"] : [],
+      ...input.draft === true ? ["--draft"] : []
+    ], { input: body, timeoutMs: CREATE_TIMEOUT_MS });
+    if (result.kind === "missing")
+      return { kind: "cli_missing" };
+    if (result.kind === "completed" && result.code === 0) {
+      const url = result.stdout.split(/\r?\n/u).map((line) => safeUrl(line.trim(), ["github.com"])).find((candidate) => candidate !== undefined);
+      if (url !== undefined)
+        return { kind: "created", url };
+    }
+    if (result.kind === "completed" && /already exists/iu.test(result.stderr)) {
+      const current = await readPullRequest(cwd, repository, head);
+      if (current.kind === "ready")
+        return { kind: "exists", pullRequest: current.pullRequest };
+    }
+    return { kind: "failed", message: RECOVERY.createPullRequest };
+  };
+  return (env) => ({
+    state: async () => (await readState(env.cwd)).state,
+    createPullRequest: (input) => createPullRequest(env.cwd, input)
+  });
+}
+
+export { localGitHubAccount2, localGitHub2 };

package/dist/chunks/canvas-preview-9aqczacs.js

@@ -0,0 +1,73 @@
+// src/local/legacy-trust.ts
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { envelope, trustRef } from "@nyte-ai/core/store";
+import { SdkError } from "@nyte-ai/schema";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var MIGRATION = "host/migrations/legacy-folder-trust-v1";
+var WorkspacesFile = Type.Record(Type.String(), Type.Object({ trusted: Type.Boolean() }));
+var TrustFile = Type.Record(Type.String(), Type.Literal(true));
+async function importLegacyTrust2(connection, home) {
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    if (await connection.refs.get(MIGRATION) !== null)
+      return;
+    const folders = await legacyFolders(home);
+    const updates = [];
+    for (const path of folders) {
+      const target = { kind: "local", path };
+      const name = await trustRef(target);
+      if (await connection.refs.get(name) !== null)
+        continue;
+      updates.push({
+        name,
+        expect: "absent",
+        target: await connection.objects.put(envelope("trust", { target, trusted: true }, Date.now()))
+      });
+    }
+    updates.push({
+      name: MIGRATION,
+      expect: "absent",
+      target: await connection.objects.put({ imported: folders })
+    });
+    if ((await connection.refs.set(updates)).kind === "set")
+      return;
+  }
+  throw new SdkError("unavailable", "Folder trust changed while Nyte was importing it.");
+}
+async function legacyFolders(home) {
+  const [workspaces, nyte, uji] = await Promise.all([
+    readJson(join(home, ".nyte", "workspaces.json")),
+    readJson(join(home, ".nyte", "trust.json")),
+    readJson(join(home, ".uji", "trust.json"))
+  ]);
+  const granted = [
+    ...Value.Check(WorkspacesFile, workspaces) ? Object.entries(workspaces).flatMap(([path, row]) => row.trusted ? [path] : []) : [],
+    ...[nyte, uji].flatMap((file) => Value.Check(TrustFile, file) ? Object.keys(file) : [])
+  ];
+  const ownHome = await realpath(home).catch(() => home);
+  const found = await Promise.all(granted.map(canonicalFolder));
+  return [
+    ...new Set(found.flatMap((path) => path === null || path === ownHome || ownHome.startsWith(`${path}/`) || path === "/" ? [] : [path]))
+  ];
+}
+async function canonicalFolder(path) {
+  if (!isAbsolute(path))
+    return null;
+  const real = await realpath(path).catch(() => null);
+  if (real === null || (await stat(real).catch(() => null))?.isDirectory() !== true)
+    return null;
+  return real.replace(/\/+$/u, "");
+}
+async function readJson(path) {
+  const text = await readFile(path, "utf8").catch(() => null);
+  if (text === null)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+export { importLegacyTrust2 };

package/dist/chunks/canvas-preview-af86jz8t.js

@@ -0,0 +1,141 @@
+import {
+  createIgnores2,
+  watchTree2
+} from "./canvas-preview-mgcx2b2p.js";
+
+// src/local/git-watch.ts
+import { lstat } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+var WATCH_DELAY_MS = 250;
+var POLL_MS = 2000;
+var GIT_STATE = new Set([
+  "HEAD",
+  "index",
+  "packed-refs",
+  "config",
+  "MERGE_HEAD",
+  "CHERRY_PICK_HEAD",
+  "REVERT_HEAD",
+  "rebase-merge",
+  "rebase-apply"
+]);
+function createWatcher2(cwd, read, repository, forget) {
+  const listeners = new Set;
+  let stop = null;
+  let checking = false;
+  let again = false;
+  const check = async () => {
+    if (checking) {
+      again = true;
+      return;
+    }
+    checking = true;
+    do {
+      again = false;
+      const current = await read().catch(() => null);
+      if (current !== null)
+        for (const listener of listeners)
+          listener(current);
+    } while (again && listeners.size > 0);
+    checking = false;
+  };
+  const restart = () => {
+    forget();
+    stop?.();
+    stop = start();
+    check();
+  };
+  const start = () => {
+    const disposers = [];
+    let polling = null;
+    let stopped = false;
+    const unwatched = () => {
+      polling ??= setInterval(() => void check(), POLL_MS);
+    };
+    const watchGitDir = (dir) => {
+      disposers.push(watchTree2(dir, { delay: WATCH_DELAY_MS, poll: null, unwatched }, (paths) => {
+        if ([...paths].some(movesStatus))
+          check();
+      }));
+    };
+    const gitEntry = async () => await lstat(join(cwd, ".git")).catch(() => null) !== null;
+    Promise.all([repository(), gitEntry()]).then(([repo, hadGit]) => {
+      if (stopped)
+        return;
+      const insideGitDir = repo === null ? null : pathInside(cwd, repo.gitDir);
+      const ignores = repo === null ? null : createIgnores2(repo.root);
+      const moved = async (paths) => {
+        let found = "none";
+        for (const path of paths) {
+          if (path === ".git") {
+            if (await gitEntry() !== hadGit)
+              return "repository";
+            continue;
+          }
+          if (repo === null || ignores === null)
+            continue;
+          if (insideGitDir !== null && (path === insideGitDir || path.startsWith(`${insideGitDir}/`))) {
+            if (movesStatus(path.slice(insideGitDir.length + 1)))
+              found = "status";
+            continue;
+          }
+          if (path.endsWith(".gitignore"))
+            ignores.forget(`${repo.prefix}${path}`.split("/").slice(0, -1).join("/"));
+          if (found !== "none")
+            continue;
+          const directory = (await lstat(join(cwd, path)).catch(() => null))?.isDirectory();
+          if (!await ignores.ignored(`${repo.prefix}${path}`, directory === true))
+            found = "status";
+        }
+        return found;
+      };
+      disposers.push(watchTree2(cwd, { delay: WATCH_DELAY_MS, poll: null, unwatched }, (paths) => {
+        moved(paths).then((outcome) => {
+          if (stopped)
+            return;
+          if (outcome === "repository")
+            restart();
+          else if (outcome === "status")
+            check();
+        });
+      }));
+      if (repo === null)
+        return;
+      if (insideGitDir === null)
+        watchGitDir(repo.gitDir);
+      if (repo.commonDir !== repo.gitDir && pathInside(cwd, repo.commonDir) === null)
+        watchGitDir(repo.commonDir);
+    });
+    return () => {
+      stopped = true;
+      if (polling !== null)
+        clearInterval(polling);
+      for (const dispose of disposers)
+        dispose();
+    };
+  };
+  return {
+    subscribe(listener, fail) {
+      listeners.add(listener);
+      stop ??= start();
+      read().then(listener, fail);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          stop?.();
+          stop = null;
+        }
+      };
+    }
+  };
+}
+function movesStatus(path) {
+  const [top = ""] = path.split("/");
+  return path === "" || GIT_STATE.has(top) || path.startsWith("refs/heads/") || path.startsWith("refs/remotes/");
+}
+function pathInside(cwd, dir) {
+  const inside = relative(cwd, dir);
+  return inside.startsWith("..") || isAbsolute(inside) ? null : inside.split(sep).join("/");
+}
+
+export { createWatcher2 };