@starci/hfs 4.11.22 → 4.12.0

package/runtime/scripts/api/fs/forbidden-root.mjs

@@ -7,23 +7,22 @@ import { fileURLToPath } from 'node:url';
 import { samePath } from '../../lib/path-key.mjs';
 import { realpathOr } from '../../lib/fs-kind.mjs';
 import { tempRoot } from '../../../engine/temp-root.mjs';
-
 const SKILL_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
-
 /**
  * True when `p` sits strictly below `root` by real path: no link on the way, not `root` itself. The one place a
  * primary checkout may be removed is a disposable fixture a caller names by its temp root (hk-tmp).
  */
 function strictlyInsideReal(p, root) {
-  if (!root) return false;
-  const rel = path.relative(path.resolve(root), path.resolve(p));
-  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return false;
-  const real = realpathOr(p);
-  const rootReal = realpathOr(root);
-  // Its real path must be the same relative place under the root's real path: no link between them.
-  return Boolean(real && rootReal) && samePath(real, path.join(rootReal, rel));
+    if (!root)
+        return false;
+    const rel = path.relative(path.resolve(root), path.resolve(p));
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+        return false;
+    const real = realpathOr(p);
+    const rootReal = realpathOr(root);
+    // Its real path must be the same relative place under the root's real path: no link between them.
+    return !!real && !!rootReal && samePath(real, path.join(rootReal, rel));
 }
-
 /**
  * A path the runtime must never remove whole: a filesystem root, the home or temp directory, the runtime, the
  * repository that hosts it, the repositories root, or a primary git checkout (its .git is a directory; the
@@ -36,17 +35,26 @@ function strictlyInsideReal(p, root) {
  * it made itself, outside every ledger's repository, says so with `hold: () => null`.
  */
 export function forbiddenRoot(p, { checkoutsUnder = null, hold } = {}) {
-  const resolved = path.resolve(p);
-  if (path.parse(resolved).root === resolved || samePath(path.dirname(resolved), resolved)) return 'a filesystem root';
-  for (const [name, dir] of [['the home directory', os.homedir()], ['the temp directory', os.tmpdir()], ['the configured temp root', tempRoot()], ['the runtime', SKILL_ROOT],
-    ['the repository hosting the runtime', path.dirname(SKILL_ROOT)], ['the repositories root', path.dirname(path.dirname(SKILL_ROOT))]]) {
-    if (dir && samePath(path.resolve(dir), resolved)) return name;
-  }
-  if (typeof hold !== 'function') return 'a tree no artifact-hold check cleared (pass hold)';
-  const held = hold(resolved);
-  if (held) return held;
-  let checkout = false;
-  try { checkout = fs.lstatSync(path.join(resolved, '.git')).isDirectory(); } catch { /* no .git directory */ }
-  if (checkout && !strictlyInsideReal(resolved, checkoutsUnder)) return 'a git checkout';
-  return null;
+    const resolved = path.resolve(p);
+    if (path.parse(resolved).root === resolved || samePath(path.dirname(resolved), resolved))
+        return 'a filesystem root';
+    const roots = [['the home directory', os.homedir()], ['the temp directory', os.tmpdir()], ['the configured temp root', tempRoot()], ['the runtime', SKILL_ROOT],
+        ['the repository hosting the runtime', path.dirname(SKILL_ROOT)], ['the repositories root', path.dirname(path.dirname(SKILL_ROOT))]];
+    for (const [name, dir] of roots) {
+        if (dir && samePath(path.resolve(dir), resolved))
+            return name;
+    }
+    if (typeof hold !== 'function')
+        return 'a tree no artifact-hold check cleared (pass hold)';
+    const held = hold(resolved);
+    if (held)
+        return held;
+    let checkout = false;
+    try {
+        checkout = fs.lstatSync(path.join(resolved, '.git')).isDirectory();
+    }
+    catch { /* no .git directory */ }
+    if (checkout && !strictlyInsideReal(resolved, checkoutsUnder))
+        return 'a git checkout';
+    return null;
 }

package/runtime/scripts/api/fs/is-link-like.d.mts

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+/**
+ * True when `p` is a link of any kind: a symlink, a junction, or another reparse point that redirects it.
+ * `parentReal` (the real path of p's parent, when the caller walked to it through real directories) lets the
+ * real-path test catch a reparse point lstat and readlink do not report. A missing path is not a link.
+ */
+export declare function isLinkLike(p: string, { parentReal, stat }?: {
+    parentReal?: string | null;
+    stat?: fs.Stats | null;
+}): boolean;

