Add files using upload-large-folder tool

mods/diff/hooks/git/probes/branch-base-of/branch-base-of.ts

@@ -0,0 +1,75 @@
+import Argv from '../../argv'
+import type Types from '../../types'
+import { currentBranchOf } from '../current-branch-of'
+import { defaultBranchOf } from '../default-branch-of'
+import { mergeBaseCandidatesOf } from '../merge-base-candidates-of'
+import { missingBaseOf } from '../missing-base-of'
+
+/**
+ * What branch mode compares against, resolved as the built-in panel does:
+ * the merge-base of HEAD and the default branch, HEAD itself, or none.
+ *
+ * `origin/<default>` wins unless the local ref's base descends from it; a
+ * detached HEAD, a `-`-led default name or no common ancestor is `none`;
+ * a failure that may pass (a ref still there, a failed rev-parse) `error`.
+ *
+ * @param run runs git
+ * @returns the base
+ */
+export async function branchBaseOf(
+  run: Types.GitRun,
+): Promise<Types.BranchBase> {
+  const [branch, defaultBranch] = await Promise.all([
+    currentBranchOf(run),
+    defaultBranchOf(run),
+  ])
+
+  const isUnrelated = branch === 'HEAD' || defaultBranch.startsWith('-')
+
+  if (isUnrelated) {
+    return { kind: 'none' }
+  }
+
+  if (branch === defaultBranch) {
+    return { kind: 'head-is-base', baseBranch: defaultBranch }
+  }
+
+  const { candidates, hasNoCommonAncestor } = await mergeBaseCandidatesOf(
+    run,
+    defaultBranch,
+  )
+
+  const [first, second] = candidates
+
+  if (first === undefined) {
+    return hasNoCommonAncestor
+      ? { kind: 'none' }
+      : missingBaseOf(run, defaultBranch)
+  }
+
+  const isLocalBaseNewer =
+    second !== undefined &&
+    second !== first &&
+    (
+      await run([
+        Argv.NO_OPTIONAL_LOCKS,
+        'merge-base',
+        '--is-ancestor',
+        first,
+        second,
+      ])
+    ).exitCode === 0
+
+  const mergeBase = isLocalBaseNewer ? second : first
+  const head = await run([Argv.NO_OPTIONAL_LOCKS, 'rev-parse', 'HEAD'])
+
+  if (head.exitCode !== 0) {
+    return { kind: 'error', reason: 'head_rev_parse_failed' }
+  }
+
+  const isHeadTheBase = head.stdout.trim() === mergeBase
+
+  return isHeadTheBase
+    ? { kind: 'head-is-base', baseBranch: defaultBranch }
+    : { kind: 'merge-base', mergeBase, baseBranch: defaultBranch }
+}

mods/diff/hooks/git/probes/branch-base-of/index.ts

@@ -0,0 +1,3 @@
+export * from './branch-base-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/conventional-default-branches/conventional-default-branches.ts

@@ -0,0 +1,5 @@
+/**
+ * Tried in order as the default branch when `refs/remotes/origin/HEAD` names
+ * none that resolves; past them the guess is `main`, as the engine's is.
+ */
+export const CONVENTIONAL_DEFAULT_BRANCHES = ['main', 'master'] as const

mods/diff/hooks/git/probes/conventional-default-branches/index.ts

@@ -0,0 +1,3 @@
+export * from './conventional-default-branches.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/current-branch-of/current-branch-of.ts

@@ -0,0 +1,21 @@
+import Argv from '../../argv'
+import type Types from '../../types'
+
+/**
+ * The checked-out branch's name, or `HEAD` when detached or unreadable.
+ *
+ * @param run runs git
+ * @returns the branch name
+ */
+export async function currentBranchOf(run: Types.GitRun): Promise<string> {
+  const { exitCode, stdout } = await run([
+    Argv.NO_OPTIONAL_LOCKS,
+    'rev-parse',
+    '--abbrev-ref',
+    'HEAD',
+  ])
+
+  const name = stdout.trim()
+
+  return exitCode === 0 && name !== '' ? name : 'HEAD'
+}

