shell-dsl 0.0.33 → 0.0.34

package/README.md

@@ -750,6 +750,8 @@ const fs = new FileSystem("/", {}, createWebUnderlyingFS(root));
 
 `VersionControlSystem` adds git-like version control to any `VirtualFS`. It tracks changes as diffs, supports branching, and stores metadata in a `.vcs` directory.
 
+Ignore and attribute rules are configured directly on the constructor:
+
 ```ts
 import { VersionControlSystem, createVirtualFS } from "shell-dsl";
 import { createFsFromVolume, Volume } from "memfs";
@@ -764,9 +766,25 @@ const fs = createVirtualFS(createFsFromVolume(vol));
 const vcs = new VersionControlSystem({
   fs,
   path: "/project",
+  ignore: ["dist", "*.log"],
+  attributes: [
+    { pattern: "assets/*.png", diff: "binary" },
+    { pattern: "secrets/**", diff: "none" },
+  ],
 });
 ```
 
+Ignore patterns apply only to untracked paths:
+
+- Ignored untracked files are skipped by `status()` and full `commit()`
+- Files already tracked by VCS remain tracked even if they later match an ignore rule
+- Full `checkout()` preserves ignored untracked files
+
+Attribute rules are applied in declaration order, with later matches winning. Supported properties:
+
+- `binary?: boolean`
+- `diff?: "text" | "binary" | "none"`
+
 ### Committing Changes
 
 ```ts
@@ -784,10 +802,13 @@ await vcs.commit("update src only", { paths: ["/src/**"] });
 ```ts
 const changes = await vcs.status();
 for (const entry of changes) {
-  console.log(entry.type, entry.path); // "add" | "modify" | "delete"
+  console.log(entry.type, entry.path, entry.diff, entry.binary);
+  // "add" | "modify" | "delete", "text" | "binary" | "none", boolean
 }
 ```
 
+When `diff` is `"none"`, the entry still reports the path and change type, but omits `content` and `previousContent`.
+
 ### Checkout
 
 ```ts
@@ -826,7 +847,7 @@ const filtered = await vcs.log({ path: "src/index.ts", limit: 10 });
 // Diff between two revisions
 const diff = await vcs.diff(1, 2);
 for (const entry of diff) {
-  console.log(entry.type, entry.path); // "add" | "modify" | "delete"
+  console.log(entry.type, entry.path, entry.diff);
 }
 
 // Current HEAD info

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "shell-dsl",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "type": "commonjs"
 }

package/dist/cjs/src/index.cjs.map

@@ -2,7 +2,7 @@
   "version": 3,
   "sources": ["../../../src/index.ts"],
   "sourcesContent": [
-    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n  IfNode,\n  ForNode,\n  WhileNode,\n  UntilNode,\n  CaseNode,\n  CaseClause,\n  ArithmeticNode,\n} from \"./parser/index.cjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n  isIfNode,\n  isForNode,\n  isWhileNode,\n  isUntilNode,\n  isCaseNode,\n  isArithmeticNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions, BreakException, ContinueException } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\nexport {\n  FileSystem,\n  ReadOnlyFileSystem,\n  WebFileSystem,\n  createWebUnderlyingFS,\n  type PathOps,\n  type Permission,\n  type PermissionRules,\n  type UnderlyingFS,\n} from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation, globVirtualFS } from \"./utils/index.cjs\";\nexport type { GlobVirtualFS, GlobOptions } from \"./utils/index.cjs\";\n\n// Version Control\nexport { VersionControlSystem } from \"./vcs/index.cjs\";\nexport type {\n  VCSConfig,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  FileEntry,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./vcs/index.cjs\";\n"
+    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n  IfNode,\n  ForNode,\n  WhileNode,\n  UntilNode,\n  CaseNode,\n  CaseClause,\n  ArithmeticNode,\n} from \"./parser/index.cjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n  isIfNode,\n  isForNode,\n  isWhileNode,\n  isUntilNode,\n  isCaseNode,\n  isArithmeticNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions, BreakException, ContinueException } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\nexport {\n  FileSystem,\n  ReadOnlyFileSystem,\n  WebFileSystem,\n  createWebUnderlyingFS,\n  type PathOps,\n  type Permission,\n  type PermissionRules,\n  type UnderlyingFS,\n} from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation, globVirtualFS } from \"./utils/index.cjs\";\nexport type { GlobVirtualFS, GlobOptions } from \"./utils/index.cjs\";\n\n// Version Control\nexport { VersionControlSystem } from \"./vcs/index.cjs\";\nexport type {\n  VCSConfig,\n  VCSAttributeRule,\n  VCSResolvedAttributes,\n  VCSDiffMode,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  TreeEntry,\n  FileEntry,\n  DirectoryEntry,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./vcs/index.cjs\";\n"
   ],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAgB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AAuCO,IAjBP;AAoBwF,IAAxF;AAGgC,IAAhC;AAUO,IATP;AAYuC,IAAvC;AACwF,IAAxF;AAG8D,IAA9D;AAIqC,IAArC;",
   "debugId": "27F0973A44539CA064756E2164756E21",

package/dist/cjs/src/vcs/diff.cjs

@@ -43,60 +43,65 @@ __export(exports_diff, {
   diffManifests: () => diffManifests
 });
 module.exports = __toCommonJS(exports_diff);