package/runtime/scripts/api/fs/is-link-like.mjs

@@ -6,21 +6,35 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { samePath } from '../../lib/path-key.mjs';
 import { realpathOr } from '../../lib/fs-kind.mjs';
-
 /**
  * True when `p` is a link of any kind: a symlink, a junction, or another reparse point that redirects it.
  * `parentReal` (the real path of p's parent, when the caller walked to it through real directories) lets the
  * real-path test catch a reparse point lstat and readlink do not report. A missing path is not a link.
  */
 export function isLinkLike(p, { parentReal = null, stat = null } = {}) {
-  let st = stat;
-  if (!st) { try { st = fs.lstatSync(p); } catch { return false; } }
-  if (!st) return false;
-  if (st.isSymbolicLink()) return true;
-  if (!st.isDirectory()) return false;
-  try { fs.readlinkSync(p); return true; } catch { /* not a link readlink can read */ }
-  const parent = parentReal ?? realpathOr(path.dirname(p));
-  const real = realpathOr(p);
-  if (!parent || !real) return true; // cannot prove it is a plain directory: treat it as a link
-  return !samePath(real, path.join(parent, path.basename(p)));
+    let st = stat;
+    if (!st) {
+        try {
+            st = fs.lstatSync(p);
+        }
+        catch {
+            return false;
+        }
+    }
+    if (!st)
+        return false;
+    if (st.isSymbolicLink())
+        return true;
+    if (!st.isDirectory())
+        return false;
+    try {
+        fs.readlinkSync(p);
+        return true;
+    }
+    catch { /* not a link readlink can read */ }
+    const parent = parentReal ?? realpathOr(path.dirname(p));
+    const real = realpathOr(p);
+    if (!parent || !real)
+        return true; // cannot prove it is a plain directory: treat it as a link
+    return !samePath(real, path.join(parent, path.basename(p)));
 }

package/runtime/scripts/api/fs/lib.d.mts

@@ -0,0 +1,12 @@
+/** The `code` of a caught value (a Node system error carries one), or undefined. */
+export declare const errorCode: (error: unknown) => string | undefined;
+/** The rename and unlink errors Windows returns while another process holds the target open: retried, never final. */
+export declare const FS_BUSY: readonly string[];
+/** Remove a link itself, never its target. True when nothing is left at `p`. */
+export declare function unlinkOnly(p: string): boolean;
+/** Construct an archive-reader refusal with its existing error code. */
+export declare const zipRefuse: (message: string, code?: string) => Error & {
+    code: string;
+};
+/** Relative ZIP entry names exclude traversal, drive roots and control characters. */
+export declare const validZipName: (name: string) => boolean;

package/runtime/scripts/api/fs/lib.mjs

@@ -2,19 +2,39 @@
 // process holds a path open, and the verified unlink of one link. The call files (safe-remove.mjs, remove-links-under.mjs,
 // rename-over.mjs, zip-write.mjs, ...) each name one filesystem use.
 import fs from 'node:fs';
-
+/** The `code` of a caught value (a Node system error carries one), or undefined. */
+export const errorCode = (error) => {
+    const code = error?.code;
+    return typeof code === 'string' ? code : undefined;
+};
 /** The rename and unlink errors Windows returns while another process holds the target open: retried, never final. */
 export const FS_BUSY = Object.freeze(['EPERM', 'EBUSY', 'EACCES']);
-
 /** Remove a link itself, never its target. True when nothing is left at `p`. */
 export function unlinkOnly(p) {
-  try { fs.lstatSync(p); } catch (error) { return error?.code === 'ENOENT'; }
-  try { fs.unlinkSync(p); } catch { try { fs.rmdirSync(p); } catch { /* verified below */ } }
-  try { fs.lstatSync(p); return false; } catch (error) { return error?.code === 'ENOENT'; }
+    try {
+        fs.lstatSync(p);
+    }
+    catch (error) {
+        return errorCode(error) === 'ENOENT';
+    }
+    try {
+        fs.unlinkSync(p);
+    }
+    catch {
+        try {
+            fs.rmdirSync(p);
+        }
+        catch { /* verified below */ }
+    }
+    try {
+        fs.lstatSync(p);
+        return false;
+    }
+    catch (error) {
+        return errorCode(error) === 'ENOENT';
+    }
 }
