shell-dsl 0.0.31 → 0.0.33

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

@@ -0,0 +1,102 @@
+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/diff.ts
+var exports_diff = {};
+__export(exports_diff, {
+  diffWorkingTree: () => diffWorkingTree,
+  diffManifests: () => diffManifests
+});
+module.exports = __toCommonJS(exports_diff);
+var import_walk = require("./walk.cjs");
+function diffManifests(before, after) {
+  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 });
+    } 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
+      });
+    }
+  }
+  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
+      });
+    }
+  }
+  for (const manifestPath of manifestPaths) {
+    if (!seenPaths.has(manifestPath)) {
+      entries.push({
+        type: "delete",
+        path: manifestPath,
+        previousContent: manifest[manifestPath].content
+      });
+    }
+  }
+  return entries.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+//# debugId=C182915799ABD69764756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "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"
+  ],
+  "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",
+  "names": []
+}

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

@@ -0,0 +1,47 @@
+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/index.ts
+var exports_vcs = {};
+__export(exports_vcs, {
+  VersionControlSystem: () => import_vcs.VersionControlSystem
+});
+module.exports = __toCommonJS(exports_vcs);
+var import_vcs = require("./vcs.cjs");
+
+//# debugId=882B2013CEEDB5D864756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "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"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAqC,IAArC;",
+  "debugId": "882B2013CEEDB5D864756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/vcs/match.cjs

