dsh-plugin-wsl-env 0.7.5 → 0.9.0

package/lib/fsio-text.d.ts

@@ -0,0 +1,115 @@
+/**
+ * The text mechanics of the distro-side filesystem, replicated from
+ * `@deepseek-ai/dsh-fs-local`'s fsio module so `lib/fsio-agent.js` can run the
+ * same orchestration without importing the peer.
+ *
+ * Everything here is pure and validation-only: no I/O, no Node fs. The
+ * replication is deliberate and temporary — once the upstream package exports
+ * its fsio module (the export is proposed in docs/UPSTREAM-FSIO-EXPORT.md),
+ * these functions are deleted in favour of the imported originals. Until then
+ * they are kept byte-for-byte faithful, including error messages, because the
+ * tool layer matches on both the `code` and what the model reads — and that
+ * faithfulness is verified, not assumed: docs/PEER-PARITY.md records the
+ * function-by-function comparison against the pinned peer's shipped code.
+ *
+ * This is a TypeScript source built to `lib/fsio-text.js`; edit THIS file and
+ * run `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
+ * @module dsh-plugin-wsl/fsio-text
+ */
+/** The byte prefix scanned for a NUL before a read is declared binary. */
+export declare const BINARY_SAMPLE_BYTES = 8192;
+/**
+ * A coded filesystem failure. `code` carries the `FS_*` token the provider
+ * maps onto the peer's `FsError`; the class stays local so this module imports
+ * no peer and stays unit-testable in a bare checkout.
+ */
+export declare class FsCodedError extends Error {
+    /** The `FS_*` token, for callers that must not match on the message. */
+    code: string;
+    /**
+     * @param message - human-readable, model-facing.
+     * @param code - the `FS_*` token.
+     * @param cause - the underlying failure, when there is one.
+     */
+    constructor(message: string, code: string, cause?: Error);
+}
+/**
+ * The structured not-text failure.
+ *
+ * @param verb - the operation being attempted, for the message.
+ * @param displayPath - the caller-facing path.
+ * @returns the refusal every decode failure raises.
+ */
+export declare function notTextError(verb: string, displayPath: string): FsCodedError;
+/**
+ * Decode a buffer as strict UTF-8, rejecting invalid byte sequences the way
+ * the peer's fsio does.
+ *
+ * @param buffer - the bytes to decode.
+ * @param verb - the operation being attempted, for the message.
+ * @param displayPath - the caller-facing path.
+ * @returns the decoded text.
+ * @throws {FsCodedError} with `FS_NOT_TEXT` on invalid UTF-8.
+ */
+export declare function decodeUtf8(buffer: Buffer, verb: string, displayPath: string): string;
+/**
+ * Decode one streamed chunk, carrying multi-byte sequences across chunks.
+ *
+ * @param decoder - the streaming decoder owned by the caller.
+ * @param chunk - the next chunk, or `undefined` to flush.
+ * @param verb - the operation being attempted, for the message.
+ * @param displayPath - the caller-facing path.
+ * @returns the decoded text.
+ * @throws {FsCodedError} with `FS_NOT_TEXT` on invalid UTF-8.
+ */
+export declare function decodeUtf8Stream(decoder: import("node:util").TextDecoder, chunk: Buffer | undefined, verb: string, displayPath: string): string;
+/**
+ * Collapse CRLF to LF — the canonical in-memory form every edit/diff basis uses.
+ *
+ * @param content - the text to normalize.
+ * @returns the text with every CRLF collapsed to LF.
+ */
+export declare function normalizeLineEndings(content: string): string;
+/**
+ * The line-ending style a file was read with.
+ *
+ * @param raw - decoded text in whatever line-ending style the file had.
+ * @returns the dominant style of the first 4096 bytes.
+ */
+export declare function detectLineEndings(raw: string): "LF" | "CRLF";
+/**
+ * Convert LF-normalized content back to the style detected at read time.
+ *
+ * @param content - the LF-normalized (edited) text.
+ * @param lineEndings - the original file's style.
+ * @returns the content in the original file's line-ending style.
+ */
+export declare function restoreLineEndings(content: string, lineEndings: "LF" | "CRLF"): string;
+/**
+ * Apply a literal replacement to LF-normalized content — the peer's edit
+ * algorithm, replicated: CRLF inside the needle is normalized before
+ * matching, an empty needle is refused, and a multi-match needle is ambiguous
+ * unless `replaceAll` is set.
+ *
+ * @param content - the current file content, already LF-normalized.
+ * @param oldString - literal text to find.
+ * @param newString - literal replacement text.
+ * @param replaceAll - replace every match instead of requiring one.
+ * @param displayPath - the caller-facing path for error messages.
+ * @returns the edited text and count.
+ * @throws {FsCodedError} with `FS_EDIT_NOT_FOUND` or `FS_AMBIGUOUS_EDIT`.
+ */
+export declare function applyLiteralEdit(content: string, oldString: string, newString: string, replaceAll: boolean | undefined, displayPath: string): {
+    content: string;
+    replacements: number;
+};
+/**
+ * Abort boundary mirroring the peer's `throwIfAborted`.
+ *
+ * @param signal - the caller's signal.
+ * @param verb - the operation being attempted, for the message.
+ * @throws {FsCodedError} with `FS_ABORTED` when the signal is done.
+ */
+export declare function throwIfAborted(signal: AbortSignal | undefined, verb: string): void;