-
 /** Construct an archive-reader refusal with its existing error code. */
 export const zipRefuse = (message, code = 'zip-corrupt') => Object.assign(new Error(message), { code });
-
 /** Relative ZIP entry names exclude traversal, drive roots and control characters. */
-export const validZipName=name=>Boolean(name)&&!name.startsWith('/')&&!/^[A-Za-z]:/.test(name)&&!/[\0\r\n\\]/.test(name)&&!name.split('/').includes('..');
+export const validZipName = (name) => Boolean(name) && !name.startsWith('/') && !/^[A-Za-z]:/.test(name) && !/[\0\r\n\\]/.test(name) && !name.split('/').includes('..');

package/runtime/scripts/api/fs/make-temp-dir.d.mts

@@ -0,0 +1,5 @@
+/** A new directory `<prefix><random>` under `parent` (default the temp root, ensureTempRoot: TEMP_ROOT_UNUSABLE when it cannot be made), which is created when it is missing. */
+export declare function makeTempDir(prefix: string, { env, parent }?: {
+    env?: NodeJS.ProcessEnv;
+    parent?: string | undefined;
+}): string;

package/runtime/scripts/api/fs/make-temp-dir.mjs

@@ -2,10 +2,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { ensureTempRoot } from './ensure-temp-root.mjs';
-
 /** A new directory `<prefix><random>` under `parent` (default the temp root, ensureTempRoot: TEMP_ROOT_UNUSABLE when it cannot be made), which is created when it is missing. */
 export function makeTempDir(prefix, { env = process.env, parent = undefined } = {}) {
-  const root = parent ?? ensureTempRoot({ env });
-  fs.mkdirSync(root, { recursive: true });
-  return fs.mkdtempSync(path.join(root, prefix));
+    const root = parent ?? ensureTempRoot({ env });
+    fs.mkdirSync(root, { recursive: true });
+    return fs.mkdtempSync(path.join(root, prefix));
 }

package/runtime/scripts/api/fs/rename-over.d.mts

@@ -0,0 +1,13 @@
+/** renameOver's options; each is a seam a spec injects. */
+export interface RenameOverOptions {
+    retries?: number;
+    delayMs?: (attempt: number) => number;
+    sleep?: (ms: number) => void;
+    rename?: (from: string, to: string) => void;
+}
+/**
+ * Rename `tmp` over `file`. A busy refusal (FS_BUSY of lib.mjs) is retried up to `retries` times, `delayMs(attempt)`
+ * apart. When the rename fails for good, `tmp` is removed and the last error is thrown. `rename` is the seam
+ * a spec injects (default fs.renameSync).
+ */
+export declare function renameOver(tmp: string, file: string, { retries, delayMs, sleep, rename }?: RenameOverOptions): void;

package/runtime/scripts/api/fs/rename-over.mjs

@@ -1,21 +1,27 @@
 // rename-over.mjs — replacing a file whole through a temp file beside it.
 import fs from 'node:fs';
 import { sleepSync } from '../../lib/sleep-sync.mjs';
-import { FS_BUSY } from './lib.mjs';
-
+import { FS_BUSY, errorCode } from './lib.mjs';
 /**
  * Rename `tmp` over `file`. A busy refusal (FS_BUSY of lib.mjs) is retried up to `retries` times, `delayMs(attempt)`
  * apart. When the rename fails for good, `tmp` is removed and the last error is thrown. `rename` is the seam
  * a spec injects (default fs.renameSync).
  */
 export function renameOver(tmp, file, { retries = 20, delayMs = () => 25, sleep = sleepSync, rename = fs.renameSync } = {}) {
-  for (let attempt = 0; ; attempt += 1) {
-    try { rename(tmp, file); return; } catch (error) {
-      if (attempt >= retries || !FS_BUSY.includes(error?.code)) {
-        try { fs.rmSync(tmp, { force: true }); } catch { /* best effort */ }
-        throw error;
-      }
-      sleep(delayMs(attempt));
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            rename(tmp, file);
+            return;
+        }
+        catch (error) {
+            if (attempt >= retries || !FS_BUSY.includes(errorCode(error) ?? '')) {
+                try {
+                    fs.rmSync(tmp, { force: true });
+                }
+                catch { /* best effort */ }
+                throw error;
+            }
+            sleep(delayMs(attempt));
+        }
     }
-  }
 }