mods/diff/hooks/git/probes/current-branch-of/index.ts

@@ -0,0 +1,3 @@
+export * from './current-branch-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/datings-of/datings-of.ts

@@ -0,0 +1,38 @@
+import type Types from '../../types'
+import { stampIfFile } from '../stamp-if-file'
+
+/**
+ * When each path was last modified against the session's start, dating a
+ * path only when it is a real file under real directories at every level.
+ *
+ * Listings report an entry's own kind, so a symbolic link anywhere on the
+ * path is never listed, descended or stat'ed: session work (the engine
+ * lstats); a path the listing budget never reached is the caller's to place.
+ *
+ * @param context the fetch's stamp probe over the working tree's top, and
+ *   when the session began
+ * @param paths repository-relative paths, `/`-separated as git prints them
+ * @returns each path's Dating
+ */
+export async function datingsOf(
+  context: Types.DatingContext,
+  paths: readonly string[],
+): Promise<ReadonlyMap<string, Types.Dating>> {
+  const { sessionStartMs } = context.deps
+
+  const stamps: readonly Types.Stamp[] = await Promise.all(
+    paths.map(path => stampIfFile(context.stamps, path)),
+  )
+
+  function datingOf(stamp: Types.Stamp): Types.Dating {
+    if (stamp === 'over-budget') {
+      return 'unlisted'
+    }
+
+    const isEarlier = (stamp ?? Number.POSITIVE_INFINITY) < sessionStartMs
+
+    return isEarlier ? 'pre-session' : 'session'
+  }
+
+  return new Map(paths.map((path, at) => [path, datingOf(stamps[at] ?? null)]))
+}

mods/diff/hooks/git/probes/datings-of/index.ts

@@ -0,0 +1,3 @@
+export * from './datings-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/default-branch-of/default-branch-of.ts

