@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/chunks/canvas-preview-5ekjx6sw.js

@@ -0,0 +1,613 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+import {
+  run2
+} from "./canvas-preview-bxnqt8cd.js";
+import {
+  feed2
+} from "./canvas-preview-yjz0f7n4.js";
+import {
+  PATCH_LIMIT2,
+  textEntry2,
+  readPatches2,
+  lineStat2,
+  parseNumstat2,
+  parseNameStatus2
+} from "./canvas-preview-tjhabynd.js";
+import {
+  createWatcher2
+} from "./canvas-preview-af86jz8t.js";
+import {
+  decodeText2
+} from "./canvas-preview-kn7kvbfj.js";
+
+// src/local/git.ts
+import { lstat, readFile, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { asId, SdkError } from "@nyte-ai/schema";
+import { dev } from "@nyte-ai/core";
+var PATCH_BATCH = 32;
+var LOG_DEFAULT = 50;
+var ENV = {
+  GIT_OPTIONAL_LOCKS: "0",
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_LITERAL_PATHSPECS: "1",
+  LC_ALL: "C"
+};
+var CONFIG = ["-c", "core.quotepath=off", "-c", "color.ui=false", "-c", "diff.noprefix=false"];
+var DIFF = [
+  "--no-color",
+  "--no-ext-diff",
+  "--no-textconv",
+  "--src-prefix=a/",
+  "--dst-prefix=b/",
+  "-M"
+];
+function localGit2(env, options) {
+  const binary = options?.git ?? "git";
+  let emptyTree = null;
+  const git = (cwd, args, extra) => {
+    const started = Date.now();
+    return run2(binary, [...CONFIG, ...args], { cwd, env: ENV, ...extra }).then((ran) => {
+      dev("git", "run", {
+        command: args[0],
+        args: args.length,
+        code: ran.code,
+        ms: Date.now() - started
+      });
+      return ran;
+    });
+  };
+  let located = null;
+  const lookUp = async () => {
+    const ran = await git(env.cwd, [
+      "rev-parse",
+      "--show-toplevel",
+      "--absolute-git-dir",
+      "--show-prefix",
+      "--path-format=absolute",
+      "--git-common-dir"
+    ]);
+    if (ran.code !== 0)
+      return null;
+    const [root, gitDir, prefix = "", commonDir] = ran.stdout.toString("utf8").split(`
+`);
+    return root === undefined || gitDir === undefined ? null : {
+      root: resolve(root),
+      gitDir: resolve(gitDir),
+      commonDir: resolve(commonDir || gitDir),
+      prefix
+    };
+  };
+  const repository = async () => {
+    const pending = located;
+    const known = pending === null ? null : await pending;
+    if (known !== null && located === pending && await exists(join(known.gitDir, "HEAD")))
+      return known;
+    if (located === pending || located === null)
+      located = lookUp();
+    return located;
+  };
+  const forget = () => {
+    located = null;
+  };
+  const required = async () => {
+    const found = await repository();
+    if (found === null)
+      throw new SdkError("unavailable", `${env.cwd} is not in a git repository.`);
+    return found;
+  };
+  const readRepository = async (repo) => {
+    const [porcelain, staged, unstaged] = await Promise.all([
+      git(repo.root, [
+        "status",
+        "--porcelain=v2",
+        "--branch",
+        "-z",
+        "--untracked-files=all",
+        ...within(repo)
+      ]),
+      git(repo.root, ["diff", "--cached", "--numstat", "-z", "-M", ...within(repo)]),
+      git(repo.root, ["diff", "--numstat", "-z", ...within(repo)])
+    ]);
+    if (porcelain.code !== 0)
+      throw new SdkError("unavailable", porcelain.stderr.trim());
+    return readStatus(repo, porcelain.stdout.toString("utf8"), {
+      staged: staged.stdout.toString("utf8"),
+      unstaged: unstaged.stdout.toString("utf8")
+    });
+  };
+  const status = async () => {
+    const repo = await repository();
+    return repo === null ? { kind: "none" } : readRepository(repo);
+  };
+  const empty = (root) => {
+    emptyTree ??= git(root, ["hash-object", "-t", "tree", "--stdin"], { input: "" }).then((ran) => ran.stdout.toString("utf8").trim());
+    return emptyTree;
+  };
+  const resolves = async (root, rev) => {
+    const ran = await git(root, ["rev-parse", "--verify", "-q", `${rev}^{commit}`]);
+    return ran.code === 0 ? ran.stdout.toString("utf8").trim() : null;
+  };
+  const resolveRange = async (root, scope) => {
+    const head = async () => await resolves(root, "HEAD") ?? await empty(root);
+    switch (scope.kind) {
+      case "worktree":
+        return { args: [await head()], untracked: true };
+      case "staged":
+        return { args: ["--cached", await head()], untracked: false };
+      case "unstaged":
+        return { args: [], untracked: true };
+      case "commit": {
+        const commit = await resolves(root, scope.commit);
+        if (commit === null)
+          throw new SdkError("unknown", `No commit ${scope.commit}.`);
+        return {
+          args: [await resolves(root, `${commit}^`) ?? await empty(root), commit],
+          untracked: false
+        };
+      }
+      case "branch": {
+        const base = await git(root, ["merge-base", scope.base, "HEAD"]);
+        if (base.code !== 0)
+          throw new SdkError("unknown", `No merge base between ${scope.base} and HEAD.`);
+        return { args: [base.stdout.toString("utf8").trim(), "HEAD"], untracked: false };
+      }
+    }
+  };
+  const whitespace = (ignore) => ignore === true ? ["--ignore-all-space"] : [];
+  const listChanged = async (repo, scope, current) => {
+    const range = await resolveRange(repo.root, scope);
+    const ran = await git(repo.root, [
+      "diff",
+      "--name-status",
+      "-z",
+      "-M",
+      ...range.args,
+      ...within(repo)
+    ]);
+    if (ran.code !== 0)
+      throw new SdkError("unavailable", ran.stderr.trim());
+    const tracked = parseNameStatus2(ran.stdout.toString("utf8")).map((file) => withPaths(file, (path) => relativeToPrefix(repo, path)));
+    return range.untracked ? [...tracked, ...current.untracked.map((path) => ({ path, status: "untracked" }))] : tracked;
+  };
+  const changesAt = async (repo, scope, current, ignoreWhitespace) => {
+    const range = await resolveRange(repo.root, scope);
+    const [changed, numstat] = await Promise.all([
+      listChanged(repo, scope, current),
+      git(repo.root, [
+        "diff",
+        "--numstat",
+        "-z",
+        "-M",
+        ...whitespace(ignoreWhitespace),
+        ...range.args,
+        ...within(repo)
+      ])
+    ]);
+    const stats = parseNumstat2(numstat.stdout.toString("utf8"));
+    const files = await Promise.all(changed.map(async (file) => ({
+      ...file,
+      stat: file.status === "untracked" ? await untrackedStat(join(repo.root, into(repo, file.path))) : stats.get(into(repo, file.path)) ?? { kind: "unknown" }
+    })));
+    return { revision: current.revision, files };
+  };
+  const patchesAt = async (repo, scope, paths, current, ignoreWhitespace) => {
+    const { root } = repo;
+    const changed = new Map((await listChanged(repo, scope, current)).map((file) => [file.path, file]));
+    const wanted = [...new Set(paths)].flatMap((path) => {
+      const file = changed.get(path);
+      return file === undefined ? [] : [file];
+    });
+    const range = await resolveRange(root, scope);
+    const entries = new Map;
+    const read = async (files, limit) => git(root, [
+      "diff",
+      ...DIFF,
+      "-U3",
+      ...whitespace(ignoreWhitespace),
+      ...range.args,
+      "--",
+      ...files.flatMap((file) => file.from === undefined ? [file.path] : [file.from, file.path])
+    ], { limit });
+    for (let start = 0;start < wanted.length; start += PATCH_BATCH) {
+      const batch = wanted.slice(start, start + PATCH_BATCH);
+      const tracked = batch.flatMap((file) => file.status === "untracked" ? [] : [withPaths(file, (path) => into(repo, path))]);
+      for (const file of batch)
+        if (file.status === "untracked")
+          entries.set(file.path, {
+            ...await untrackedEntry(join(root, into(repo, file.path)), file.path),
+            fresh: true
+          });
+      if (tracked.length === 0)
+        continue;
+      for (const entry of await readPatches2(tracked, read, (file) => sha2562(`${file.path}\x00`))) {
+        const path = relativeToPrefix(repo, entry.path);
+        entries.set(path, { ...entry, path, fresh: true });
+      }
+    }
+    return { revision: current.revision, entries };
+  };
+  const blob = async (root, spec) => {
+    const ran = await git(root, ["cat-file", "blob", spec], { limit: PATCH_LIMIT2 });
+    if (ran.code !== 0 && !ran.truncated)
+      return { kind: "absent" };
+    return decodeSide(ran.stdout, ran.truncated);
+  };
+  const worktree = async (root, path) => {
+    const target = join(root, path);
+    const stats = await stat(target).catch(() => null);
+    if (stats === null || !stats.isFile())
+      return { kind: "absent" };
+    const bytes = await readFile(target).catch(() => null);
+    if (bytes === null)
+      return { kind: "absent" };
+    return decodeSide(bytes.subarray(0, PATCH_LIMIT2), bytes.byteLength > PATCH_LIMIT2);
+  };
+  const write = async (takesIndex, expect, operation, moves = "revision") => {
+    const repo = await required();
+    if (takesIndex && await exists(join(repo.gitDir, "index.lock")))
+      return { kind: "busy", runs: [] };
+    const before = await readRepository(repo);
+    if (expect !== undefined && expect !== before.revision)
+      return { kind: "stale", revision: before.revision };
+    const ran = await operation(repo, before);
+    if (ran === "unchanged")
+      return { kind: "unchanged" };
+    if ("rejected" in ran)
+      return { kind: "rejected", reason: ran.rejected };
+    if (ran.code !== 0) {
+      const output = `${ran.stdout.toString("utf8")}
+${ran.stderr}`;
+      if (/nothing to commit|no changes added to commit|nothing added to commit/.test(output))
+        return { kind: "unchanged" };
+      return {
+        kind: "rejected",
+        reason: ran.stderr.trim() || ran.stdout.toString("utf8").trim() || `git exited with ${ran.code}`
+      };
+    }
+    const after = await readRepository(repo);
+    return moves === "revision" && after.revision === before.revision ? { kind: "unchanged" } : { kind: "applied", revision: after.revision };
+  };
+  const watcher = createWatcher2(env.cwd, status, repository, forget);
+  const follow = (read) => feed2((sink) => {
+    let seen = null;
+    let pending = null;
+    let reading = false;
+    let closed = false;
+    const drain = async () => {
+      if (reading)
+        return;
+      reading = true;
+      while (pending !== null && !closed) {
+        const next = pending;
+        pending = null;
+        try {
+          sink.push(await read(next));
+        } catch (error) {
+          closed = true;
+          sink.fail(error);
+        }
+      }
+      reading = false;
+    };
+    const unsubscribe = watcher.subscribe((current) => {
+      const key = current.kind === "none" ? "none" : current.revision;
+      if (key === seen)
+        return;
+      seen = key;
+      pending = current;
+      drain();
+    }, (error) => sink.fail(error));
+    return () => {
+      closed = true;
+      unsubscribe();
+    };
+  });
+  const inRepo = (read) => async (current) => {
+    if (current.kind === "none")
+      throw new SdkError("unavailable", `${env.cwd} is not in a git repository.`);
+    return read(await required(), current);
+  };
+  return {
+    status,
+    watch: () => follow(async (current) => current),
+    async changes(scope, diff) {
+      const repo = await required();
+      return changesAt(repo, scope, await readRepository(repo), diff?.ignoreWhitespace);
+    },
+    watchChanges: (scope, diff) => follow(inRepo((repo, current) => changesAt(repo, scope, current, diff?.ignoreWhitespace))),
+    patches: (scope, paths, diff) => follow(inRepo((repo, current) => patchesAt(repo, scope, paths, current, diff?.ignoreWhitespace))),
+    async contents(path, scope) {
+      const repo = await required();
+      const current = await readRepository(repo);
+      const root = repo.root;
+      const from = into(repo, (await listChanged(repo, scope, current)).find((file) => file.path === path)?.from ?? path);
+      const at = into(repo, path);
+      const head = current.head === null ? null : "HEAD";
+      switch (scope.kind) {
+        case "worktree":
+          return {
+            path,
+            old: head === null ? { kind: "absent" } : await blob(root, `${head}:${from}`),
+            new: await worktree(root, at)
+          };
+        case "staged":
+          return {
+            path,
+            old: head === null ? { kind: "absent" } : await blob(root, `${head}:${from}`),
+            new: await blob(root, `:${at}`)
+          };
+        case "unstaged":
+          return { path, old: await blob(root, `:${from}`), new: await worktree(root, at) };
+        case "commit": {
+          const parent = await resolves(root, `${scope.commit}^`);
+          return {
+            path,
+            old: parent === null ? { kind: "absent" } : await blob(root, `${parent}:${from}`),
+            new: await blob(root, `${scope.commit}:${at}`)
+          };
+        }
+        case "branch": {
+          const base = (await git(root, ["merge-base", scope.base, "HEAD"])).stdout.toString("utf8").trim();
+          return {
+            path,
+            old: base === "" ? { kind: "absent" } : await blob(root, `${base}:${from}`),
+            new: await blob(root, `HEAD:${at}`)
+          };
+        }
+      }
+    },
+    async log(input) {
+      const repo = await required();
+      const skip = input?.cursor === undefined ? 0 : Number(input.cursor) || 0;
+      const limit = Math.max(1, input?.limit ?? LOG_DEFAULT);
+      const ran = await git(repo.root, [
+        "log",
+        "-z",
+        `--skip=${skip}`,
+        `-n${limit + 1}`,
+        "--format=%H%x1f%P%x1f%an%x1f%ct%x1f%s"
+      ]);
+      if (ran.code !== 0)
+        return { items: [], next: null };
+      const records = ran.stdout.toString("utf8").split("\x00").filter((record) => record !== "");
+      const items = records.slice(0, limit).map((record) => {
+        const [id = "", parents = "", author = "", time = "0", subject = ""] = record.split("\x1F");
+        return {
+          id: asId(id),
+          subject,
+          author,
+          committedAt: Number(time) * 1000,
+          parents: parents === "" ? [] : parents.split(" ").map((parent) => asId(parent))
+        };
+      });
+      const next = records.length > limit ? asId(String(skip + limit)) : null;
+      return { items, next };
+    },
+    async refs() {
+      const repo = await required();
+      const [current, branches, remotes] = await Promise.all([
+        git(repo.root, ["symbolic-ref", "--short", "-q", "HEAD"]),
+        git(repo.root, [
+          "for-each-ref",
+          "--format=%(refname:short)%00%(objectname)%00%(upstream:short)",
+          "refs/heads"
+        ]),
+        git(repo.root, ["remote"])
+      ]);
+      return {
+        current: current.code === 0 ? current.stdout.toString("utf8").trim() : null,
+        branches: lines(branches.stdout).map((line) => {
+          const [name = "", commit = "", upstream = ""] = line.split("\x00");
+          return {
+            name,
+            commit: asId(commit),
+            upstream: upstream === "" ? null : upstream
+          };
+        }),
+        remotes: lines(remotes.stdout)
+      };
+    },
+    async blame(path) {
+      const repo = await required();
+      const ran = await git(repo.root, ["blame", "--porcelain", "--", into(repo, path)]);
+      if (ran.code !== 0)
+        throw new SdkError("unknown", ran.stderr.trim() || `Cannot blame ${path}.`);
+      return parseBlame(path, ran.stdout.toString("utf8"));
+    },
+    stage: (paths, guard) => write(true, guard?.expect, (repo) => git(repo.root, ["add", "-A", "--", ...paths.map((path) => into(repo, path))])),
+    unstage: (paths, guard) => write(true, guard?.expect, (repo, before) => {
+      const inside = paths.map((path) => into(repo, path));
+      return git(repo.root, before.head === null ? ["rm", "--cached", "-r", "-q", "--", ...inside] : ["restore", "--staged", "--", ...inside]);
+    }),
+    discard: (paths, guard) => write(true, guard?.expect, async (repo, before) => {
+      const untracked = new Set(before.untracked);
+      const tracked = paths.filter((path) => !untracked.has(path)).map((path) => into(repo, path));
+      const loose = paths.filter((path) => untracked.has(path)).map((path) => into(repo, path));
+      const restored = tracked.length === 0 ? null : await git(repo.root, ["restore", "--worktree", "--", ...tracked]);
+      if (restored !== null && restored.code !== 0)
+        return restored;
+      return loose.length === 0 ? restored ?? "unchanged" : git(repo.root, ["clean", "-f", "-q", "--", ...loose]);
+    }),
+    commit: (input, guard) => write(true, guard?.expect, async (repo) => {
+      if (input.files === "staged")
+        return git(repo.root, ["commit", "-q", "-m", input.message]);
+      if (input.files === "all")
+        return git(repo.root, ["commit", "-q", "-a", "-m", input.message]);
+      const files = input.files.map((path) => into(repo, path));
+      const added = await git(repo.root, ["add", "-A", "--", ...files]);
+      if (added.code !== 0)
+        return added;
+      return git(repo.root, ["commit", "-q", "-m", input.message, "--", ...files]);
+    }),
+    branch: (input, guard) => write(input.checkout, guard?.expect, (repo) => git(repo.root, input.checkout ? ["switch", "-q", "-c", input.name] : ["branch", input.name]), "always"),
+    push: (input, guard) => write(false, guard?.expect, async (repo, before) => {
+      if (input?.setUpstream === true && before.branch === null)
+        return { rejected: "HEAD is detached; there is no branch to push." };
+      const ran = await git(repo.root, input?.setUpstream === true && before.branch !== null ? ["push", "--porcelain", "--set-upstream", "origin", before.branch] : ["push", "--porcelain"]);
+      const flags = lines(ran.stdout).flatMap((line) => /^[ +\-*!=]\t/.test(line) ? [line[0]] : []);
+      return ran.code === 0 && flags.length > 0 && flags.every((flag) => flag === "=") ? "unchanged" : ran;
+    }, "always")
+  };
+}
+async function readStatus(repo, porcelain, numstat) {
+  const tokens = porcelain.split("\x00");
+  const stagedStats = parseNumstat2(numstat.staged);
+  const unstagedStats = parseNumstat2(numstat.unstaged);
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  const conflicts = [];
+  let head = null;
+  let branch = null;
+  let upstream = null;
+  let ahead = 0;
+  let behind = 0;
+  const change = (path, code, stats, from) => {
+    const stat = stats.get(path);
+    const counts = stat?.kind === "text" ? { added: stat.added, removed: stat.removed } : { added: 0, removed: 0 };
+    const status = code === "A" ? "added" : code === "D" ? "deleted" : code === "R" || code === "C" ? "renamed" : "modified";
+    return from === undefined || status !== "renamed" ? { path, status, ...counts } : { path, status, ...counts, from };
+  };
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index] ?? "";
+    if (token.startsWith("# branch.oid ")) {
+      const oid = token.slice("# branch.oid ".length);
+      head = oid === "(initial)" ? null : oid;
+    } else if (token.startsWith("# branch.head ")) {
+      const name = token.slice("# branch.head ".length);
+      branch = name === "(detached)" ? null : name;
+    } else if (token.startsWith("# branch.upstream "))
+      upstream = token.slice("# branch.upstream ".length);
+    else if (token.startsWith("# branch.ab ")) {
+      const [plus = "+0", minus = "-0"] = token.slice("# branch.ab ".length).split(" ");
+      ahead = Number(plus.slice(1)) || 0;
+      behind = Number(minus.slice(1)) || 0;
+    } else if (token.startsWith("1 ") || token.startsWith("2 ")) {
+      const renamed = token.startsWith("2 ");
+      const fields = splitFields(token, renamed ? 9 : 8);
+      const codes = fields.fields[1] ?? "..";
+      const from = renamed ? tokens[index + 1] : undefined;
+      if (renamed)
+        index += 1;
+      const x = codes[0] ?? ".";
+      const y = codes[1] ?? ".";
+      if (x !== ".")
+        staged.push(change(fields.rest, x, stagedStats, from));
+      if (y !== ".")
+        unstaged.push(change(fields.rest, y, unstagedStats, undefined));
+    } else if (token.startsWith("u "))
+      conflicts.push(splitFields(token, 10).rest);
+    else if (token.startsWith("? "))
+      untracked.push(token.slice(2));
+  }
+  const stamps = await Promise.all([...unstaged.map((file) => file.path), ...untracked].map(async (path) => {
+    const found = await lstat(join(repo.root, path)).catch(() => null);
+    return `${path}:${found === null ? "-" : `${found.size}:${found.mtimeMs}`}`;
+  }));
+  return {
+    kind: "repository",
+    root: repo.root,
+    head: head === null ? null : asId(head),
+    branch,
+    upstream: upstream === null ? null : { name: upstream, ahead, behind },
+    revision: asId(sha2562([porcelain, head ?? "", numstat.staged, numstat.unstaged, ...stamps].join("\x00"))),
+    staged: staged.map((file) => withPaths(file, (path) => relativeToPrefix(repo, path))),
+    unstaged: unstaged.map((file) => withPaths(file, (path) => relativeToPrefix(repo, path))),
+    untracked: untracked.map((path) => relativeToPrefix(repo, path)),
+    conflicts: conflicts.map((path) => relativeToPrefix(repo, path))
+  };
+}
+function into(repo, path) {
+  return `${repo.prefix}${path}`;
+}
+function relativeToPrefix(repo, path) {
+  return path.startsWith(repo.prefix) ? path.slice(repo.prefix.length) : `${"../".repeat(repo.prefix.split("/").length - 1)}${path}`;
+}
+function within(repo) {
+  return repo.prefix === "" ? [] : ["--", repo.prefix];
+}
+function withPaths(file, map) {
+  return file.from === undefined ? { ...file, path: map(file.path) } : { ...file, path: map(file.path), from: map(file.from) };
+}
+function splitFields(token, count) {
+  const parts = token.split(" ");
+  const fields = parts.slice(0, Math.min(count, parts.length - 1));
+  return { fields, rest: parts.slice(fields.length).join(" ") };
+}
+function parseBlame(path, output) {
+  const authors = new Map;
+  const rows = [];
+  let commit = "";
+  let line = 0;
+  for (const text of output.split(`
+`)) {
+    const header = /^([0-9a-f]{40,64}) \d+ (\d+)(?: \d+)?$/.exec(text);
+    if (header !== null) {
+      commit = header[1] ?? "";
+      line = Number(header[2]);
+      if (!authors.has(commit))
+        authors.set(commit, { author: "", at: 0 });
+      continue;
+    }
+    const known = authors.get(commit);
+    if (text.startsWith("author ") && known !== undefined)
+      known.author = text.slice(7);
+    else if (text.startsWith("author-time ") && known !== undefined)
+      known.at = Number(text.slice(12)) * 1000;
+    else if (text.startsWith("\t"))
+      rows.push({
+        line,
+        commit: asId(commit),
+        author: known?.author ?? "",
+        at: known?.at ?? 0
+      });
+  }
+  return { path, lines: rows };
+}
+async function untrackedStat(path) {
+  const stats = await stat(path).catch(() => null);
+  if (stats === null || !stats.isFile() || stats.size > PATCH_LIMIT2)
+    return { kind: "unknown" };
+  const bytes = await readFile(path).catch(() => null);
+  const text = bytes === null ? null : decodeText2(bytes);
+  return text === null ? { kind: "binary" } : lineStat2("", text);
+}
+async function untrackedEntry(target, path) {
+  const stats = await stat(target).catch(() => null);
+  if (stats === null || !stats.isFile())
+    return {
+      path,
+      status: "untracked",
+      digest: "",
+      kind: "failed",
+      reason: `${path} is not a file.`
+    };
+  const bytes = await readFile(target).catch((error) => error instanceof Error ? error.message : String(error));
+  if (typeof bytes === "string")
+    return { path, status: "untracked", digest: "", kind: "failed", reason: bytes };
+  const digest = sha2562(bytes);
+  if (bytes.byteLength > PATCH_LIMIT2)
+    return { path, status: "untracked", digest, kind: "too-large", limit: PATCH_LIMIT2 };
+  const text = decodeText2(bytes);
+  return text === null ? { path, status: "untracked", digest, kind: "binary" } : textEntry2(path, "untracked", null, text);
+}
+function decodeSide(bytes, truncated) {
+  if (bytes.includes(0))
+    return { kind: "binary" };
+  if (truncated)
+    return { kind: "truncated", head: new TextDecoder().decode(bytes) };
+  const text = decodeText2(bytes);
+  return text === null ? { kind: "binary" } : { kind: "text", text };
+}
+function lines(output) {
+  return output.toString("utf8").split(`
+`).filter((line) => line !== "");
+}
+async function exists(path) {
+  return lstat(path).then(() => true, () => false);
+}
+
+export { localGit2 };

package/dist/chunks/canvas-preview-5mex725c.js

@@ -0,0 +1,14 @@
+import {
+  seedSigner2
+} from "./canvas-preview-31w7xm8z.js";
+import {
+  readKeyFile2
+} from "./canvas-preview-wg80rbc2.js";
+
+// src/identity-key.ts
+import { join } from "node:path";
+async function identitySigner2(id, home) {
+  return seedSigner2(id, await readKeyFile2(join(home, ".nyte", "identity.key"), "identity key"));
+}
+
+export { identitySigner2 };