package/runtime/scripts/api/fs/safe-remove.d.mts

@@ -0,0 +1,25 @@
+/** What safeRemove reports: ok is true only when the root is gone. */
+export interface SafeRemoveResult {
+    ok: boolean;
+    root: string;
+    removed: {
+        files: number;
+        dirs: number;
+        links: number;
+    };
+    errors: Array<{
+        path: string;
+        code: string;
+        message: string;
+    }>;
+}
+/**
+ * Remove `root` and everything under it without ever following a link. Links are unlinked (the link only);
+ * plain files and directories are deleted bottom-up. `checkoutsUnder` and `hold` (required) are forbidden-root.mjs forbiddenRoot's. Returns {ok, root, removed: {files, dirs, links},
+ * errors: [{path, code, message}]}; ok is true only when `root` is gone. A missing root is ok.
+ */
+export declare function safeRemove(root: unknown, { retries, checkoutsUnder, hold }?: {
+    retries?: number;
+    checkoutsUnder?: string | null;
+    hold?: ((path: string) => string | null) | undefined;
+}): SafeRemoveResult;

package/runtime/scripts/api/fs/safe-remove.mjs

@@ -23,99 +23,157 @@ import path from 'node:path';
 import { sleepSync } from '../../lib/sleep-sync.mjs';
 import { samePath } from '../../lib/path-key.mjs';
 import { realpathOr } from '../../lib/fs-kind.mjs';
-import { FS_BUSY, unlinkOnly } from './lib.mjs';
+import { FS_BUSY, unlinkOnly, errorCode } from './lib.mjs';
 import { isLinkLike } from './is-link-like.mjs';
 import { forbiddenRoot } from './forbidden-root.mjs';
-
+const messageOf = (error) => String(error?.message ?? error);
 const WIN = process.platform === 'win32';
 const same = samePath;
-
 const retrying = (fn, retries) => {
-  for (let attempt = 0; ; attempt += 1) {
-    try { fn(); return null; } catch (error) {
-      if (error?.code === 'ENOENT') return null;
-      if (attempt >= retries || ![...FS_BUSY, 'ENOTEMPTY'].includes(error?.code)) return error;
-      sleepSync(25 * (attempt + 1));
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            fn();
+            return null;
+        }
+        catch (error) {
+            if (errorCode(error) === 'ENOENT')
+                return null;
+            if (attempt >= retries || ![...FS_BUSY, 'ENOTEMPTY'].includes(errorCode(error) ?? ''))
+                return error;
+            sleepSync(25 * (attempt + 1));
+        }
     }
-  }
 };
 const removeFile = (p, retries) => retrying(() => {
-  try { fs.unlinkSync(p); } catch (error) {
-    if (WIN && (error?.code === 'EPERM' || error?.code === 'EACCES')) { fs.chmodSync(p, 0o600); fs.unlinkSync(p); } else throw error;
-  }
+    try {
+        fs.unlinkSync(p);
+    }
+    catch (error) {
+        if (WIN && (errorCode(error) === 'EPERM' || errorCode(error) === 'EACCES')) {
+            fs.chmodSync(p, 0o600);
+            fs.unlinkSync(p);
+        }
+        else
+            throw error;
+    }
 }, retries);