package/lib/fsio-text.js

@@ -12,142 +12,162 @@
  * faithfulness is verified, not assumed: docs/PEER-PARITY.md records the
  * function-by-function comparison against the pinned peer's shipped code.
  *
+ * This is a TypeScript source built to `lib/fsio-text.js`; edit THIS file and
+ * run `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
  * @module dsh-plugin-wsl/fsio-text
  */
-
 /** The byte prefix scanned for a NUL before a read is declared binary. */
 export const BINARY_SAMPLE_BYTES = 8192;
-
 /**
  * A coded filesystem failure. `code` carries the `FS_*` token the provider
  * maps onto the peer's `FsError`; the class stays local so this module imports
  * no peer and stays unit-testable in a bare checkout.
  */
 export class FsCodedError extends Error {
-  /**
-   * @param {string} message - human-readable, model-facing.
-   * @param {string} code - the `FS_*` token.
-   * @param {Error} [cause] - the underlying failure, when there is one.
-   */
-  constructor(message, code, cause) {
-    super(message, cause === undefined ? {} : { cause });
-    this.name = "FsCodedError";
-    this.code = code;
-  }
+    /**
+     * @param message - human-readable, model-facing.
+     * @param code - the `FS_*` token.
+     * @param cause - the underlying failure, when there is one.
+     */
+    constructor(message, code, cause) {
+        super(message, cause === undefined ? {} : { cause });
+        this.name = "FsCodedError";
+        this.code = code;
+    }
 }
-
 /**
- * @param {string} verb - the operation being attempted, for the message.
- * @param {string} displayPath - the caller-facing path.
- * @returns {FsCodedError} the structured not-text failure.
+ * The structured not-text failure.
+ *
+ * @param verb - the operation being attempted, for the message.
+ * @param displayPath - the caller-facing path.
+ * @returns the refusal every decode failure raises.
  */
 export function notTextError(verb, displayPath) {
-  return new FsCodedError(`cannot ${verb} "${displayPath}": invalid UTF-8 text`, "FS_NOT_TEXT");
+    return new FsCodedError(`cannot ${verb} "${displayPath}": invalid UTF-8 text`, "FS_NOT_TEXT");
 }
-
 /**
  * Decode a buffer as strict UTF-8, rejecting invalid byte sequences the way
  * the peer's fsio does.
- * @param {Buffer} buffer - the bytes to decode.
- * @param {string} verb - the operation being attempted, for the message.
- * @param {string} displayPath - the caller-facing path.
- * @returns {string} the decoded text.
+ *
+ * @param buffer - the bytes to decode.
+ * @param verb - the operation being attempted, for the message.
+ * @param displayPath - the caller-facing path.
+ * @returns the decoded text.
  * @throws {FsCodedError} with `FS_NOT_TEXT` on invalid UTF-8.
  */
 export function decodeUtf8(buffer, verb, displayPath) {
-  try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
-  } catch (error) {
-    if (!(error instanceof TypeError)) throw error;
-    throw notTextError(verb, displayPath);
-  }
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    }
+    catch (error) {
+        if (!(error instanceof TypeError))
+            throw error;
+        throw notTextError(verb, displayPath);
+    }
 }
-
 /**
  * Decode one streamed chunk, carrying multi-byte sequences across chunks.
- * @param {TextDecoder} decoder - the streaming decoder owned by the caller.
- * @param {Buffer|undefined} chunk - the next chunk, or `undefined` to flush.
- * @param {string} verb - the operation being attempted, for the message.
- * @param {string} displayPath - the caller-facing path.
- * @returns {string} the decoded text.
+ *
+ * @param decoder - the streaming decoder owned by the caller.
+ * @param chunk - the next chunk, or `undefined` to flush.
+ * @param verb - the operation being attempted, for the message.
+ * @param displayPath - the caller-facing path.
+ * @returns the decoded text.
  * @throws {FsCodedError} with `FS_NOT_TEXT` on invalid UTF-8.
  */
 export function decodeUtf8Stream(decoder, chunk, verb, displayPath) {
-  try {
-    return chunk ? decoder.decode(chunk, { stream: true }) : decoder.decode();
-  } catch (error) {
-    if (!(error instanceof TypeError)) throw error;
-    throw notTextError(verb, displayPath);
-  }
+    try {
+        return chunk ? decoder.decode(chunk, { stream: true }) : decoder.decode();
+    }
+    catch (error) {
+        if (!(error instanceof TypeError))
+            throw error;
+        throw notTextError(verb, displayPath);
+    }
 }
-
-/** Collapse CRLF to LF — the canonical in-memory form every edit/diff basis uses. */
+/**
+ * Collapse CRLF to LF — the canonical in-memory form every edit/diff basis uses.
+ *
+ * @param content - the text to normalize.
+ * @returns the text with every CRLF collapsed to LF.
+ */
 export function normalizeLineEndings(content) {
-  return content.replaceAll("\r\n", "\n");
+    return content.replaceAll("\r\n", "\n");
 }
-
-/** @param {string} raw - decoded text in whatever line-ending style the file had. */
+/**
+ * The line-ending style a file was read with.
+ *
+ * @param raw - decoded text in whatever line-ending style the file had.
+ * @returns the dominant style of the first 4096 bytes.
+ */
 export function detectLineEndings(raw) {
-  const sample = raw.slice(0, 4096);
-  const crlfCount = sample.split("\r\n").length - 1;
-  return crlfCount > sample.split("\n").length - 1 - crlfCount ? "CRLF" : "LF";
+    const sample = raw.slice(0, 4096);
+    const crlfCount = sample.split("\r\n").length - 1;
+    return crlfCount > sample.split("\n").length - 1 - crlfCount ? "CRLF" : "LF";
 }
-
 /**
  * Convert LF-normalized content back to the style detected at read time.
- * @param {string} content - the LF-normalized (edited) text.
- * @param {"LF"|"CRLF"} lineEndings - the original file's style.
- * @returns {string} the content in the original file's line-ending style.
+ *
+ * @param content - the LF-normalized (edited) text.
+ * @param lineEndings - the original file's style.
+ * @returns the content in the original file's line-ending style.
  */
 export function restoreLineEndings(content, lineEndings) {
-  if (lineEndings === "LF") return content;
-  return normalizeLineEndings(content).replaceAll("\n", "\r\n");
+    if (lineEndings === "LF")
+        return content;
+    return normalizeLineEndings(content).replaceAll("\n", "\r\n");
 }
-
+/**
+ * Count how many times `search` appears in `content`.
+ *
+ * @param content - the haystack.
+ * @param search - the needle.
+ * @returns the occurrence count.
+ */
 function countOccurrences(content, search) {
-  return content.split(search).length - 1;
+    return content.split(search).length - 1;
 }
-
 /**
  * Apply a literal replacement to LF-normalized content — the peer's edit
  * algorithm, replicated: CRLF inside the needle is normalized before
  * matching, an empty needle is refused, and a multi-match needle is ambiguous
  * unless `replaceAll` is set.
  *
- * @param {string} content - the current file content, already LF-normalized.
- * @param {string} oldString - literal text to find.
- * @param {string} newString - literal replacement text.
- * @param {boolean} replaceAll - replace every match instead of requiring one.
- * @param {string} displayPath - the caller-facing path for error messages.
- * @returns {{content: string, replacements: number}} the edited text and count.
+ * @param content - the current file content, already LF-normalized.
+ * @param oldString - literal text to find.
+ * @param newString - literal replacement text.
+ * @param replaceAll - replace every match instead of requiring one.
+ * @param displayPath - the caller-facing path for error messages.
+ * @returns the edited text and count.
  * @throws {FsCodedError} with `FS_EDIT_NOT_FOUND` or `FS_AMBIGUOUS_EDIT`.
  */
 export function applyLiteralEdit(content, oldString, newString, replaceAll, displayPath) {
-  const oldNorm = normalizeLineEndings(oldString);
-  if (oldNorm.length === 0) throw new FsCodedError("old_string must be a non-empty string", "FS_EDIT_NOT_FOUND");
-  const newNorm = normalizeLineEndings(newString);
-  const replacements = countOccurrences(content, oldNorm);
-  if (replacements === 0) throw new FsCodedError(`old_string was not found in "${displayPath}"`, "FS_EDIT_NOT_FOUND");
-  if (!replaceAll && replacements > 1) {
-    throw new FsCodedError(
-      `old_string matched ${replacements} times in "${displayPath}"; provide a more specific old_string or set replace_all to true`,
-      "FS_AMBIGUOUS_EDIT",
-    );
-  }
-  return {
-    content: content.split(oldNorm).join(newNorm),
-    replacements,
-  };
+    const oldNorm = normalizeLineEndings(oldString);
+    if (oldNorm.length === 0)
+        throw new FsCodedError("old_string must be a non-empty string", "FS_EDIT_NOT_FOUND");
+    const newNorm = normalizeLineEndings(newString);
+    const replacements = countOccurrences(content, oldNorm);
+    if (replacements === 0)
+        throw new FsCodedError(`old_string was not found in "${displayPath}"`, "FS_EDIT_NOT_FOUND");
+    if (!replaceAll && replacements > 1) {
+        throw new FsCodedError(`old_string matched ${replacements} times in "${displayPath}"; provide a more specific old_string or set replace_all to true`, "FS_AMBIGUOUS_EDIT");
+    }
+    return {
+        content: content.split(oldNorm).join(newNorm),
+        replacements,
+    };
 }
-
 /**
  * Abort boundary mirroring the peer's `throwIfAborted`.
- * @param {AbortSignal|undefined} signal - the caller's signal.
- * @param {string} verb - the operation being attempted, for the message.
+ *
+ * @param signal - the caller's signal.
+ * @param verb - the operation being attempted, for the message.
  * @throws {FsCodedError} with `FS_ABORTED` when the signal is done.
  */
 export function throwIfAborted(signal, verb) {
-  if (signal?.aborted) {
-    throw new FsCodedError(`${verb} aborted`, "FS_ABORTED", signal.reason instanceof Error ? signal.reason : undefined);
-  }
+    if (signal?.aborted) {
+        throw new FsCodedError(`${verb} aborted`, "FS_ABORTED", signal.reason instanceof Error ? signal.reason : undefined);
+    }
 }

package/lib/git-route.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Which git spawns belong inside the distro, and the `wsl.exe` argv they
+ * become there.
+ *
+ * `workspace-changes` snapshots a workspace's git state by spawning the host
+ * git through `ctx.subprocess` with the workspace as the working directory.
+ * On a distro workspace that spawn runs Windows git against the 9P share —
+ * the same slow direction as the search path, and the snapshot's
+ * `git add --all` is a full work-tree scan, the most metadata-heavy operation
+ * there is. The interception point is the same `spawn` override; the decision
+ * lives here, pure and unit-testable, mirroring `search-route.js`.
+ *
+ * ## What is routed, and what deliberately is not
+ *
+ * A spawn is routed only when the working directory names the distro (a
+ * `\\wsl.localhost\<distro>` UNC) and the argv carries none of the discovery
+ * flags (`--show-toplevel`, `--absolute-git-dir`, `--git-path`). Those three
+ * print **absolute paths**, which `workspace-changes` resolves against the
+ * UNC workspace (`git.ts` `resolve(cwd, line)`) — a distro git would answer
+ * in Linux paths and corrupt that resolution. Host git answers in UNC form,
+ * which is exactly what the caller wants, and the discovery call is one
+ * cheap command rather than a work-tree scan. Everything else — `add`,
+ * `write-tree`, `ls-tree`, `cat-file`, `diff-tree`, `ls-files`,
+ * `check-ignore` — is safe to route: snapshot calls run in an environment
+ * fully isolated from the user's git state (`GIT_INDEX_FILE` /
+ * `GIT_OBJECT_DIRECTORY` / `GIT_ALTERNATE_OBJECT_DIRECTORIES` pointing at the
+ * tool's private scratch), so the distro git mutates scratch, never the
+ * repository.
+ *
+ * ## Environment translation
+ *
+ * The routed spawn must forward the caller's `GIT_*` environment into the
+ * distro, and its values are paths in Windows form (`\\wsl.localhost\...`
+ * identities and drive-letter scratch dirs). `translateGitEnv` rewrites those
+ * two shapes into distro paths with the same pure translations the fs seam
+ * uses, forwards every other value verbatim (`GIT_CONFIG_COUNT=0` and
+ * friends), and returns the names that must ride `WSLENV`. One documented
+ * limit: a colon-separated multi-directory value (none of the current
+ * callers set one) passes through untranslated.
+ *
+ * This is a TypeScript source built to `lib/git-route.js`; edit THIS file and
+ * run `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
+ * @module dsh-plugin-wsl/git-route
+ */
+/**
+ * Whether a spawn's program is git.
+ *
+ * @param program - the spawn's `argv[0]`.
+ * @returns true when the spawn is a git launch.
+ */
+export declare function isGitProgram(program: unknown): boolean;
+/**
+ * Translate one `GIT_*` value into the distro's coordinate system.
+ *
+ * UNC identities (`\\wsl.localhost\<distro>\...`) map onto their Linux paths;
+ * drive-letter paths map onto their `/mnt/<drive>` mounts; anything else is
+ * not a path we can name and passes through verbatim.
+ *
+ * @param value - the env value.
+ * @returns the distro-side spelling of the value.
+ */
+export declare function translateGitEnvValue(value: string | undefined): string | undefined;
+/**
+ * Translate a git spawn's environment for the distro and name the keys that
+ * must ride `WSLENV`.
+ *
+ * @param env - the spawn's environment, or undefined.
+ * @returns the environment to forward (every key, path-shaped values
+ *   translated) and the `WSLENV` names.
+ */
+export declare function translateGitEnv(env: Record<string, string | undefined> | undefined): {
+    env: Record<string, string | undefined>;
+    wslenv: string[];
+};
+/**
+ * The distro-side rewrite of one git spawn, when it belongs in the distro.
+ *
+ * `gitArgv` is the distro command itself; `wslArgv` is the same command
+ * wrapped for a one-shot `wsl.exe --exec` launch — git snapshot operations
+ * are not latency-sensitive, so the routing stays on the simple transport
+ * and does not need the resident agent. `wsl.exe` itself must start in a
+ * Windows directory, so the caller supplies its own host cwd.
+ *
+ * @param object - the spawn's inputs.
+ * @returns the rewrite, or undefined when the spawn is not a routable distro
+ *   git launch (non-git programs, host directories, and the absolute-output
+ *   discovery flags all keep the shipped spawn).
+ */
+export declare function gitSpawnRewrite({ argv, cwd, wslPath }: {
+    argv?: readonly string[];
+    cwd?: string;
+    wslPath: string;
+}): {
+    distro: string;
+    linuxCwd: string;
+    gitArgv: string[];
+    wslArgv: string[];
+} | undefined;