-var import_walk = require("./walk.cjs");
-function diffManifests(before, after) {
+var import_rules = require("./rules.cjs");
+var import_snapshot = require("./snapshot.cjs");
+function diffManifests(before, after, rules = new import_rules.VCSRules) {
   const entries = [];
   const allPaths = new Set([...Object.keys(before), ...Object.keys(after)]);
   for (const path of allPaths) {
     const prev = before[path];
     const curr = after[path];
     if (!prev && curr) {
-      entries.push({ type: "add", path, content: curr.content });
+      entries.push(createDiffEntry("add", path, curr, undefined, rules));
     } else if (prev && !curr) {
-      entries.push({ type: "delete", path, previousContent: prev.content });
-    } else if (prev && curr && prev.content !== curr.content) {
-      entries.push({
-        type: "modify",
-        path,
-        content: curr.content,
-        previousContent: prev.content
-      });
+      entries.push(createDiffEntry("delete", path, undefined, prev, rules));
+    } else if (prev && curr && !entriesEqual(prev, curr)) {
+      entries.push(createDiffEntry("modify", path, curr, prev, rules));
     }
   }
   return entries.sort((a, b) => a.path.localeCompare(b.path));
 }
-async function diffWorkingTree(fs, rootPath, manifest, exclude = []) {
-  const entries = [];
-  const workingFiles = await import_walk.walkTree(fs, rootPath, exclude);
-  const manifestPaths = new Set(Object.keys(manifest));
-  const seenPaths = new Set;
-  for (const relPath of workingFiles) {
-    seenPaths.add(relPath);
-    const fullPath = fs.resolve(rootPath, relPath);
-    const content = await fs.readFile(fullPath);
-    const b64 = Buffer.from(content).toString("base64");
-    const prev = manifest[relPath];
-    if (!prev) {
-      entries.push({ type: "add", path: relPath, content: b64 });
-    } else if (prev.content !== b64) {
-      entries.push({
-        type: "modify",
-        path: relPath,
-        content: b64,
-        previousContent: prev.content
-      });
+async function diffWorkingTree(fs, rootPath, manifest, rules = new import_rules.VCSRules({ internalDirName: ".vcs" })) {
+  const workingManifest = await import_snapshot.buildTreeManifest(fs, rootPath, {
+    rules,
+    trackedPaths: Object.keys(manifest)
+  });
+  return diffManifests(manifest, workingManifest, rules);
+}
+function createDiffEntry(type, path, current, previous, rules) {
+  const attributes = rules.resolveAttributes(path);
+  const entryKind = getEntryKind(current ?? previous);
+  const previousEntryKind = previous ? getEntryKind(previous) : undefined;
+  const entry = {
+    type,
+    path,
+    binary: attributes.binary,
+    diff: attributes.diff,
+    entryKind,
+    previousEntryKind
+  };
+  if (attributes.diff !== "none") {
+    if (isFileEntry(current)) {
+      entry.content = current.content;
     }
-  }
-  for (const manifestPath of manifestPaths) {
-    if (!seenPaths.has(manifestPath)) {
-      entries.push({
-        type: "delete",
-        path: manifestPath,
-        previousContent: manifest[manifestPath].content
-      });
+    if (isFileEntry(previous)) {
+      entry.previousContent = previous.content;
     }
   }
-  return entries.sort((a, b) => a.path.localeCompare(b.path));
+  return entry;
+}
+function entriesEqual(a, b) {
+  if (getEntryKind(a) !== getEntryKind(b))
+    return false;
+  if (!isFileEntry(a) || !isFileEntry(b))
+    return true;
+  return a.content === b.content;
+}
+function getEntryKind(entry) {
+  return entry?.kind === "directory" ? "directory" : "file";
+}
+function isFileEntry(entry) {
+  return !!entry && entry.kind !== "directory";
 }
 
-//# debugId=C182915799ABD69764756E2164756E21
+//# debugId=F0849DE3546011FF64756E2164756E21

package/dist/cjs/src/vcs/diff.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/vcs/diff.ts"],
   "sourcesContent": [
-    "import type { VirtualFS } from \"../types.cjs\";\nimport type { TreeManifest, DiffEntry } from \"./types.cjs\";\nimport { walkTree } from \"./walk.cjs\";\n\n/**\n * Compute diff entries between two tree manifests.\n */\nexport function diffManifests(\n  before: TreeManifest,\n  after: TreeManifest,\n): DiffEntry[] {\n  const entries: DiffEntry[] = [];\n  const allPaths = new Set([...Object.keys(before), ...Object.keys(after)]);\n\n  for (const path of allPaths) {\n    const prev = before[path];\n    const curr = after[path];\n\n    if (!prev && curr) {\n      entries.push({ type: \"add\", path, content: curr.content });\n    } else if (prev && !curr) {\n      entries.push({ type: \"delete\", path, previousContent: prev.content });\n    } else if (prev && curr && prev.content !== curr.content) {\n      entries.push({\n        type: \"modify\",\n        path,\n        content: curr.content,\n        previousContent: prev.content,\n      });\n    }\n  }\n\n  return entries.sort((a, b) => a.path.localeCompare(b.path));\n}\n\n/**\n * Compute diff between a tree manifest and the current working tree.\n */\nexport async function diffWorkingTree(\n  fs: VirtualFS,\n  rootPath: string,\n  manifest: TreeManifest,\n  exclude: string[] = [],\n): Promise<DiffEntry[]> {\n  const entries: DiffEntry[] = [];\n  const workingFiles = await walkTree(fs, rootPath, exclude);\n  const manifestPaths = new Set(Object.keys(manifest));\n  const seenPaths = new Set<string>();\n\n  for (const relPath of workingFiles) {\n    seenPaths.add(relPath);\n    const fullPath = fs.resolve(rootPath, relPath);\n    const content = await fs.readFile(fullPath);\n    const b64 = Buffer.from(content).toString(\"base64\");\n\n    const prev = manifest[relPath];\n    if (!prev) {\n      entries.push({ type: \"add\", path: relPath, content: b64 });\n    } else if (prev.content !== b64) {\n      entries.push({\n        type: \"modify\",\n        path: relPath,\n        content: b64,\n        previousContent: prev.content,\n      });\n    }\n  }\n\n  for (const manifestPath of manifestPaths) {\n    if (!seenPaths.has(manifestPath)) {\n      entries.push({\n        type: \"delete\",\n        path: manifestPath,\n        previousContent: manifest[manifestPath]!.content,\n      });\n    }\n  }\n\n  return entries.sort((a, b) => a.path.localeCompare(b.path));\n}\n"
+    "import type { VirtualFS } from \"../types.cjs\";\nimport type { TreeManifest, DiffEntry, TreeEntry } from \"./types.cjs\";\nimport { VCSRules } from \"./rules.cjs\";\nimport { buildTreeManifest } from \"./snapshot.cjs\";\n\n/**\n * Compute diff entries between two tree manifests.\n */\nexport function diffManifests(\n  before: TreeManifest,\n  after: TreeManifest,\n  rules: VCSRules = new VCSRules(),\n): DiffEntry[] {\n  const entries: DiffEntry[] = [];\n  const allPaths = new Set([...Object.keys(before), ...Object.keys(after)]);\n\n  for (const path of allPaths) {\n    const prev = before[path];\n    const curr = after[path];\n\n    if (!prev && curr) {\n      entries.push(createDiffEntry(\"add\", path, curr, undefined, rules));\n    } else if (prev && !curr) {\n      entries.push(createDiffEntry(\"delete\", path, undefined, prev, rules));\n    } else if (prev && curr && !entriesEqual(prev, curr)) {\n      entries.push(createDiffEntry(\"modify\", path, curr, prev, rules));\n    }\n  }\n\n  return entries.sort((a, b) => a.path.localeCompare(b.path));\n}\n\n/**\n * Compute diff between a tree manifest and the current working tree.\n */\nexport async function diffWorkingTree(\n  fs: VirtualFS,\n  rootPath: string,\n  manifest: TreeManifest,\n  rules: VCSRules = new VCSRules({ internalDirName: \".vcs\" }),\n): Promise<DiffEntry[]> {\n  const workingManifest = await buildTreeManifest(fs, rootPath, {\n    rules,\n    trackedPaths: Object.keys(manifest),\n  });\n  return diffManifests(manifest, workingManifest, rules);\n}\n\nfunction createDiffEntry(\n  type: DiffEntry[\"type\"],\n  path: string,\n  current: TreeEntry | undefined,\n  previous: TreeEntry | undefined,\n  rules: VCSRules,\n): DiffEntry {\n  const attributes = rules.resolveAttributes(path);\n  const entryKind = getEntryKind(current ?? previous);\n  const previousEntryKind = previous ? getEntryKind(previous) : undefined;\n  const entry: DiffEntry = {\n    type,\n    path,\n    binary: attributes.binary,\n    diff: attributes.diff,\n    entryKind,\n    previousEntryKind,\n  };\n\n  if (attributes.diff !== \"none\") {\n    if (isFileEntry(current)) {\n      entry.content = current.content;\n    }\n    if (isFileEntry(previous)) {\n      entry.previousContent = previous.content;\n    }\n  }\n\n  return entry;\n}\n\nfunction entriesEqual(a: TreeEntry, b: TreeEntry): boolean {\n  if (getEntryKind(a) !== getEntryKind(b)) return false;\n  if (!isFileEntry(a) || !isFileEntry(b)) return true;\n  return a.content === b.content;\n}\n\nfunction getEntryKind(entry: TreeEntry | undefined): \"file\" | \"directory\" {\n  return entry?.kind === \"directory\" ? \"directory\" : \"file\";\n}\n\nfunction isFileEntry(entry: TreeEntry | undefined): entry is Extract<TreeEntry, { kind?: \"file\" }> {\n  return !!entry && entry.kind !== \"directory\";\n}\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEyB,IAAzB;AAKO,SAAS,aAAa,CAC3B,QACA,OACa;AAAA,EACb,MAAM,UAAuB,CAAC;AAAA,EAC9B,MAAM,WAAW,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,MAAM,GAAG,GAAG,OAAO,KAAK,KAAK,CAAC,CAAC;AAAA,EAExE,WAAW,QAAQ,UAAU;AAAA,IAC3B,MAAM,OAAO,OAAO;AAAA,IACpB,MAAM,OAAO,MAAM;AAAA,IAEnB,IAAI,CAAC,QAAQ,MAAM;AAAA,MACjB,QAAQ,KAAK,EAAE,MAAM,OAAO,MAAM,SAAS,KAAK,QAAQ,CAAC;AAAA,IAC3D,EAAO,SAAI,QAAQ,CAAC,MAAM;AAAA,MACxB,QAAQ,KAAK,EAAE,MAAM,UAAU,MAAM,iBAAiB,KAAK,QAAQ,CAAC;AAAA,IACtE,EAAO,SAAI,QAAQ,QAAQ,KAAK,YAAY,KAAK,SAAS;AAAA,MACxD,QAAQ,KAAK;AAAA,QACX,MAAM;AAAA,QACN;AAAA,QACA,SAAS,KAAK;AAAA,QACd,iBAAiB,KAAK;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,OAAO,QAAQ,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAAA;AAM5D,eAAsB,eAAe,CACnC,IACA,UACA,UACA,UAAoB,CAAC,GACC;AAAA,EACtB,MAAM,UAAuB,CAAC;AAAA,EAC9B,MAAM,eAAe,MAAM,qBAAS,IAAI,UAAU,OAAO;AAAA,EACzD,MAAM,gBAAgB,IAAI,IAAI,OAAO,KAAK,QAAQ,CAAC;AAAA,EACnD,MAAM,YAAY,IAAI;AAAA,EAEtB,WAAW,WAAW,cAAc;AAAA,IAClC,UAAU,IAAI,OAAO;AAAA,IACrB,MAAM,WAAW,GAAG,QAAQ,UAAU,OAAO;AAAA,IAC7C,MAAM,UAAU,MAAM,GAAG,SAAS,QAAQ;AAAA,IAC1C,MAAM,MAAM,OAAO,KAAK,OAAO,EAAE,SAAS,QAAQ;AAAA,IAElD,MAAM,OAAO,SAAS;AAAA,IACtB,IAAI,CAAC,MAAM;AAAA,MACT,QAAQ,KAAK,EAAE,MAAM,OAAO,MAAM,SAAS,SAAS,IAAI,CAAC;AAAA,IAC3D,EAAO,SAAI,KAAK,YAAY,KAAK;AAAA,MAC/B,QAAQ,KAAK;AAAA,QACX,MAAM;AAAA,QACN,MAAM;AAAA,QACN,SAAS;AAAA,QACT,iBAAiB,KAAK;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,WAAW,gBAAgB,eAAe;AAAA,IACxC,IAAI,CAAC,UAAU,IAAI,YAAY,GAAG;AAAA,MAChC,QAAQ,KAAK;AAAA,QACX,MAAM;AAAA,QACN,MAAM;AAAA,QACN,iBAAiB,SAAS,cAAe;AAAA,MAC3C,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,OAAO,QAAQ,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAAA;",
-  "debugId": "C182915799ABD69764756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEyB,IAAzB;AACkC,IAAlC;AAKO,SAAS,aAAa,CAC3B,QACA,OACA,QAAkB,IAAI,uBACT;AAAA,EACb,MAAM,UAAuB,CAAC;AAAA,EAC9B,MAAM,WAAW,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,MAAM,GAAG,GAAG,OAAO,KAAK,KAAK,CAAC,CAAC;AAAA,EAExE,WAAW,QAAQ,UAAU;AAAA,IAC3B,MAAM,OAAO,OAAO;AAAA,IACpB,MAAM,OAAO,MAAM;AAAA,IAEnB,IAAI,CAAC,QAAQ,MAAM;AAAA,MACjB,QAAQ,KAAK,gBAAgB,OAAO,MAAM,MAAM,WAAW,KAAK,CAAC;AAAA,IACnE,EAAO,SAAI,QAAQ,CAAC,MAAM;AAAA,MACxB,QAAQ,KAAK,gBAAgB,UAAU,MAAM,WAAW,MAAM,KAAK,CAAC;AAAA,IACtE,EAAO,SAAI,QAAQ,QAAQ,CAAC,aAAa,MAAM,IAAI,GAAG;AAAA,MACpD,QAAQ,KAAK,gBAAgB,UAAU,MAAM,MAAM,MAAM,KAAK,CAAC;AAAA,IACjE;AAAA,EACF;AAAA,EAEA,OAAO,QAAQ,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAAA;AAM5D,eAAsB,eAAe,CACnC,IACA,UACA,UACA,QAAkB,IAAI,sBAAS,EAAE,iBAAiB,OAAO,CAAC,GACpC;AAAA,EACtB,MAAM,kBAAkB,MAAM,kCAAkB,IAAI,UAAU;AAAA,IAC5D;AAAA,IACA,cAAc,OAAO,KAAK,QAAQ;AAAA,EACpC,CAAC;AAAA,EACD,OAAO,cAAc,UAAU,iBAAiB,KAAK;AAAA;AAGvD,SAAS,eAAe,CACtB,MACA,MACA,SACA,UACA,OACW;AAAA,EACX,MAAM,aAAa,MAAM,kBAAkB,IAAI;AAAA,EAC/C,MAAM,YAAY,aAAa,WAAW,QAAQ;AAAA,EAClD,MAAM,oBAAoB,WAAW,aAAa,QAAQ,IAAI;AAAA,EAC9D,MAAM,QAAmB;AAAA,IACvB;AAAA,IACA;AAAA,IACA,QAAQ,WAAW;AAAA,IACnB,MAAM,WAAW;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AAAA,EAEA,IAAI,WAAW,SAAS,QAAQ;AAAA,IAC9B,IAAI,YAAY,OAAO,GAAG;AAAA,MACxB,MAAM,UAAU,QAAQ;AAAA,IAC1B;AAAA,IACA,IAAI,YAAY,QAAQ,GAAG;AAAA,MACzB,MAAM,kBAAkB,SAAS;AAAA,IACnC;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAGT,SAAS,YAAY,CAAC,GAAc,GAAuB;AAAA,EACzD,IAAI,aAAa,CAAC,MAAM,aAAa,CAAC;AAAA,IAAG,OAAO;AAAA,EAChD,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,YAAY,CAAC;AAAA,IAAG,OAAO;AAAA,EAC/C,OAAO,EAAE,YAAY,EAAE;AAAA;AAGzB,SAAS,YAAY,CAAC,OAAoD;AAAA,EACxE,OAAO,OAAO,SAAS,cAAc,cAAc;AAAA;AAGrD,SAAS,WAAW,CAAC,OAA8E;AAAA,EACjG,OAAO,CAAC,CAAC,SAAS,MAAM,SAAS;AAAA;",
+  "debugId": "F0849DE3546011FF64756E2164756E21",
   "names": []
 }

package/dist/cjs/src/vcs/index.cjs.map

@@ -2,7 +2,7 @@
   "version": 3,
   "sources": ["../../../../src/vcs/index.ts"],
   "sourcesContent": [
-    "export { VersionControlSystem } from \"./vcs.cjs\";\nexport type {\n  VCSConfig,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  FileEntry,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./types.cjs\";\n"
+    "export { VersionControlSystem } from \"./vcs.cjs\";\nexport type {\n  VCSConfig,\n  VCSAttributeRule,\n  VCSResolvedAttributes,\n  VCSDiffMode,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  TreeEntry,\n  FileEntry,\n  DirectoryEntry,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./types.cjs\";\n"
   ],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAqC,IAArC;",
   "debugId": "882B2013CEEDB5D864756E2164756E21",

package/dist/cjs/src/vcs/rules.cjs

@@ -0,0 +1,180 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/vcs/rules.ts
+var exports_rules = {};
+__export(exports_rules, {
+  matchVCSPath: () => matchVCSPath,
+  VCSRules: () => VCSRules
+});
+module.exports = __toCommonJS(exports_rules);
+var import_match = require("./match.cjs");
+
+class VCSRules {
+  internalPath;
+  ignorePatterns;
+  attributeRules;
+  constructor(config = {}) {
+    this.internalPath = normalizePath(config.internalPath ?? config.internalDirName ?? "");
+    this.ignorePatterns = [...config.ignore ?? []];
+    this.attributeRules = [...config.attributes ?? []];
+  }
+  isInternalPath(relPath) {
+    if (!this.internalPath)
+      return false;
+    const normalizedPath = normalizePath(relPath);
+    if (!normalizedPath)
+      return false;
+    return normalizedPath === this.internalPath || normalizedPath.startsWith(`${this.internalPath}/`);
+  }
+  isIgnored(relPath) {
+    if (this.isInternalPath(relPath))
+      return true;
+    return this.ignorePatterns.some((pattern) => matchVCSPath(pattern, relPath));
+  }
+  shouldEnterDirectory(relPath, trackedPaths) {
+    if (this.isInternalPath(relPath))
+      return false;
+    if (!this.isIgnored(relPath))
+      return true;
+    return hasTrackedPathAtOrBelow(relPath, trackedPaths);
+  }
+  shouldIncludeWorkingFile(relPath, trackedPaths) {
+    if (this.isInternalPath(relPath))
+      return false;
+    if (trackedPaths.has(relPath))
+      return true;
+    return !this.isIgnored(relPath);
+  }
+  shouldIncludeEmptyDirectory(relPath, trackedPaths) {
+    if (this.isInternalPath(relPath))
+      return false;
+    if (trackedPaths.has(relPath))
+      return true;
+    return !this.isIgnored(relPath);
+  }
+  shouldIncludeRestoreScanFile(relPath) {
+    return !this.isInternalPath(relPath);
+  }
+  shouldPreserveUntrackedIgnored(relPath, trackedPaths) {
+    if (trackedPaths.has(relPath))
+      return false;
+    return this.isIgnored(relPath);
+  }
+  resolveAttributes(relPath) {
+    let binary = false;
+    let diff = "text";
+    for (const rule of this.attributeRules) {
+      if (!matchVCSPath(rule.pattern, relPath))
+        continue;
+      if (rule.binary !== undefined) {
+        binary = rule.binary;
+      }
+      if (rule.diff !== undefined) {
+        diff = rule.diff;
+      }
+    }
+    if (diff === "binary") {
+      binary = true;
+    }
+    return { binary, diff };
+  }
+}
+function matchVCSPath(pattern, relPath) {
+  const normalizedPattern = normalizePattern(pattern);
+  const normalizedPath = normalizePath(relPath);
+  if (!normalizedPattern || !normalizedPath)
+    return false;
+  if (normalizedPattern.mode === "root-path") {
+    return import_match.matchGlobPath(normalizedPattern.pattern, normalizedPath);
+  }
+  if (normalizedPattern.mode === "root-segment") {
+    const [firstSegment] = normalizedPath.split("/");
+    return firstSegment ? import_match.matchGlobPath(normalizedPattern.pattern, firstSegment) : false;
+  }
+  if (normalizedPattern.mode === "root-prefix") {
+    return import_match.matchGlobPath(normalizedPattern.pattern, normalizedPath) || import_match.matchGlobPath(`${normalizedPattern.pattern}/**`, normalizedPath);
+  }
+  const segments = normalizedPath.split("/");
+  return segments.some((segment) => import_match.matchGlobPath(normalizedPattern.pattern, segment));
+}
+function normalizePath(relPath) {
+  return relPath.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function normalizePattern(pattern) {
+  let normalized = pattern.trim();
+  if (!normalized)
+    return null;
+  normalized = normalized.replace(/\\/g, "/");
+  const anchored = normalized.startsWith("/");
+  const directoryOnly = normalized.endsWith("/");
+  normalized = normalized.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!normalized)
+    return null;
+  if (normalized.includes("/")) {
+    return {
+      pattern: normalized,
+      mode: directoryOnly ? "root-prefix" : "root-path"
+    };
+  }
+  if (anchored) {
+    return {
+      pattern: normalized,
+      mode: "root-segment"
+    };
+  }
+  return {
+    pattern: normalized,
+    mode: "segment"
+  };
+}
+function hasTrackedPathAtOrBelow(relPath, trackedPaths) {
+  const normalizedPath = normalizePath(relPath);
+  if (!normalizedPath)
+    return false;
+  const prefix = normalizedPath + "/";
+  for (const trackedPath of trackedPaths) {
+    const normalizedTrackedPath = normalizePath(trackedPath);
+    if (normalizedTrackedPath === normalizedPath || normalizedTrackedPath.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+//# debugId=FD722B600498944364756E2164756E21

package/dist/cjs/src/vcs/rules.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/rules.ts"],
+  "sourcesContent": [
+    "import { matchGlobPath } from \"./match.cjs\";\nimport type { VCSAttributeRule, VCSResolvedAttributes } from \"./types.cjs\";\n\ninterface VCSRulesConfig {\n  internalPath?: string;\n  internalDirName?: string;\n  ignore?: string[];\n  attributes?: VCSAttributeRule[];\n}\n\nexport class VCSRules {\n  private readonly internalPath: string;\n  private readonly ignorePatterns: string[];\n  private readonly attributeRules: VCSAttributeRule[];\n\n  constructor(config: VCSRulesConfig = {}) {\n    this.internalPath = normalizePath(config.internalPath ?? config.internalDirName ?? \"\");\n    this.ignorePatterns = [...(config.ignore ?? [])];\n    this.attributeRules = [...(config.attributes ?? [])];\n  }\n\n  isInternalPath(relPath: string): boolean {\n    if (!this.internalPath) return false;\n    const normalizedPath = normalizePath(relPath);\n    if (!normalizedPath) return false;\n    return normalizedPath === this.internalPath || normalizedPath.startsWith(`${this.internalPath}/`);\n  }\n\n  isIgnored(relPath: string): boolean {\n    if (this.isInternalPath(relPath)) return true;\n    return this.ignorePatterns.some((pattern) => matchVCSPath(pattern, relPath));\n  }\n\n  shouldEnterDirectory(relPath: string, trackedPaths: Iterable<string>): boolean {\n    if (this.isInternalPath(relPath)) return false;\n    if (!this.isIgnored(relPath)) return true;\n    return hasTrackedPathAtOrBelow(relPath, trackedPaths);\n  }\n\n  shouldIncludeWorkingFile(relPath: string, trackedPaths: ReadonlySet<string>): boolean {\n    if (this.isInternalPath(relPath)) return false;\n    if (trackedPaths.has(relPath)) return true;\n    return !this.isIgnored(relPath);\n  }\n\n  shouldIncludeEmptyDirectory(relPath: string, trackedPaths: ReadonlySet<string>): boolean {\n    if (this.isInternalPath(relPath)) return false;\n    if (trackedPaths.has(relPath)) return true;\n    return !this.isIgnored(relPath);\n  }\n\n  shouldIncludeRestoreScanFile(relPath: string): boolean {\n    return !this.isInternalPath(relPath);\n  }\n\n  shouldPreserveUntrackedIgnored(relPath: string, trackedPaths: ReadonlySet<string>): boolean {\n    if (trackedPaths.has(relPath)) return false;\n    return this.isIgnored(relPath);\n  }\n\n  resolveAttributes(relPath: string): VCSResolvedAttributes {\n    let binary = false;\n    let diff: VCSResolvedAttributes[\"diff\"] = \"text\";\n\n    for (const rule of this.attributeRules) {\n      if (!matchVCSPath(rule.pattern, relPath)) continue;\n      if (rule.binary !== undefined) {\n        binary = rule.binary;\n      }\n      if (rule.diff !== undefined) {\n        diff = rule.diff;\n      }\n    }\n\n    if (diff === \"binary\") {\n      binary = true;\n    }\n\n    return { binary, diff };\n  }\n}\n\nexport function matchVCSPath(pattern: string, relPath: string): boolean {\n  const normalizedPattern = normalizePattern(pattern);\n  const normalizedPath = normalizePath(relPath);\n\n  if (!normalizedPattern || !normalizedPath) return false;\n\n  if (normalizedPattern.mode === \"root-path\") {\n    return matchGlobPath(normalizedPattern.pattern, normalizedPath);\n  }\n\n  if (normalizedPattern.mode === \"root-segment\") {\n    const [firstSegment] = normalizedPath.split(\"/\");\n    return firstSegment ? matchGlobPath(normalizedPattern.pattern, firstSegment) : false;\n  }\n\n  if (normalizedPattern.mode === \"root-prefix\") {\n    return (\n      matchGlobPath(normalizedPattern.pattern, normalizedPath) ||\n      matchGlobPath(`${normalizedPattern.pattern}/**`, normalizedPath)\n    );\n  }\n\n  const segments = normalizedPath.split(\"/\");\n  return segments.some((segment) => matchGlobPath(normalizedPattern.pattern, segment));\n}\n\nfunction normalizePath(relPath: string): string {\n  return relPath.replace(/\\\\/g, \"/\").replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n}\n\nfunction normalizePattern(pattern: string): {\n  pattern: string;\n  mode: \"root-path\" | \"root-prefix\" | \"root-segment\" | \"segment\";\n} | null {\n  let normalized = pattern.trim();\n  if (!normalized) return null;\n\n  normalized = normalized.replace(/\\\\/g, \"/\");\n  const anchored = normalized.startsWith(\"/\");\n  const directoryOnly = normalized.endsWith(\"/\");\n  normalized = normalized.replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n  if (!normalized) return null;\n\n  if (normalized.includes(\"/\")) {\n    return {\n      pattern: normalized,\n      mode: directoryOnly ? \"root-prefix\" : \"root-path\",\n    };\n  }\n\n  if (anchored) {\n    return {\n      pattern: normalized,\n      mode: \"root-segment\",\n    };\n  }\n\n  return {\n    pattern: normalized,\n    mode: \"segment\",\n  };\n}\n\nfunction hasTrackedPathAtOrBelow(relPath: string, trackedPaths: Iterable<string>): boolean {\n  const normalizedPath = normalizePath(relPath);\n  if (!normalizedPath) return false;\n\n  const prefix = normalizedPath + \"/\";\n  for (const trackedPath of trackedPaths) {\n    const normalizedTrackedPath = normalizePath(trackedPath);\n    if (\n      normalizedTrackedPath === normalizedPath ||\n      normalizedTrackedPath.startsWith(prefix)\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "FD722B600498944364756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/vcs/snapshot.cjs

@@ -44,15 +44,27 @@ __export(exports_snapshot, {
   buildPartialManifest: () => buildPartialManifest
 });
 module.exports = __toCommonJS(exports_snapshot);
+var import_rules = require("./rules.cjs");
 var import_walk = require("./walk.cjs");
-async function buildTreeManifest(fs, rootPath, exclude = []) {
+async function buildTreeManifest(fs, rootPath, options) {
   const manifest = {};
-  const files = await import_walk.walkTree(fs, rootPath, exclude);
-  for (const relPath of files) {
-    const fullPath = fs.resolve(rootPath, relPath);
+  const rules = options?.rules ?? new import_rules.VCSRules({ internalDirName: ".vcs" });
+  const trackedPaths = new Set(options?.trackedPaths ?? []);
+  const entries = await import_walk.walkTreeEntries(fs, rootPath, {
+    enterDirectory: (relPath) => rules.shouldEnterDirectory(relPath, trackedPaths),
+    includeFile: (relPath) => rules.shouldIncludeWorkingFile(relPath, trackedPaths),
+    includeDirectory: (relPath, info) => info.empty && rules.shouldIncludeEmptyDirectory(relPath, trackedPaths)
+  });
+  for (const entry of entries) {
+    if (entry.kind === "directory") {
+      manifest[entry.path] = { kind: "directory", size: 0 };
+      continue;
+    }
+    const fullPath = fs.resolve(rootPath, entry.path);
     const content = await fs.readFile(fullPath);
     const buf = Buffer.from(content);
-    manifest[relPath] = {
+    manifest[entry.path] = {
+      kind: "file",
       content: buf.toString("base64"),
       size: buf.length
     };
@@ -66,11 +78,19 @@ async function buildPartialManifest(fs, rootPath, paths) {
     if (!await fs.exists(fullPath))
       continue;
     const stat = await fs.stat(fullPath);
+    if (stat.isDirectory()) {
+      const entries = await fs.readdir(fullPath);
+      if (entries.length === 0) {
+        manifest[relPath] = { kind: "directory", size: 0 };
+      }
+      continue;
+    }
     if (!stat.isFile())
       continue;
     const content = await fs.readFile(fullPath);
     const buf = Buffer.from(content);
     manifest[relPath] = {
+      kind: "file",
       content: buf.toString("base64"),
       size: buf.length
     };
@@ -79,18 +99,55 @@ async function buildPartialManifest(fs, rootPath, paths) {
 }
 async function restoreTree(fs, rootPath, manifest, options) {
   const fullRestore = options?.fullRestore ?? false;
-  const filterPaths = options?.paths ? new Set(options.paths) : null;
-  for (const [relPath, entry] of Object.entries(manifest)) {
-    if (filterPaths && !filterPaths.has(relPath))
+  const rules = options?.rules ?? new import_rules.VCSRules({ internalDirName: ".vcs" });
+  const trackedPaths = new Set(options?.trackedPaths ?? []);
+  const scopePatterns = options?.paths ?? null;
+  const scopedEntries = Object.entries(manifest).filter(([relPath]) => isPathInScope(relPath, scopePatterns)).sort(([a], [b]) => a.localeCompare(b));
+  const targetPaths = new Set(scopedEntries.map(([relPath]) => relPath));
+  const requiredDirectories = collectRequiredDirectories(scopedEntries);
+  const shouldDeleteExtras = fullRestore || scopePatterns !== null;
+  if (shouldDeleteExtras) {
+    const currentEntries = await import_walk.walkTreeEntries(fs, rootPath, {
+      enterDirectory: (relPath) => !rules.isInternalPath(relPath),
+      includeFile: (relPath) => rules.shouldIncludeRestoreScanFile(relPath),
+      includeDirectory: () => true
+    });
+    for (const current of currentEntries) {
+      if (current.kind !== "file")
+        continue;
+      if (!isPathInScope(current.path, scopePatterns))
+        continue;
+      if (targetPaths.has(current.path))
+        continue;
+      if (rules.shouldPreserveUntrackedIgnored(current.path, trackedPaths))
+        continue;
+      await fs.rm(fs.resolve(rootPath, current.path));
+    }
+  }
+  for (const directory of [...requiredDirectories].sort(comparePathDepth)) {
+    await ensureDirectoryExists(fs, fs.resolve(rootPath, directory));
+  }
+  for (const [relPath, entry] of scopedEntries) {
+    if (isDirectoryEntry(entry)) {
+      await ensureDirectoryExists(fs, fs.resolve(rootPath, relPath));
       continue;
+    }
     await writeFileFromEntry(fs, rootPath, relPath, entry);
   }
-  if (fullRestore) {
-    const exclude = getVcsDirName(rootPath);
-    const currentFiles = await import_walk.walkTree(fs, rootPath, exclude ? [exclude] : []);
-    for (const relPath of currentFiles) {
-      if (!manifest[relPath]) {
-        const fullPath = fs.resolve(rootPath, relPath);
+  if (shouldDeleteExtras) {
+    const currentEntries = await import_walk.walkTreeEntries(fs, rootPath, {
+      enterDirectory: (relPath) => !rules.isInternalPath(relPath),
+      includeFile: () => true,
+      includeDirectory: () => true
+    });
+    const directories = currentEntries.filter((entry) => entry.kind === "directory").map((entry) => entry.path).filter((relPath) => isPathInScope(relPath, scopePatterns)).sort((a, b) => comparePathDepth(b, a));
+    for (const relPath of directories) {
+      if (requiredDirectories.has(relPath))
+        continue;
+      if (rules.shouldPreserveUntrackedIgnored(relPath, trackedPaths))
+        continue;
+      const fullPath = fs.resolve(rootPath, relPath);
+      if (await isEmptyDirectory(fs, fullPath)) {
         await fs.rm(fullPath);
       }
     }
@@ -98,15 +155,74 @@ async function restoreTree(fs, rootPath, manifest, options) {
 }
 async function writeFileFromEntry(fs, rootPath, relPath, entry) {
   const fullPath = fs.resolve(rootPath, relPath);
-  const dir = fs.dirname(fullPath);
-  if (!await fs.exists(dir)) {
-    await fs.mkdir(dir, { recursive: true });
-  }
+  await ensureDirectoryExists(fs, fs.dirname(fullPath));
+  await removeDirectoryAtPath(fs, fullPath);
   const buf = Buffer.from(entry.content, "base64");
   await fs.writeFile(fullPath, buf);
 }
-function getVcsDirName(_rootPath) {
-  return ".vcs";
+function isDirectoryEntry(entry) {
+  return entry.kind === "directory";
+}
+function isPathInScope(relPath, patterns) {
+  if (!patterns || patterns.length === 0)
+    return true;
+  return patterns.some((pattern) => import_rules.matchVCSPath(pattern, relPath));
+}
+function collectRequiredDirectories(entries) {
+  const directories = new Set;
+  for (const [relPath, entry] of entries) {
+    if (isDirectoryEntry(entry)) {
+      directories.add(relPath);
+    }
+    for (const parent of parentDirectories(relPath)) {
+      directories.add(parent);
+    }
+  }
+  return directories;
+}
+function parentDirectories(relPath) {
+  const parts = relPath.split("/").filter(Boolean);
+  const parents = [];
+  for (let i = 1;i < parts.length; i++) {
+    parents.push(parts.slice(0, i).join("/"));
+  }
+  return parents;
+}
+function comparePathDepth(a, b) {
+  const depthA = a.split("/").filter(Boolean).length;
+  const depthB = b.split("/").filter(Boolean).length;
+  if (depthA !== depthB)
+    return depthA - depthB;
+  return a.localeCompare(b);
+}
+async function ensureDirectoryExists(fs, dirPath) {
+  const parent = fs.dirname(dirPath);
+  if (parent !== dirPath) {
+    await ensureDirectoryExists(fs, parent);
+  }
+  if (await fs.exists(dirPath)) {
+    const stat = await fs.stat(dirPath);
+    if (stat.isDirectory())
+      return;
+    await fs.rm(dirPath, { recursive: true, force: true });
+  }
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function removeDirectoryAtPath(fs, path) {
+  if (!await fs.exists(path))
+    return;
+  const stat = await fs.stat(path);
+  if (stat.isDirectory()) {
+    await fs.rm(path, { recursive: true, force: true });
+  }
+}
+async function isEmptyDirectory(fs, dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath);
+    return entries.length === 0;
+  } catch {
+    return false;
+  }
 }
 
-//# debugId=E0FC26F624360D1C64756E2164756E21
+//# debugId=7E15F1F035E56CC164756E2164756E21