@@ -0,0 +1,106 @@
+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/match.ts
+var exports_match = {};
+__export(exports_match, {
+  matchGlobPath: () => matchGlobPath
+});
+module.exports = __toCommonJS(exports_match);
+function matchGlobPath(pattern, filePath) {
+  const p = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+  const f = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+  const patternParts = p.split("/");
+  const pathParts = f.split("/");
+  return matchParts(patternParts, pathParts, 0, 0);
+}
+function matchParts(pattern, path, pi, fi) {
+  while (pi < pattern.length && fi < path.length) {
+    const seg = pattern[pi];
+    if (seg === "**") {
+      for (let i = fi;i <= path.length; i++) {
+        if (matchParts(pattern, path, pi + 1, i))
+          return true;
+      }
+      return false;
+    }
+    if (!matchSegment(seg, path[fi]))
+      return false;
+    pi++;
+    fi++;
+  }
+  while (pi < pattern.length && pattern[pi] === "**")
+    pi++;
+  return pi === pattern.length && fi === path.length;
+}
+function matchSegment(pattern, segment) {
+  let regex = "^";
+  for (let i = 0;i < pattern.length; i++) {
+    const c = pattern[i];
+    switch (c) {
+      case "*":
+        regex += "[^/]*";
+        break;
+      case "?":
+        regex += "[^/]";
+        break;
+      case ".":
+      case "^":
+      case "$":
+      case "+":
+      case "{":
+      case "}":
+      case "(":
+      case ")":
+      case "|":
+      case "\\":
+        regex += "\\" + c;
+        break;
+      default:
+        regex += c;
+    }
+  }
+  regex += "$";
+  try {
+    return new RegExp(regex).test(segment);
+  } catch {
+    return false;
+  }
+}
+
+//# debugId=9C038AE3F1837D4764756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/match.ts"],
+  "sourcesContent": [
+    "/**\n * Match a file path against a glob pattern.\n * Supports `**` for recursive directory matching, `*` for single segment wildcard.\n */\nexport function matchGlobPath(pattern: string, filePath: string): boolean {\n  // Normalize: strip leading slashes\n  const p = pattern.startsWith(\"/\") ? pattern.slice(1) : pattern;\n  const f = filePath.startsWith(\"/\") ? filePath.slice(1) : filePath;\n\n  const patternParts = p.split(\"/\");\n  const pathParts = f.split(\"/\");\n\n  return matchParts(patternParts, pathParts, 0, 0);\n}\n\nfunction matchParts(\n  pattern: string[],\n  path: string[],\n  pi: number,\n  fi: number,\n): boolean {\n  while (pi < pattern.length && fi < path.length) {\n    const seg = pattern[pi]!;\n\n    if (seg === \"**\") {\n      // ** matches zero or more path segments\n      // Try matching rest of pattern against current position and all subsequent positions\n      for (let i = fi; i <= path.length; i++) {\n        if (matchParts(pattern, path, pi + 1, i)) return true;\n      }\n      return false;\n    }\n\n    if (!matchSegment(seg, path[fi]!)) return false;\n    pi++;\n    fi++;\n  }\n\n  // Skip trailing ** patterns\n  while (pi < pattern.length && pattern[pi] === \"**\") pi++;\n\n  return pi === pattern.length && fi === path.length;\n}\n\nfunction matchSegment(pattern: string, segment: string): boolean {\n  // Convert glob segment to regex\n  let regex = \"^\";\n  for (let i = 0; i < pattern.length; i++) {\n    const c = pattern[i]!;\n    switch (c) {\n      case \"*\":\n        regex += \"[^/]*\";\n        break;\n      case \"?\":\n        regex += \"[^/]\";\n        break;\n      case \".\":\n      case \"^\":\n      case \"$\":\n      case \"+\":\n      case \"{\":\n      case \"}\":\n      case \"(\":\n      case \")\":\n      case \"|\":\n      case \"\\\\\":\n        regex += \"\\\\\" + c;\n        break;\n      default:\n        regex += c;\n    }\n  }\n  regex += \"$\";\n\n  try {\n    return new RegExp(regex).test(segment);\n  } catch {\n    return false;\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,SAAS,aAAa,CAAC,SAAiB,UAA2B;AAAA,EAExE,MAAM,IAAI,QAAQ,WAAW,GAAG,IAAI,QAAQ,MAAM,CAAC,IAAI;AAAA,EACvD,MAAM,IAAI,SAAS,WAAW,GAAG,IAAI,SAAS,MAAM,CAAC,IAAI;AAAA,EAEzD,MAAM,eAAe,EAAE,MAAM,GAAG;AAAA,EAChC,MAAM,YAAY,EAAE,MAAM,GAAG;AAAA,EAE7B,OAAO,WAAW,cAAc,WAAW,GAAG,CAAC;AAAA;AAGjD,SAAS,UAAU,CACjB,SACA,MACA,IACA,IACS;AAAA,EACT,OAAO,KAAK,QAAQ,UAAU,KAAK,KAAK,QAAQ;AAAA,IAC9C,MAAM,MAAM,QAAQ;AAAA,IAEpB,IAAI,QAAQ,MAAM;AAAA,MAGhB,SAAS,IAAI,GAAI,KAAK,KAAK,QAAQ,KAAK;AAAA,QACtC,IAAI,WAAW,SAAS,MAAM,KAAK,GAAG,CAAC;AAAA,UAAG,OAAO;AAAA,MACnD;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,CAAC,aAAa,KAAK,KAAK,GAAI;AAAA,MAAG,OAAO;AAAA,IAC1C;AAAA,IACA;AAAA,EACF;AAAA,EAGA,OAAO,KAAK,QAAQ,UAAU,QAAQ,QAAQ;AAAA,IAAM;AAAA,EAEpD,OAAO,OAAO,QAAQ,UAAU,OAAO,KAAK;AAAA;AAG9C,SAAS,YAAY,CAAC,SAAiB,SAA0B;AAAA,EAE/D,IAAI,QAAQ;AAAA,EACZ,SAAS,IAAI,EAAG,IAAI,QAAQ,QAAQ,KAAK;AAAA,IACvC,MAAM,IAAI,QAAQ;AAAA,IAClB,QAAQ;AAAA,WACD;AAAA,QACH,SAAS;AAAA,QACT;AAAA,WACG;AAAA,QACH,SAAS;AAAA,QACT;AAAA,WACG;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,QACH,SAAS,OAAO;AAAA,QAChB;AAAA;AAAA,QAEA,SAAS;AAAA;AAAA,EAEf;AAAA,EACA,SAAS;AAAA,EAET,IAAI;AAAA,IACF,OAAO,IAAI,OAAO,KAAK,EAAE,KAAK,OAAO;AAAA,IACrC,MAAM;AAAA,IACN,OAAO;AAAA;AAAA;",
+  "debugId": "9C038AE3F1837D4764756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,112 @@
+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/snapshot.ts
+var exports_snapshot = {};
+__export(exports_snapshot, {
+  restoreTree: () => restoreTree,
+  buildTreeManifest: () => buildTreeManifest,
+  buildPartialManifest: () => buildPartialManifest
+});
+module.exports = __toCommonJS(exports_snapshot);
+var import_walk = require("./walk.cjs");
+async function buildTreeManifest(fs, rootPath, exclude = []) {
+  const manifest = {};
+  const files = await import_walk.walkTree(fs, rootPath, exclude);
+  for (const relPath of files) {
+    const fullPath = fs.resolve(rootPath, relPath);
+    const content = await fs.readFile(fullPath);
+    const buf = Buffer.from(content);
+    manifest[relPath] = {
+      content: buf.toString("base64"),
+      size: buf.length
+    };
+  }
+  return manifest;
+}
+async function buildPartialManifest(fs, rootPath, paths) {
+  const manifest = {};
+  for (const relPath of paths) {
+    const fullPath = fs.resolve(rootPath, relPath);
+    if (!await fs.exists(fullPath))
+      continue;
+    const stat = await fs.stat(fullPath);
+    if (!stat.isFile())
+      continue;
+    const content = await fs.readFile(fullPath);
+    const buf = Buffer.from(content);
+    manifest[relPath] = {
+      content: buf.toString("base64"),
+      size: buf.length
+    };
+  }
+  return manifest;
+}
+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))
+      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);
+        await fs.rm(fullPath);
+      }
+    }
+  }
+}
+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 });
+  }
+  const buf = Buffer.from(entry.content, "base64");
+  await fs.writeFile(fullPath, buf);
+}
+function getVcsDirName(_rootPath) {
+  return ".vcs";
+}
+
+//# debugId=E0FC26F624360D1C64756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/snapshot.ts"],
+  "sourcesContent": [
+    "import type { VirtualFS } from \"../types.cjs\";\nimport type { TreeManifest, FileEntry } from \"./types.cjs\";\nimport { walkTree } from \"./walk.cjs\";\n\n/**\n * Build a TreeManifest from the current working tree.\n */\nexport async function buildTreeManifest(\n  fs: VirtualFS,\n  rootPath: string,\n  exclude: string[] = [],\n): Promise<TreeManifest> {\n  const manifest: TreeManifest = {};\n  const files = await walkTree(fs, rootPath, exclude);\n\n  for (const relPath of files) {\n    const fullPath = fs.resolve(rootPath, relPath);\n    const content = await fs.readFile(fullPath);\n    const buf = Buffer.from(content);\n    manifest[relPath] = {\n      content: buf.toString(\"base64\"),\n      size: buf.length,\n    };\n  }\n\n  return manifest;\n}\n\n/**\n * Build a TreeManifest for only the specified relative paths.\n */\nexport async function buildPartialManifest(\n  fs: VirtualFS,\n  rootPath: string,\n  paths: string[],\n): Promise<TreeManifest> {\n  const manifest: TreeManifest = {};\n\n  for (const relPath of paths) {\n    const fullPath = fs.resolve(rootPath, relPath);\n    if (!(await fs.exists(fullPath))) continue;\n    const stat = await fs.stat(fullPath);\n    if (!stat.isFile()) continue;\n\n    const content = await fs.readFile(fullPath);\n    const buf = Buffer.from(content);\n    manifest[relPath] = {\n      content: buf.toString(\"base64\"),\n      size: buf.length,\n    };\n  }\n\n  return manifest;\n}\n\n/**\n * Restore a working tree from a TreeManifest.\n *\n * If `fullRestore` is true, deletes working tree files not in the manifest.\n * If `paths` is provided, only restores matching files.\n */\nexport async function restoreTree(\n  fs: VirtualFS,\n  rootPath: string,\n  manifest: TreeManifest,\n  options?: { fullRestore?: boolean; paths?: string[] },\n): Promise<void> {\n  const fullRestore = options?.fullRestore ?? false;\n  const filterPaths = options?.paths ? new Set(options.paths) : null;\n\n  // Write files from manifest\n  for (const [relPath, entry] of Object.entries(manifest)) {\n    if (filterPaths && !filterPaths.has(relPath)) continue;\n    await writeFileFromEntry(fs, rootPath, relPath, entry);\n  }\n\n  // Delete files not in manifest (full restore only)\n  if (fullRestore) {\n    const exclude = getVcsDirName(rootPath);\n    const currentFiles = await walkTree(fs, rootPath, exclude ? [exclude] : []);\n\n    for (const relPath of currentFiles) {\n      if (!manifest[relPath]) {\n        const fullPath = fs.resolve(rootPath, relPath);\n        await fs.rm(fullPath);\n      }\n    }\n  }\n}\n\nasync function writeFileFromEntry(\n  fs: VirtualFS,\n  rootPath: string,\n  relPath: string,\n  entry: FileEntry,\n): Promise<void> {\n  const fullPath = fs.resolve(rootPath, relPath);\n  const dir = fs.dirname(fullPath);\n\n  // Ensure parent directory exists\n  if (!(await fs.exists(dir))) {\n    await fs.mkdir(dir, { recursive: true });\n  }\n\n  const buf = Buffer.from(entry.content, \"base64\");\n  await fs.writeFile(fullPath, buf);\n}\n\nfunction getVcsDirName(_rootPath: string): string | null {\n  return \".vcs\";\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEyB,IAAzB;AAKA,eAAsB,iBAAiB,CACrC,IACA,UACA,UAAoB,CAAC,GACE;AAAA,EACvB,MAAM,WAAyB,CAAC;AAAA,EAChC,MAAM,QAAQ,MAAM,qBAAS,IAAI,UAAU,OAAO;AAAA,EAElD,WAAW,WAAW,OAAO;AAAA,IAC3B,MAAM,WAAW,GAAG,QAAQ,UAAU,OAAO;AAAA,IAC7C,MAAM,UAAU,MAAM,GAAG,SAAS,QAAQ;AAAA,IAC1C,MAAM,MAAM,OAAO,KAAK,OAAO;AAAA,IAC/B,SAAS,WAAW;AAAA,MAClB,SAAS,IAAI,SAAS,QAAQ;AAAA,MAC9B,MAAM,IAAI;AAAA,IACZ;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAMT,eAAsB,oBAAoB,CACxC,IACA,UACA,OACuB;AAAA,EACvB,MAAM,WAAyB,CAAC;AAAA,EAEhC,WAAW,WAAW,OAAO;AAAA,IAC3B,MAAM,WAAW,GAAG,QAAQ,UAAU,OAAO;AAAA,IAC7C,IAAI,CAAE,MAAM,GAAG,OAAO,QAAQ;AAAA,MAAI;AAAA,IAClC,MAAM,OAAO,MAAM,GAAG,KAAK,QAAQ;AAAA,IACnC,IAAI,CAAC,KAAK,OAAO;AAAA,MAAG;AAAA,IAEpB,MAAM,UAAU,MAAM,GAAG,SAAS,QAAQ;AAAA,IAC1C,MAAM,MAAM,OAAO,KAAK,OAAO;AAAA,IAC/B,SAAS,WAAW;AAAA,MAClB,SAAS,IAAI,SAAS,QAAQ;AAAA,MAC9B,MAAM,IAAI;AAAA,IACZ;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAST,eAAsB,WAAW,CAC/B,IACA,UACA,UACA,SACe;AAAA,EACf,MAAM,cAAc,SAAS,eAAe;AAAA,EAC5C,MAAM,cAAc,SAAS,QAAQ,IAAI,IAAI,QAAQ,KAAK,IAAI;AAAA,EAG9D,YAAY,SAAS,UAAU,OAAO,QAAQ,QAAQ,GAAG;AAAA,IACvD,IAAI,eAAe,CAAC,YAAY,IAAI,OAAO;AAAA,MAAG;AAAA,IAC9C,MAAM,mBAAmB,IAAI,UAAU,SAAS,KAAK;AAAA,EACvD;AAAA,EAGA,IAAI,aAAa;AAAA,IACf,MAAM,UAAU,cAAc,QAAQ;AAAA,IACtC,MAAM,eAAe,MAAM,qBAAS,IAAI,UAAU,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC;AAAA,IAE1E,WAAW,WAAW,cAAc;AAAA,MAClC,IAAI,CAAC,SAAS,UAAU;AAAA,QACtB,MAAM,WAAW,GAAG,QAAQ,UAAU,OAAO;AAAA,QAC7C,MAAM,GAAG,GAAG,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AAAA;AAGF,eAAe,kBAAkB,CAC/B,IACA,UACA,SACA,OACe;AAAA,EACf,MAAM,WAAW,GAAG,QAAQ,UAAU,OAAO;AAAA,EAC7C,MAAM,MAAM,GAAG,QAAQ,QAAQ;AAAA,EAG/B,IAAI,CAAE,MAAM,GAAG,OAAO,GAAG,GAAI;AAAA,IAC3B,MAAM,GAAG,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAAA,EAEA,MAAM,MAAM,OAAO,KAAK,MAAM,SAAS,QAAQ;AAAA,EAC/C,MAAM,GAAG,UAAU,UAAU,GAAG;AAAA;AAGlC,SAAS,aAAa,CAAC,WAAkC;AAAA,EACvD,OAAO;AAAA;",
+  "debugId": "E0FC26F624360D1C64756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/vcs/storage.cjs

@@ -0,0 +1,120 @@
+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/storage.ts
+var exports_storage = {};
+__export(exports_storage, {
+  VCSStorage: () => VCSStorage
+});
+module.exports = __toCommonJS(exports_storage);
+
+class VCSStorage {
+  fs;
+  basePath;
+  constructor(fs, basePath) {
+    this.fs = fs;
+    this.basePath = basePath;
+  }
+  path(...segments) {
+    return this.fs.resolve(this.basePath, ...segments);
+  }
+  async isInitialized() {
+    return this.fs.exists(this.path("HEAD"));
+  }
+  async initialize(defaultBranch = "main") {
+    await this.fs.mkdir(this.basePath, { recursive: true });
+    await this.fs.mkdir(this.path("refs", "heads"), { recursive: true });
+    await this.fs.mkdir(this.path("revisions"), { recursive: true });
+    await this.writeHead({ ref: `refs/heads/${defaultBranch}` });
+    await this.writeJSON(["counter.json"], { next: 1 });
+    await this.writeJSON(["config.json"], { defaultBranch });
+  }
+  async readHead() {
+    return this.readJSON("HEAD");
+  }
+  async writeHead(head) {
+    await this.writeJSON(["HEAD"], head);
+  }
+  async readBranch(name) {
+    const branchPath = this.path("refs", "heads", name);
+    if (!await this.fs.exists(branchPath))
+      return null;
+    return this.readJSON("refs", "heads", name);
+  }
+  async writeBranch(name, ref) {
+    await this.writeJSON(["refs", "heads", name], ref);
+  }
+  async deleteBranch(name) {
+    const branchPath = this.path("refs", "heads", name);
+    await this.fs.rm(branchPath);
+  }
+  async listBranches() {
+    const headsPath = this.path("refs", "heads");
+    try {
+      return await this.fs.readdir(headsPath);
+    } catch {
+      return [];
+    }
+  }
+  async readRevision(id) {
+    return this.readJSON("revisions", `${id}.json`);
+  }
+  async writeRevision(rev) {
+    await this.writeJSON(["revisions", `${rev.id}.json`], rev);
+  }
+  async nextRevisionId() {
+    const counter = await this.readJSON("counter.json");
+    const id = counter.next;
+    await this.writeJSON(["counter.json"], { next: id + 1 });
+    return id;
+  }
+  async readConfig() {
+    return this.readJSON("config.json");
+  }
+  async readJSON(...segments) {
+    const filePath = this.path(...segments);
+    const content = await this.fs.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  }
+  async writeJSON(segments, data) {
+    const filePath = this.path(...segments);
+    await this.fs.writeFile(filePath, JSON.stringify(data, null, 2));
+  }
+}
+
+//# debugId=E27DBCC23E16A74564756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/storage.ts"],
+  "sourcesContent": [
+    "import type { VirtualFS } from \"../types.cjs\";\nimport type {\n  HeadRef,\n  BranchRef,\n  RevisionCounter,\n  VCSConfigFile,\n  Revision,\n} from \"./types.cjs\";\n\nexport class VCSStorage {\n  constructor(\n    private readonly fs: VirtualFS,\n    private readonly basePath: string,\n  ) {}\n\n  private path(...segments: string[]): string {\n    return this.fs.resolve(this.basePath, ...segments);\n  }\n\n  // --- Init ---\n\n  async isInitialized(): Promise<boolean> {\n    return this.fs.exists(this.path(\"HEAD\"));\n  }\n\n  async initialize(defaultBranch: string = \"main\"): Promise<void> {\n    await this.fs.mkdir(this.basePath, { recursive: true });\n    await this.fs.mkdir(this.path(\"refs\", \"heads\"), { recursive: true });\n    await this.fs.mkdir(this.path(\"revisions\"), { recursive: true });\n\n    await this.writeHead({ ref: `refs/heads/${defaultBranch}` });\n    await this.writeJSON([\"counter.json\"], { next: 1 } satisfies RevisionCounter);\n    await this.writeJSON([\"config.json\"], { defaultBranch } satisfies VCSConfigFile);\n  }\n\n  // --- HEAD ---\n\n  async readHead(): Promise<HeadRef> {\n    return this.readJSON<HeadRef>(\"HEAD\");\n  }\n\n  async writeHead(head: HeadRef): Promise<void> {\n    await this.writeJSON([\"HEAD\"], head);\n  }\n\n  // --- Branches ---\n\n  async readBranch(name: string): Promise<BranchRef | null> {\n    const branchPath = this.path(\"refs\", \"heads\", name);\n    if (!(await this.fs.exists(branchPath))) return null;\n    return this.readJSON<BranchRef>(\"refs\", \"heads\", name);\n  }\n\n  async writeBranch(name: string, ref: BranchRef): Promise<void> {\n    await this.writeJSON([\"refs\", \"heads\", name], ref);\n  }\n\n  async deleteBranch(name: string): Promise<void> {\n    const branchPath = this.path(\"refs\", \"heads\", name);\n    await this.fs.rm(branchPath);\n  }\n\n  async listBranches(): Promise<string[]> {\n    const headsPath = this.path(\"refs\", \"heads\");\n    try {\n      return await this.fs.readdir(headsPath);\n    } catch {\n      return [];\n    }\n  }\n\n  // --- Revisions ---\n\n  async readRevision(id: number): Promise<Revision> {\n    return this.readJSON<Revision>(\"revisions\", `${id}.json`);\n  }\n\n  async writeRevision(rev: Revision): Promise<void> {\n    await this.writeJSON([\"revisions\", `${rev.id}.json`], rev);\n  }\n\n  // --- Counter ---\n\n  async nextRevisionId(): Promise<number> {\n    const counter = await this.readJSON<RevisionCounter>(\"counter.json\");\n    const id = counter.next;\n    await this.writeJSON([\"counter.json\"], { next: id + 1 } satisfies RevisionCounter);\n    return id;\n  }\n\n  // --- Config ---\n\n  async readConfig(): Promise<VCSConfigFile> {\n    return this.readJSON<VCSConfigFile>(\"config.json\");\n  }\n\n  // --- Helpers ---\n\n  private async readJSON<T>(...segments: string[]): Promise<T> {\n    const filePath = this.path(...segments);\n    const content = await this.fs.readFile(filePath, \"utf8\");\n    return JSON.parse(content) as T;\n  }\n\n  private async writeJSON(segments: string[], data: unknown): Promise<void> {\n    const filePath = this.path(...segments);\n    await this.fs.writeFile(filePath, JSON.stringify(data, null, 2));\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "E27DBCC23E16A74564756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/vcs/types.cjs

@@ -0,0 +1,30 @@
+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;
+
+// src/vcs/types.ts
+var exports_types = {};
+module.exports = __toCommonJS(exports_types);
+
+//# debugId=0D69226887DD202F64756E2164756E21

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

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "0D69226887DD202F64756E2164756E21",
+  "names": []
+}