package/lib/git-route.js

@@ -38,38 +38,39 @@
  * limit: a colon-separated multi-directory value (none of the current
  * callers set one) passes through untranslated.
  *
+ * This is a TypeScript source built to `lib/git-route.js`; edit THIS file and
+ * run `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
  * @module dsh-plugin-wsl/git-route
  */
-
 import { isWslUnc, uncToPosix, windowsToLinuxMount } from "./paths.js";
-
 /** The one program this rewrite passes through to the distro. */
 const GIT_PROGRAM = "git";
-
 /** Discovery flags print absolute paths — host git keeps that contract. */
 const DISCOVERY_FLAGS = ["--show-toplevel", "--absolute-git-dir", "--git-path"];
-
 /**
  * Whether a spawn's program is git.
- * @param unknown - the spawn's `argv[0]`.
+ *
+ * @param program - the spawn's `argv[0]`.
  * @returns true when the spawn is a git launch.
  */
 export function isGitProgram(program) {
-  if (typeof program !== "string" || program.length === 0) return false;
-  const base = program.slice(Math.max(program.lastIndexOf("/"), program.lastIndexOf("\\")) + 1);
-  return base.toLowerCase().replace(/\.exe$/u, "") === GIT_PROGRAM;
+    if (typeof program !== "string" || program.length === 0)
+        return false;
+    const base = program.slice(Math.max(program.lastIndexOf("/"), program.lastIndexOf("\\")) + 1);
+    return base.toLowerCase().replace(/\.exe$/u, "") === GIT_PROGRAM;
 }
-
 /**
  * Whether a git argv carries the discovery flags whose absolute output the
  * caller resolves against the UNC world.
- * @param {unknown[]} argv - the spawn's argv; `argv[0]` is the program.
+ *
+ * @param argv - the spawn's argv; `argv[0]` is the program.
  * @returns true when the spawn must stay on host git.
  */
 function namesDiscoveryPaths(argv) {
-  return argv.some((arg) => typeof arg === "string" && DISCOVERY_FLAGS.includes(arg));
+    return argv.some((arg) => typeof arg === "string" && DISCOVERY_FLAGS.includes(arg));
 }
-
 /**
  * Translate one `GIT_*` value into the distro's coordinate system.
  *
@@ -81,15 +82,15 @@ function namesDiscoveryPaths(argv) {
  * @returns the distro-side spelling of the value.
  */
 export function translateGitEnvValue(value) {
-  if (typeof value !== "string") return value;
-  if (isWslUnc(value)) {
-    const parsed = uncToPosix(value);
-    return parsed === undefined ? value : parsed.linuxPath.length > 0 ? parsed.linuxPath : "/";
-  }
-  const mounted = windowsToLinuxMount(value);
-  return mounted === undefined ? value : mounted;
+    if (typeof value !== "string")
+        return value;
+    if (isWslUnc(value)) {
+        const parsed = uncToPosix(value);
+        return parsed === undefined ? value : parsed.linuxPath.length > 0 ? parsed.linuxPath : "/";
+    }
+    const mounted = windowsToLinuxMount(value);
+    return mounted === undefined ? value : mounted;
 }
-
 /**
  * Translate a git spawn's environment for the distro and name the keys that
  * must ride `WSLENV`.
@@ -99,15 +100,14 @@ export function translateGitEnvValue(value) {
  *   translated) and the `WSLENV` names.
  */
 export function translateGitEnv(env) {
-  const translated = {};
-  const names = [];
-  for (const [name, value] of Object.entries(env ?? {})) {
-    translated[name] = name.startsWith("GIT_") ? translateGitEnvValue(value) : value;
-    names.push(name);
-  }
-  return { env: translated, wslenv: names };
+    const translated = {};
+    const names = [];
+    for (const [name, value] of Object.entries(env ?? {})) {
+        translated[name] = name.startsWith("GIT_") ? translateGitEnvValue(value) : value;
+        names.push(name);
+    }
+    return { env: translated, wslenv: names };
 }
-
 /**
  * The distro-side rewrite of one git spawn, when it belongs in the distro.
  *
@@ -118,25 +118,24 @@ export function translateGitEnv(env) {
  * Windows directory, so the caller supplies its own host cwd.
  *
  * @param object - the spawn's inputs.
- * @param {unknown[]} object.argv - the spawn's argv; `argv[0]` is the program.
- * @param {unknown} object.cwd - the spawn's working directory, any coordinate system.
- * @param {string} object.wslPath - path to `wsl.exe`.
- * @returns {{distro: string, linuxCwd: string, gitArgv: string[], wslArgv: string[]}|undefined} the
- *   rewrite, or undefined when the spawn is not a routable distro git launch
- *   (non-git programs, host directories, and the absolute-output discovery
- *   flags all keep the shipped spawn).
+ * @returns the rewrite, or undefined when the spawn is not a routable distro
+ *   git launch (non-git programs, host directories, and the absolute-output
+ *   discovery flags all keep the shipped spawn).
  */
 export function gitSpawnRewrite({ argv, cwd, wslPath }) {
-  if (!Array.isArray(argv) || !isGitProgram(argv[0])) return undefined;
-  if (namesDiscoveryPaths(argv)) return undefined;
-  const named = uncToPosix(cwd);
-  if (named === undefined) return undefined;
-  const linuxCwd = named.linuxPath.length > 0 ? named.linuxPath : "/";
-  const gitArgv = [GIT_PROGRAM, ...argv.slice(1)];
-  return {
-    distro: named.distro,
-    linuxCwd,
-    gitArgv,
-    wslArgv: [wslPath, "-d", named.distro, "--cd", linuxCwd, "--exec", ...gitArgv],
-  };
+    if (!Array.isArray(argv) || !isGitProgram(argv[0]))
+        return undefined;
+    if (namesDiscoveryPaths(argv))
+        return undefined;
+    const named = uncToPosix(cwd);
+    if (named === undefined)
+        return undefined;
+    const linuxCwd = named.linuxPath.length > 0 ? named.linuxPath : "/";
+    const gitArgv = [GIT_PROGRAM, ...argv.slice(1)];
+    return {
+        distro: named.distro,
+        linuxCwd,
+        gitArgv,
+        wslArgv: [wslPath, "-d", named.distro, "--cd", linuxCwd, "--exec", ...gitArgv],
+    };
 }