@@ -0,0 +1,47 @@
+import Argv from '../../argv'
+import type Types from '../../types'
+import { CONVENTIONAL_DEFAULT_BRANCHES } from '../conventional-default-branches'
+
+/**
+ * The remote's default branch: what `origin/HEAD` names while that ref
+ * resolves, else the first conventional name with a remote ref, else main.
+ *
+ * The engine's own default-branch confidence ladder, over `$.process.run`.
+ *
+ * @param run runs git
+ * @returns the branch name, never empty
+ */
+export async function defaultBranchOf(run: Types.GitRun): Promise<string> {
+  const hasRemoteRef = async (branch: string): Promise<boolean> =>
+    (
+      await run([
+        Argv.NO_OPTIONAL_LOCKS,
+        'show-ref',
+        '--verify',
+        '--quiet',
+        `refs/remotes/origin/${branch}`,
+      ])
+    ).exitCode === 0
+
+  const symref = await run([
+    Argv.NO_OPTIONAL_LOCKS,
+    'symbolic-ref',
+    '--short',
+    'refs/remotes/origin/HEAD',
+  ])
+
+  const named =
+    symref.exitCode === 0 ? symref.stdout.trim().replace(/^origin\//, '') : ''
+
+  if (named !== '' && (await hasRemoteRef(named))) {
+    return named
+  }
+
+  for (const candidate of CONVENTIONAL_DEFAULT_BRANCHES) {
+    if (await hasRemoteRef(candidate)) {
+      return candidate
+    }
+  }
+
+  return 'main'
+}

mods/diff/hooks/git/probes/default-branch-of/index.ts

@@ -0,0 +1,3 @@
+export * from './default-branch-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/dirty-paths-of/dirty-paths-of.ts

@@ -0,0 +1,35 @@
+import Argv from '../../argv'
+import Parse from '../../parse'
+import type Types from '../../types'
+import { STATUS_PATH_OFFSET } from './status-path-offset'
+
+/**
+ * Every path dirty in the working tree right now, tracked changes and
+ * untracked files alike, as `git status -z` lists them; null unread.
+ *
+ * Read once, by the backend's first fetch (it walks the whole tree), so a
+ * later fetch can tell a path that was dirty then from one that turned up
+ * since (GitDeps `baseline`). Renames unpaired: each side is its own path.
+ *
+ * @param run runs git against the pinned repository
+ * @returns the paths, root-relative, or null on a failed or cut listing
+ */
+export async function dirtyPathsOf(
+  run: Types.GitRun,
+): Promise<ReadonlySet<string> | null> {
+  const listing = await run([
+    Argv.NO_OPTIONAL_LOCKS,
+    'status',
+    '--porcelain',
+    '-z',
+    '--untracked-files=all',
+    '--no-renames',
+    '--ignore-submodules=dirty',
+  ])
+
+  const records = listing.stdout.split('\0').filter(record => record !== '')
+
+  return Parse.isWholeAnswer(listing)
+    ? new Set(records.map(record => record.slice(STATUS_PATH_OFFSET)))
+    : null
+}

mods/diff/hooks/git/probes/dirty-paths-of/index.ts

@@ -0,0 +1,4 @@
+export * from './dirty-paths-of.js'
+export * from './status-path-offset'
+
+export * as default from '.'

mods/diff/hooks/git/probes/dirty-paths-of/status-path-offset/index.ts

@@ -0,0 +1,3 @@
+export * from './status-path-offset.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/dirty-paths-of/status-path-offset/status-path-offset.ts

@@ -0,0 +1,5 @@
+/**
+ * Where the path starts in a `status --porcelain -z` record: after the two
+ * status letters and a space.
+ */
+export const STATUS_PATH_OFFSET = 3

mods/diff/hooks/git/probes/head-key-of/head-key-of.ts

@@ -0,0 +1,66 @@
+import Limits from '../../../limits'
+import Argv from '../../argv'
+import type Types from '../../types'
+import { isSafeRefName } from '../is-safe-ref-name'
+import { stampIfFile } from '../stamp-if-file'
+import { stampProbeOf } from '../stamp-probe-of'
+
+/**
+ * A string that changes when HEAD moves: HEAD's text and the timestamps
+ * of HEAD, its ref file and packed-refs, each a listed real file.
+ *
+ * A HEAD that is not a plain file, or a `ref:` outside the safe refname
+ * grammar, is read through `git rev-parse` instead and nothing is stat'ed;
+ * every directory above a stat'ed file was listed as a real directory.
+ *
+ * @param deps git, listings, timestamps, a file read
+ * @param repository the repository's directories
+ * @returns the key for this tick
+ */
+export async function headKeyOf(
+  deps: Types.HeadKeyDeps,
+  repository: Types.Repository,
+): Promise<string> {
+  const own = stampProbeOf(
+    deps,
+    repository.gitDir,
+    Limits.MAX_LISTED_DIRECTORIES,
+  )
+
+  const isShared = repository.commonDir === repository.gitDir
+
+  const common = isShared
+    ? own
+    : stampProbeOf(deps, repository.commonDir, Limits.MAX_LISTED_DIRECTORIES)
+
+  async function viaGit() {
+    const parsed = await deps.run([
+      Argv.NO_OPTIONAL_LOCKS,
+      'rev-parse',
+      '--verify',
+      '--quiet',
+      'HEAD',
+    ])
+
+    return `rev:${parsed.exitCode === 0 ? parsed.stdout.trim() : ''}`
+  }
+
+  if ((await own.walk.kindOf('HEAD')) !== 'file') {
+    return viaGit()
+  }
+
+  const head = await deps.readFile(`${repository.gitDir}/HEAD`).catch(() => '')
+  const ref = head.startsWith('ref: ') ? head.slice('ref: '.length).trim() : ''
+  const isSymbolic = ref !== ''
+
+  const isUnsafeRef = isSymbolic && !isSafeRefName(ref)
+
+  return isUnsafeRef
+    ? viaGit()
+    : [
+        head,
+        await stampIfFile(own, 'HEAD'),
+        isSymbolic ? await stampIfFile(common, ref) : null,
+        await stampIfFile(common, 'packed-refs'),
+      ].join('|')
+}

mods/diff/hooks/git/probes/head-key-of/index.ts

@@ -0,0 +1,3 @@
+export * from './head-key-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/is-absolute-path/index.ts

@@ -0,0 +1,3 @@
+export * from './is-absolute-path.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/is-absolute-path/is-absolute-path.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether a line `rev-parse --path-format=absolute` printed is an absolute
+ * path (POSIX or drive-letter), and so neither relative nor an echoed flag.
+ *
+ * @param line one line of rev-parse output
+ * @returns whether it names an absolute path
+ */
+export const isAbsolutePath = (line: string) =>
+  line.startsWith('/') || /^[A-Za-z]:[\\/]/.test(line)

mods/diff/hooks/git/probes/is-safe-ref-name/index.ts

@@ -0,0 +1,4 @@
+export * from './is-safe-ref-name.js'
+export * from './safe-ref-pattern'
+
+export * as default from '.'

mods/diff/hooks/git/probes/is-safe-ref-name/is-safe-ref-name.ts

@@ -0,0 +1,15 @@
+import { SAFE_REF_PATTERN } from './safe-ref-pattern'
+
+/**
+ * Whether HEAD's `ref:` text names a ref the poll may stat: under `refs/`,
+ * plain characters, no `..`, no component ending `.lock`.
+ *
+ * Git's refname rules, narrowed; anything else is read through git.
+ *
+ * @param ref the text after `ref: `
+ * @returns whether the ref is safe to join under the common directory
+ */
+export const isSafeRefName = (ref: string) =>
+  SAFE_REF_PATTERN.test(ref) &&
+  !ref.includes('..') &&
+  !ref.split('/').some(part => part.endsWith('.lock'))

mods/diff/hooks/git/probes/is-safe-ref-name/safe-ref-pattern/index.ts

@@ -0,0 +1,3 @@
+export * from './safe-ref-pattern.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/is-safe-ref-name/safe-ref-pattern/safe-ref-pattern.ts

@@ -0,0 +1,5 @@
+/**
+ * The refnames the HEAD poll will touch on disk: under `refs/`, of plain
+ * name characters only, `/` between components.
+ */
+export const SAFE_REF_PATTERN = /^refs(?:\/[A-Za-z0-9_@+-][A-Za-z0-9._@+-]*)+$/

mods/diff/hooks/git/probes/is-sha/index.ts

@@ -0,0 +1,3 @@
+export * from './is-sha.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/is-sha/is-sha.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether git printed an object name: 40 or 64 lowercase hex digits, the
+ * only shape a merge-base may take before it reaches a `git diff` argv.
+ *
+ * @param text one trimmed line of git output
+ * @returns whether it is a full object name
+ */
+export const isSha = (text: string) =>
+  /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(text)

mods/diff/hooks/git/probes/kind-walk-of/index.ts

@@ -0,0 +1,3 @@
+export * from './kind-walk-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/kind-walk-of/kind-walk-of.ts

@@ -0,0 +1,72 @@
+import type Types from '../../types'
+
+/**
+ * A KindWalk: each directory is listed once, only after its own entry
+ * read as `dir` in its parent, and only while listings remain.
+ *
+ * Read from the root down, one listing a component: the depth is the
+ * budget's, never the stack's. A symbolic link is never listed or descended
+ * and what lies under it reads as null; the unlisted reads `over-budget`.
+ *
+ * @param entryKindsOf the host's directory listing
+ * @param root the absolute directory the walk's paths are relative to
+ * @param budget how many directories this walk may list
+ * @returns the walk
+ */
+export function kindWalkOf(
+  entryKindsOf: Types.GitDeps['entryKindsOf'],
+  root: string,
+  budget: number,
+): Types.KindWalk {
+  const listings = new Map<
+    string,
+    Promise<ReadonlyMap<string, Types.EntryKind> | null>
+  >()
+
+  function listingOf(directory: string) {
+    const held = listings.get(directory)
+    const isOverBudget = held === undefined && listings.size >= budget
+
+    if (isOverBudget) {
+      return 'over-budget'
+    }
+
+    const listed =
+      held ?? entryKindsOf(directory === '' ? root : `${root}/${directory}`)
+
+    listings.set(directory, listed)
+
+    return listed
+  }
+
+  async function kindOf(path: string): Promise<Types.WalkKind> {
+    const names = path === '' ? [] : path.split('/')
+
+    let directory = ''
+
+    for (const [depth, name] of names.entries()) {
+      const listing = listingOf(directory)
+
+      if (listing === 'over-budget') {
+        return 'over-budget'
+      }
+
+      const kind = (await listing)?.get(name) ?? null
+      const isLeaf = depth === names.length - 1
+
+      if (isLeaf) {
+        return kind
+      }
+
+      if (kind !== 'dir') {
+        return null
+      }
+
+      directory = directory === '' ? name : `${directory}/${name}`
+    }
+
+    return 'dir'
+  }
+
+  return { kindOf }
+}

mods/diff/hooks/git/probes/merge-base-candidates-of/index.ts

@@ -0,0 +1,4 @@
+export * from './merge-base-candidates'
+export * from './merge-base-candidates-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/merge-base-candidates-of/merge-base-candidates-of.ts

@@ -0,0 +1,38 @@
+import Argv from '../../argv'
+import type Types from '../../types'
+import { isSha } from '../is-sha'
+import type { MergeBaseCandidates } from './merge-base-candidates'
+
+/**
+ * The merge-bases of HEAD with `origin/<default>` and with `<default>`, in
+ * that order, each present only when git printed an object name.
+ *
+ * Also whether any call ran and exited 1: no common ancestor, a stable
+ * state rather than a failure.
+ *
+ * @param run runs git
+ * @param defaultBranch the default branch's name
+ * @returns the candidate object names and the no-ancestor flag
+ */
+export async function mergeBaseCandidatesOf(
+  run: Types.GitRun,
+  defaultBranch: string,
+): Promise<MergeBaseCandidates> {
+  const results = [
+    await run([
+      Argv.NO_OPTIONAL_LOCKS,
+      'merge-base',
+      'HEAD',
+      `origin/${defaultBranch}`,
+    ]),
+    await run([Argv.NO_OPTIONAL_LOCKS, 'merge-base', 'HEAD', defaultBranch]),
+  ]
+
+  return {
+    candidates: results
+      .filter(result => result.exitCode === 0)
+      .map(result => result.stdout.trim())
+      .filter(isSha),
+    hasNoCommonAncestor: results.some(result => result.exitCode === 1),
+  }
+}

mods/diff/hooks/git/probes/merge-base-candidates-of/merge-base-candidates/index.ts

@@ -0,0 +1,3 @@
+export type * from './merge-base-candidates.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/merge-base-candidates-of/merge-base-candidates/merge-base-candidates.ts

@@ -0,0 +1,8 @@
+/**
+ * What the two merge-base calls yielded: the object names printed, in
+ * call order, and whether either ran to a no-common-ancestor exit.
+ */
+export type MergeBaseCandidates = {
+  candidates: readonly string[]
+  hasNoCommonAncestor: boolean
+}

mods/diff/hooks/git/probes/missing-base-of/index.ts

@@ -0,0 +1,3 @@
+export * from './missing-base-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/missing-base-of/missing-base-of.ts

@@ -0,0 +1,39 @@
+import Argv from '../../argv'
+import type Types from '../../types'
+
+/**
+ * The verdict for a merge-base that produced nothing: `none` when neither
+ * ref of the default branch exists, else `error`.
+ *
+ * Only a probe that ran and exited non-zero is an authoritative miss; one
+ * that answered 0 or never ran means the merge-base failure may pass.
+ *
+ * @param run runs git
+ * @param defaultBranch the default branch's name
+ * @returns `none` or `error`
+ */
+export async function missingBaseOf(
+  run: Types.GitRun,
+  defaultBranch: string,
+): Promise<Types.BranchBase> {
+  for (const ref of [
+    `refs/remotes/origin/${defaultBranch}`,
+    `refs/heads/${defaultBranch}`,
+  ]) {
+    const { exitCode } = await run([
+      Argv.NO_OPTIONAL_LOCKS,
+      'show-ref',
+      '--verify',
+      '--quiet',
+      ref,
+    ])
+
+    const isPresentOrUnknown = exitCode === 0 || exitCode === -1
+
+    if (isPresentOrUnknown) {
+      return { kind: 'error', reason: 'merge_base_failed' }
+    }
+  }
+
+  return { kind: 'none' }
+}

mods/diff/hooks/git/probes/repository-lines/index.ts

@@ -0,0 +1,3 @@
+export * from './repository-lines.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/repository-lines/repository-lines.ts

@@ -0,0 +1,5 @@
+/**
+ * How many lines the repository probe's `rev-parse` answers when git
+ * understood every option: top level, git directory, common directory.
+ */
+export const REPOSITORY_LINES = 3

mods/diff/hooks/git/probes/repository-of/index.ts

@@ -0,0 +1,3 @@
+export * from './repository-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/repository-of/repository-of.ts

@@ -0,0 +1,38 @@
+import Argv from '../../argv'
+import type Types from '../../types'
+import { isAbsolutePath } from '../is-absolute-path'
+import { REPOSITORY_LINES } from '../repository-lines'
+
+/**
+ * The repository the session's directory is in, read with one `rev-parse`:
+ * working tree top, git directory, common directory, all absolute.
+ *
+ * Exactly three absolute lines or nothing: a git too old for
+ * `--path-format` echoes the flag as a line of its own, and such an answer
+ * pins no repository rather than a wrong one.
+ *
+ * @param run runs git in the session's directory, nothing pinned yet
+ * @returns the three absolute paths, or null outside a working tree
+ */
+export async function repositoryOf(
+  run: Types.GitRun,
+): Promise<Types.Repository | null> {
+  const { exitCode, stdout } = await run([
+    Argv.NO_OPTIONAL_LOCKS,
+    'rev-parse',
+    '--path-format=absolute',
+    '--show-toplevel',
+    '--git-dir',
+    '--git-common-dir',
+  ])
+
+  const lines = stdout.split('\n').filter(line => line !== '')
+  const [toplevel = '', gitDir = '', commonDir = ''] = lines
+
+  const isResolved =
+    exitCode === 0 &&
+    lines.length === REPOSITORY_LINES &&
+    lines.every(isAbsolutePath)
+
+  return isResolved ? { toplevel, gitDir, commonDir } : null
+}

mods/diff/hooks/git/probes/stamp-if-file/index.ts

@@ -0,0 +1,3 @@
+export * from './stamp-if-file.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/stamp-if-file/stamp-if-file.ts

@@ -0,0 +1,29 @@
+import type Types from '../../types'
+
+/**
+ * A path's modification time when the walk shows it as a real entry of the
+ * wanted kind under real directories; otherwise nothing is stat'ed.
+ *
+ * A path git printed with a trailing `/` (an untracked directory, a nested
+ * repository) names a directory and is dated as one.
+ *
+ * @param probe the walk over the base directory and the timestamp probe
+ * @param path the path relative to the walk's root
+ * @returns the timestamp, `over-budget`, or null
+ */
+export async function stampIfFile(
+  probe: Types.StampProbe,
+  path: string,
+): Promise<Types.Stamp> {
+  const isDirectory = path.endsWith('/')
+  const entry = isDirectory ? path.slice(0, -1) : path
+  const kind = await probe.walk.kindOf(entry)
+  const isUnlisted = kind === 'over-budget'
+  const isWanted = kind === (isDirectory ? 'dir' : 'file')
+
+  return isUnlisted
+    ? 'over-budget'
+    : isWanted
+      ? probe.mtimeOf(`${probe.base}/${entry}`)
+      : null
+}

mods/diff/hooks/git/probes/stamp-probe-of/index.ts

@@ -0,0 +1,3 @@
+export * from './stamp-probe-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/stamp-probe-of/stamp-probe-of.ts

@@ -0,0 +1,21 @@
+import type Types from '../../types'
+import { kindWalkOf } from '../kind-walk-of'
+
+/**
+ * A StampProbe rooted at a directory: a fresh, bounded kind walk over it
+ * and the host's timestamp probe.
+ *
+ * @param deps lists a directory, reads a timestamp
+ * @param base the absolute directory the probe's paths are under
+ * @param budget how many directories the walk may list
+ * @returns the probe
+ */
+export const stampProbeOf = (
+  deps: Pick<Types.GitDeps, 'entryKindsOf' | 'mtimeOf'>,
+  base: string,
+  budget: number,
+): Types.StampProbe => ({
+  walk: kindWalkOf(deps.entryKindsOf, base, budget),
+  base,
+  mtimeOf: deps.mtimeOf,
+})

mods/diff/hooks/git/probes/transient-state-files/index.ts

@@ -0,0 +1,3 @@
+export * from './transient-state-files.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/transient-state-files/transient-state-files.ts

@@ -0,0 +1,10 @@
+/**
+ * The git-directory files that mean a merge, rebase, cherry-pick or revert
+ * is under way: the working tree then holds incoming changes, unread.
+ */
+export const TRANSIENT_STATE_FILES = [
+  'MERGE_HEAD',
+  'REBASE_HEAD',
+  'CHERRY_PICK_HEAD',
+  'REVERT_HEAD',
+] as const

mods/diff/hooks/git/probes/untracked-files/index.ts

@@ -0,0 +1,3 @@
+export * from './untracked-files.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/untracked-files/untracked-files.ts

@@ -0,0 +1,40 @@
+import Argv from '../../argv'
+import Parse from '../../parse'
+import type Types from '../../types'
+import type { UntrackedPlace } from '../untracked-place'
+import { untrackedRowsOf } from '../untracked-rows-of'
+
+/**
+ * The untracked, unignored files as 0/0 rows (untrackedRowsOf), listed
+ * with `ls-files -z`. A listing not given whole: no answer.
+ *
+ * @param context the fetch: its pinned git, stamp probe and session start
+ * @param place the free row slots and the scope
+ * @returns the rows to merge after the tracked ones, or null when the
+ * `-z` listing failed, timed out or was cut
+ */
+export async function untrackedFiles(
+  context: Pick<Types.FetchContext, 'run'> & Types.DatingContext,
+  place: UntrackedPlace,
+): Promise<readonly Types.FileStat[] | null> {
+  if (place.slots <= 0) {
+    return []
+  }
+
+  const listing = await context.run([
+    Argv.NO_OPTIONAL_LOCKS,
+    'ls-files',
+    '-z',
+    '--others',
+    '--exclude-standard',
+    '--full-name',
+  ])
+
+  return Parse.isWholeAnswer(listing)
+    ? untrackedRowsOf(
+        context,
+        listing.stdout.split('\0').filter(path => path !== ''),
+        place,
+      )
+    : null
+}

mods/diff/hooks/git/probes/untracked-place/index.ts

@@ -0,0 +1,3 @@
+export type * from './untracked-place.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/untracked-place/untracked-place.ts

@@ -0,0 +1,10 @@
+import type Types from '../../types'
+
+/**
+ * How much untrackedFiles may keep: the row slots left under MAX_FILES, and
+ * which files count.
+ */
+export type UntrackedPlace = {
+  slots: number
+  scope: Types.UntrackedScope
+}

mods/diff/hooks/git/probes/untracked-rows-of/index.ts

@@ -0,0 +1,3 @@
+export * from './untracked-rows-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/untracked-rows-of/untracked-rows-of.ts

@@ -0,0 +1,59 @@
+import Limits from '../../../limits'
+import type Types from '../../types'
+import { datingsOf } from '../datings-of'
+import type { UntrackedPlace } from '../untracked-place'
+import { wasDirtyAtStart } from '../was-dirty-at-start'
+
+/**
+ * Listed untracked paths as 0/0 rows: the session's own first, then,
+ * when the scope asks, the tagged pre-session ones, up to the slots.
+ *
+ * At most MAX_UNTRACKED_PROBES are dated; a file past that or past the
+ * listing budget reads as pre-session, an undatable one or one that turned
+ * up since the start (wasDirtyAtStart) as the session's (the built-in's).
+ *
+ * @param context the fetch's stamp probe and session start
+ * @param paths the untracked paths, root-relative, as the lister printed them
+ * @param place the free row slots and the scope
+ * @returns the rows to merge after the tracked ones
+ */
+export async function untrackedRowsOf(
+  context: Types.DatingContext,
+  paths: readonly string[],
+  place: UntrackedPlace,
+): Promise<readonly Types.FileStat[]> {
+  const probedPaths = paths.slice(0, Limits.MAX_UNTRACKED_PROBES)
+  const datings = await datingsOf(context, probedPaths)
+
+  const isPreSessionOf = (path: string, dating: Types.Dating | undefined) =>
+    dating === 'unlisted' ||
+    (dating === 'pre-session' && wasDirtyAtStart(context, path))
+
+  const probed = probedPaths.map(path => ({
+    path,
+    isPreSession: isPreSessionOf(path, datings.get(path)),
+  }))
+
+  const isWithPreSession = place.scope === 'with-pre-session'
+
+  const earlier = isWithPreSession
+    ? [
+        ...probed.filter(file => file.isPreSession),
+        ...paths
+          .slice(Limits.MAX_UNTRACKED_PROBES)
+          .map(path => ({ path, isPreSession: true })),
+      ]
+    : []
+
+  const ordered = [...probed.filter(file => !file.isPreSession), ...earlier]
+
+  return ordered.slice(0, place.slots).map(file => ({
+    path: file.path,
+    renamedFrom: null,
+    added: 0,
+    removed: 0,
+    isBinary: false,
+    isUntracked: true,
+    isPreSession: file.isPreSession,
+  }))
+}

mods/diff/hooks/git/probes/was-dirty-at-start/index.ts

@@ -0,0 +1,3 @@
+export * from './was-dirty-at-start.js'
+
+export * as default from '.'

mods/diff/hooks/git/probes/was-dirty-at-start/was-dirty-at-start.ts

@@ -0,0 +1,16 @@
+import type Types from '../../types'
+
+/**
+ * Whether a path may predate the session at all: it was dirty when the
+ * baseline was read (the first fetch), or nothing says otherwise (none was).
+ *
+ * A path missing from the baseline turned up since, so its old timestamp
+ * (a rename keeps the file's, a move keeps the source's) does not date it,
+ * as the built-in's change-time check does not let it.
+ *
+ * @param context the fetch's dating context
+ * @param path the root-relative path
+ * @returns false only when a baseline exists and lacks the path
+ */
+export const wasDirtyAtStart = (context: Types.DatingContext, path: string) =>
+  context.deps.baseline?.has(path) ?? true