-
 /**
  * Remove `root` and everything under it without ever following a link. Links are unlinked (the link only);
  * plain files and directories are deleted bottom-up. `checkoutsUnder` and `hold` (required) are forbidden-root.mjs forbiddenRoot's. Returns {ok, root, removed: {files, dirs, links},
  * errors: [{path, code, message}]}; ok is true only when `root` is gone. A missing root is ok.
  */
 export function safeRemove(root, { retries = 5, checkoutsUnder = null, hold } = {}) {
-  const target = path.resolve(String(root ?? ''));
-  const out = { ok: false, root: target, removed: { files: 0, dirs: 0, links: 0 }, errors: [] };
-  const fail = (p, error) => { out.errors.push({ path: p, code: error?.code ?? 'ERROR', message: String(error?.message ?? error) }); };
-  const refused = root ? forbiddenRoot(target, { checkoutsUnder, hold }) : 'no path';
-  if (refused) { fail(target, { code: 'REFUSED', message: `refusing to remove ${refused}` }); return out; }
-  let st;
-  try { st = fs.lstatSync(target); } catch (error) {
-    if (error?.code === 'ENOENT') { out.ok = true; return out; }
-    fail(target, error); return out;
-  }
-  // CONTAINMENT (the .claude/node_modules wipe, 2026-09-28): nothing is ever deleted whose real path is not
-  // the root itself or strictly under the root's real path. A link is unlinked above (the link only); any other
-  // entry that resolves outside the tree is refused, whatever made it look like a plain entry.
-  const rootReal = realpathOr(target);
-  const ctx = { out, fail, retries, rootReal, target };
-  walk(ctx, target, st, null);
-  out.ok = !fs.existsSync(target) && (() => { try { fs.lstatSync(target); return false; } catch { return true; } })();
-  return out;
+    const target = path.resolve(String(root ?? ''));
+    const out = { ok: false, root: target, removed: { files: 0, dirs: 0, links: 0 }, errors: [] };
+    const fail = (p, error) => { out.errors.push({ path: p, code: errorCode(error) ?? 'ERROR', message: messageOf(error) }); };
+    const refused = root ? forbiddenRoot(target, { checkoutsUnder, hold }) : 'no path';
+    if (refused) {
+        fail(target, { code: 'REFUSED', message: `refusing to remove ${refused}` });
+        return out;
+    }
+    let st;
+    try {
+        st = fs.lstatSync(target);
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT') {
+            out.ok = true;
+            return out;
+        }
+        fail(target, error);
+        return out;
+    }
+    // CONTAINMENT (the .claude/node_modules wipe, 2026-09-28): nothing is ever deleted whose real path is not
+    // the root itself or strictly under the root's real path. A link is unlinked above (the link only); any other
+    // entry that resolves outside the tree is refused, whatever made it look like a plain entry.
+    const rootReal = realpathOr(target);
+    const ctx = { out, fail, retries, rootReal, target };
+    walk(ctx, target, st, null);
+    out.ok = !fs.existsSync(target) && (() => { try {
+        fs.lstatSync(target);
+        return false;
+    }
+    catch {
+        return true;
+    } })();
+    return out;
 }
-
 function insideRoot({ rootReal }, p) {
-  const real = realpathOr(p);
-  if (!real || !rootReal) return false;
-  if (same(real, rootReal)) return true;
-  const rel = path.relative(rootReal, real);
-  return Boolean(rel) && !rel.startsWith('..') && !path.isAbsolute(rel);
+    const real = realpathOr(p);
+    if (!real || !rootReal)
+        return false;
+    if (same(real, rootReal))
+        return true;
+    const rel = path.relative(rootReal, real);
+    return Boolean(rel) && !rel.startsWith('..') && !path.isAbsolute(rel);
 }
-
 // Removes each child of `dir` (real path `real`); false when any child stays.
 function removeChildren(ctx, dir, entries, real) {
-  let clear = true;
-  for (const name of entries) {
-    const child = path.join(dir, name);
-    let childStat;
-    try { childStat = fs.lstatSync(child); } catch (error) { if (error?.code !== 'ENOENT') { ctx.fail(child, error); clear = false; } continue; }
-    if (!walk(ctx, child, childStat, real)) clear = false;
-  }
-  return clear;
+    let clear = true;
+    for (const name of entries) {
+        const child = path.join(dir, name);
+        let childStat;
+        try {
+            childStat = fs.lstatSync(child);
+        }
+        catch (error) {
+            if (errorCode(error) !== 'ENOENT') {
+                ctx.fail(child, error);
+                clear = false;
+            }
+            continue;
+        }
+        if (!walk(ctx, child, childStat, real))
+            clear = false;
+    }
+    return clear;
 }
-
 function walkDirectory(ctx, dir) {
-  const { out, fail, retries } = ctx;
-  const real = realpathOr(dir);
-  if (!real) { fail(dir, { code: 'REALPATH', message: 'cannot resolve the directory' }); return false; }
-  let entries;
-  try { entries = fs.readdirSync(dir); } catch (error) { fail(dir, error); return false; }
-  if (!removeChildren(ctx, dir, entries, real)) return false;
-  const error = retrying(() => fs.rmdirSync(dir), retries);
-  if (error) { fail(dir, error); return false; }
-  out.removed.dirs += 1; return true;
+    const { out, fail, retries } = ctx;
+    const real = realpathOr(dir);
+    if (!real) {
+        fail(dir, { code: 'REALPATH', message: 'cannot resolve the directory' });
+        return false;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch (error) {
+        fail(dir, error);
+        return false;
+    }
+    if (!removeChildren(ctx, dir, entries, real))
+        return false;
+    const error = retrying(() => fs.rmdirSync(dir), retries);
+    if (error) {
+        fail(dir, error);
+        return false;
+    }
+    out.removed.dirs += 1;
+    return true;
 }
-
 function walk(ctx, dir, st, parentReal) {
-  const { out, fail, retries, rootReal, target } = ctx;
-  if (isLinkLike(dir, { parentReal, stat: st })) {
-    if (unlinkOnly(dir)) { out.removed.links += 1; return true; }
-    fail(dir, { code: 'LINK_STUCK', message: 'a link could not be unlinked; nothing above it is removed' });
-    return false;
-  }
-  if (!insideRoot(ctx, dir)) {
-    fail(dir, { code: 'OUTSIDE_ROOT', message: `refusing to delete ${dir}: its real path ${realpathOr(dir) ?? '?'} is outside ${rootReal ?? target}` });
-    return false;
-  }
-  if (st.isDirectory()) return walkDirectory(ctx, dir);
-  const error = removeFile(dir, retries);
-  if (error) { fail(dir, error); return false; }
-  out.removed.files += 1; return true;
+    const { out, fail, retries, rootReal, target } = ctx;
+    if (isLinkLike(dir, { parentReal, stat: st })) {
+        if (unlinkOnly(dir)) {
+            out.removed.links += 1;
+            return true;
+        }
+        fail(dir, { code: 'LINK_STUCK', message: 'a link could not be unlinked; nothing above it is removed' });
+        return false;
+    }
+    if (!insideRoot(ctx, dir)) {
+        fail(dir, { code: 'OUTSIDE_ROOT', message: `refusing to delete ${dir}: its real path ${realpathOr(dir) ?? '?'} is outside ${rootReal ?? target}` });
+        return false;
+    }
+    if (st.isDirectory())
+        return walkDirectory(ctx, dir);
+    const error = removeFile(dir, retries);
+    if (error) {
+        fail(dir, error);
+        return false;
+    }
+    out.removed.files += 1;
+    return true;
 }

package/runtime/scripts/api/git/add.d.mts

@@ -0,0 +1,3 @@
+import { type GitOptions, type GitResult } from './lib.mjs';
+/** The spawn result {status, stdout, stderr, error} of `git add ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
+export declare const add: (args?: readonly string[], options?: GitOptions) => GitResult;

package/runtime/scripts/api/git/add.mjs

@@ -1,5 +1,4 @@
 // add.mjs — `git add <args>`: paths staged into the index.
 import { runGit } from './lib.mjs';
-
 /** The spawn result {status, stdout, stderr, error} of `git add ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
 export const add = (args = [], options = {}) => runGit(['add', ...args], options);

package/runtime/scripts/api/git/cat-file.d.mts

@@ -0,0 +1,3 @@
+import { type GitOptions, type GitResult } from './lib.mjs';
+/** The spawn result {status, stdout, stderr, error} of `git cat-file ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
+export declare const catFile: (args?: readonly string[], options?: GitOptions) => GitResult;

package/runtime/scripts/api/git/cat-file.mjs

@@ -1,5 +1,4 @@
 // cat-file.mjs — `git cat-file <args>`: the type, size or content of repository objects (-e, -p, --batch).
 import { runGit } from './lib.mjs';
-
 /** The spawn result {status, stdout, stderr, error} of `git cat-file ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
 export const catFile = (args = [], options = {}) => runGit(['cat-file', ...args], options);

package/runtime/scripts/api/git/check-ignore.d.mts

@@ -0,0 +1,3 @@
+import { type GitOptions, type GitResult } from './lib.mjs';
+/** The spawn result {status, stdout, stderr, error} of `git check-ignore ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
+export declare const checkIgnore: (args?: readonly string[], options?: GitOptions) => GitResult;

package/runtime/scripts/api/git/check-ignore.mjs

@@ -1,5 +1,4 @@
 // check-ignore.mjs — `git check-ignore <args>`: whether paths are ignored (-q exits 0 for an ignored path).
 import { runGit } from './lib.mjs';
-
 /** The spawn result {status, stdout, stderr, error} of `git check-ignore ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
 export const checkIgnore = (args = [], options = {}) => runGit(['check-ignore', ...args], options);

package/runtime/scripts/api/git/commit-tree.d.mts

@@ -0,0 +1,3 @@
+import { type GitOptions, type GitResult } from './lib.mjs';
+/** The spawn result {status, stdout, stderr, error} of `git commit-tree ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
+export declare const commitTree: (args?: readonly string[], options?: GitOptions) => GitResult;

package/runtime/scripts/api/git/commit-tree.mjs

@@ -1,5 +1,4 @@
 // commit-tree.mjs — `git commit-tree <args>`: a commit object written from a tree (its sha on stdout).
 import { runGit } from './lib.mjs';
-
 /** The spawn result {status, stdout, stderr, error} of `git commit-tree ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
 export const commitTree = (args = [], options = {}) => runGit(['commit-tree', ...args], options);

package/runtime/scripts/api/git/config-get.d.mts

@@ -0,0 +1,10 @@
+import { type GitRun, type GitRunnerFn } from './lib.mjs';
+/**
+ * {ok, stdout, stderr}; `local` reads the repository's own config only; `env` replaces the process env (a caller drops
+ * git's repository-local variables). git: the caller's runner or null.
+ */
+export declare function configGet(cwd: string, key: string, { local, env, git }?: {
+    local?: boolean;
+    env?: NodeJS.ProcessEnv | undefined;
+    git?: GitRunnerFn | null;
+}): GitRun;

package/runtime/scripts/api/git/config-get.mjs

@@ -1,10 +1,9 @@
 // config-get.mjs — `git config [--local] --get <key>`: one configuration value of a checkout (empty when unset).
 import { gitRunner } from './lib.mjs';
-
 /**
  * {ok, stdout, stderr}; `local` reads the repository's own config only; `env` replaces the process env (a caller drops
  * git's repository-local variables). git: the caller's runner or null.
  */
 export function configGet(cwd, key, { local = false, env = undefined, git = null } = {}) {
-  return gitRunner(git)(['config', ...(local ? ['--local'] : []), '--get', key], env ? { cwd, env } : { cwd });
+    return gitRunner(git)(['config', ...(local ? ['--local'] : []), '--get', key], env ? { cwd, env } : { cwd });
 }

package/runtime/scripts/api/git/diff.d.mts

@@ -0,0 +1,3 @@
+import { type GitOptions, type GitResult } from './lib.mjs';
+/** The spawn result {status, stdout, stderr, error} of `git diff ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
+export declare const diff: (args?: readonly string[], options?: GitOptions) => GitResult;

package/runtime/scripts/api/git/diff.mjs

@@ -1,5 +1,4 @@
 // diff.mjs — `git diff <args>`: the changes between commits, the index and the working tree.
 import { runGit } from './lib.mjs';
-
 /** The spawn result {status, stdout, stderr, error} of `git diff ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
 export const diff = (args = [], options = {}) => runGit(['diff', ...args], options);

package/runtime/scripts/api/git/init.d.mts

@@ -0,0 +1,7 @@
+import { type GitRun, type GitRunnerFn } from './lib.mjs';
+/** {ok, stdout, stderr}. `env` replaces the process env (a sandbox's own home); git: the caller's runner or null. */
+export declare function init(cwd: string, { branch, env, git }?: {
+    branch?: string;
+    env?: NodeJS.ProcessEnv | undefined;
+    git?: GitRunnerFn | null;
+}): GitRun;

package/runtime/scripts/api/git/init.mjs

@@ -1,7 +1,6 @@
 // init.mjs — `git -c init.defaultBranch=<branch> init --quiet`: create an empty repository in `cwd` (the install sandbox's app repository).
 import { gitRunner } from './lib.mjs';
-
 /** {ok, stdout, stderr}. `env` replaces the process env (a sandbox's own home); git: the caller's runner or null. */
 export function init(cwd, { branch = 'main', env = undefined, git = null } = {}) {
-  return gitRunner(git)(['-c', `init.defaultBranch=${branch}`, 'init', '--quiet'], env ? { cwd, env } : { cwd });
+    return gitRunner(git)(['-c', `init.defaultBranch=${branch}`, 'init', '--quiet'], env ? { cwd, env } : { cwd });
 }