@openclaw/fs-safe 0.4.0 → 0.4.2

package/docs/advanced.md

@@ -55,6 +55,7 @@ Operational filesystem failures such as permissions or I/O errors are rethrown.
 
 | Export | Page | Notes |
 |---|---|---|
+| `readFileDescriptorBounded`, `readFileDescriptorBoundedSync`, `readFileHandleBounded` | – | Incremental whole-file reads for already-open descriptors/handles. They consume at most `maxBytes + 1`, do not close the input, and throw `FsSafeError("too-large")` on overflow. |
 | `openRootFile`, `openRootFileSync`, `canUseRootFileOpen`, `matchRootFileOpenFailure`, related types | – | Low-level no-follow open routed through the root-file path. |
 | `appendRegularFile`, `appendRegularFileSync`, `readRegularFile`, `readRegularFileSync`, `statRegularFile`, `statRegularFileSync`, `resolveRegularFileAppendFlags`, `AppendRegularFileOptions`, `RegularFileStatResult` | [regular-file.md](regular-file.md) | Type-checked regular-file I/O. |
 | `sameFileIdentity`, `FileIdentityStat` | – | Compare two stats for same-inode equality. |
@@ -62,6 +63,25 @@ Operational filesystem failures such as permissions or I/O errors are rethrown.
 | `assertNoSymlinkParents`, `assertNoSymlinkParentsSync`, `AssertNoSymlinkParentsOptions` | – | Reject paths whose ancestor chain contains symlinks. |
 | `assertNoHardlinkedFinalPath`, `assertNoPathAliasEscape`, `PATH_ALIAS_POLICIES`, `PathAliasPolicy` | – | Hardlink/alias defense building blocks. |
 
+The bounded descriptor helpers start at the descriptor's current offset and
+leave ownership with the caller. They are intended for the second half of a
+safe read: first open and validate the path using the boundary appropriate to
+your application, then read the already-pinned descriptor without trusting a
+possibly stale size check.
+
+```ts
+import fs from "node:fs";
+import { readFileDescriptorBoundedSync } from "@openclaw/fs-safe/advanced";
+
+const fd = fs.openSync(filePath, "r");
+try {
+  const bytes = readFileDescriptorBoundedSync(fd, 256 * 1024);
+  consume(bytes);
+} finally {
+  fs.closeSync(fd);
+}
+```
+
 ### Local roots and file URLs
 
 | Export | Page | Notes |

package/docs/config.md

@@ -56,7 +56,7 @@ Return the effective configuration: programmatic overrides win, then env vars, t
 function configureFsSafeLocks(config: Partial<FsSafeLockConfig>): void;
 
 type FsSafeLockConfig = {
-  staleRecovery: "fail-closed" | "remove-if-unchanged";
+  staleRecovery: "fail-closed" | "remove-if-unchanged"; // legacy value also fails closed
   staleMs?: number;
   timeoutMs?: number;
   retry?: FileLockRetryOptions;
@@ -65,7 +65,7 @@ type FsSafeLockConfig = {
 
 Set process-wide defaults for sidecar lock options. This does **not** turn locking on globally; callers still need to pass `lock: true` or a lock options object for the specific JSON store/resource that needs cross-process coordination.
 
-`staleRecovery` defaults to `"fail-closed"`. `"remove-if-unchanged"` is available for callers that also pass `shouldRemoveStaleLock`; fs-safe re-reads the observed sidecar and removes it only when the raw content and file identity still match.
+`staleRecovery` defaults to `"fail-closed"`. The deprecated `"remove-if-unchanged"` value remains accepted for source and configuration compatibility, but behaves as `"fail-closed"`. fs-safe never removes a stale third-party lock during acquisition because a pathname recheck followed by unlink cannot prevent deleting a replacement lock.
 
 ## `getFsSafeLockConfig()`
 

package/docs/index.md

@@ -64,7 +64,7 @@ await fs.remove("notes/archive/today.txt");
 | [`extractArchive`](archive.md) | ZIP/TAR extraction with size, count, link, and traversal limits. |
 | [Secret files](secret-file.md) | Mode-0600 credentials with size and TOCTOU defense. |
 | [Permissions](permissions.md) | POSIX mode and Windows ACL inspection/remediation helpers. |
-| [`acquireFileLock`](sidecar-lock.md) | Cross-process file lock with retry, fail-closed stale-lock handling, and opt-in caller-approved stale removal. |
+| [`acquireFileLock`](sidecar-lock.md) | Cross-process file lock with retry and fail-closed stale-lock handling. |
 | [`FsSafeError`](errors.md) | Closed code union (with `policy` / `operational` category) you can branch on. |
 | [`pathScope()`](path-scope.md) | Lower-level absolute-path boundary helper; lives behind `@openclaw/fs-safe/advanced`. |
 | [`@openclaw/fs-safe/advanced`](advanced.md) | Directory of lower-level composition helpers (path scopes, regular-file I/O, install paths, sibling-temp writes, …). |

package/docs/json-store.md

@@ -53,7 +53,7 @@ type JsonStoreLockOptions = {
   staleMs?: number;     // default 30_000
   timeoutMs?: number;   // default 30_000
   retry?: FileLockRetryOptions;
-  staleRecovery?: "fail-closed" | "remove-if-unchanged";
+  staleRecovery?: "fail-closed" | "remove-if-unchanged"; // legacy value also fails closed
   managerKey?: string;  // default `fs-safe.json-store:<filePath>`
 };
 
@@ -141,7 +141,7 @@ When `lock` is falsy, `read` / `write` / `update` are unlocked. The `update` sha
 
 Process-wide lock defaults from `configureFsSafeLocks()` apply only after locking is explicitly enabled. They do not make JSON stores lock by default.
 
-JSON store locks do not expose `shouldRemoveStaleLock`, so `staleRecovery: "remove-if-unchanged"` cannot remove a stale sidecar by itself. Use the lower-level [file lock](sidecar-lock.md) API when your application needs custom owner-liveness checks and caller-approved stale-lock removal.
+JSON store locks always fail closed on stale sidecars. The deprecated `staleRecovery: "remove-if-unchanged"` value remains accepted for compatibility, but it behaves as `"fail-closed"` and never removes the lock.
 
 The default `managerKey` namespaces the in-process `FileLockManager` per absolute file path, so two `jsonStore` calls on the same file share lock state automatically.
 

package/docs/json.md

@@ -40,15 +40,22 @@ Use `readJson` when missing-or-malformed is a programmer error you want to surfa
 
 ## Reading
 
-### `readJson<T>(filePath)`
+### `readJson<T>(filePath, options?)`
 
 Async strict reader. Throws `JsonFileReadError` on missing or invalid input. The cast is unchecked — validate the shape with your own schema (zod, valibot, …) if it came from an untrusted source.
 
 ```ts
 const manifest = await readJson<Manifest>("./manifest.json");
+const smallManifest = await readJson<Manifest>("./manifest.json", {
+  maxBytes: 256 * 1024,
+});
 ```
 
-### `readJsonIfExists<T>(filePath)`
+All standalone readers accept `{ maxBytes?: number }`. When set, the read is
+incremental and consumes no more than `maxBytes + 1` bytes before rejecting, so
+file growth after the initial stat cannot cause an unbounded allocation.
+
+### `readJsonIfExists<T>(filePath, options?)`
 
 Async semi-lenient reader. Returns `null` if the file is missing; throws `JsonFileReadError` if the file exists but cannot be parsed.
 
@@ -56,7 +63,7 @@ Async semi-lenient reader. Returns `null` if the file is missing; throws `JsonFi
 const cache = (await readJsonIfExists<Cache>("./cache.json")) ?? freshCache();
 ```
 
-### `tryReadJson<T>(filePath)`
+### `tryReadJson<T>(filePath, options?)`
 
 Async lenient reader. Returns `null` for any failure (missing, unreadable, invalid). The "no fuss" sibling.
 
@@ -64,11 +71,11 @@ Async lenient reader. Returns `null` for any failure (missing, unreadable, inval
 const optional = (await tryReadJson<Settings>("./settings.json")) ?? defaults;
 ```
 
-### `readJsonSync<T>(filePath)`
+### `readJsonSync<T>(filePath, options?)`
 
 Synchronous strict reader. Throws `JsonFileReadError` on missing or invalid input, matching the async `readJson` contract.
 
-### `tryReadJsonSync<T>(pathname)`
+### `tryReadJsonSync<T>(pathname, options?)`
 
 Synchronous, generic, lenient. Returns `T | null`. Useful in boot paths where you want a typed result without async.
 
@@ -83,6 +90,7 @@ const result = readRootJsonObjectSync({
   rootDir: "/safe/workspace",
   relativePath: "plugin/openclaw.plugin.json",
   boundaryLabel: "plugin manifest",
+  maxBytes: 256 * 1024,
 });
 
 if (!result.ok) {

package/docs/regular-file.md

@@ -32,14 +32,14 @@ type RegularFileStatResult =
   | { missing: false; stat: Stats };
 ```
 
-A non-regular file (directory, FIFO, …) returns `{ missing: false }` with a `stat` whose `isFile()` is false — the helper does not throw, you decide what to do.
+A non-regular file (directory, FIFO, symlink, …) throws. Missing paths return
+`{ missing: true }`; existing regular files return `{ missing: false, stat }`.
 
 ```ts
 import { statRegularFile } from "@openclaw/fs-safe/advanced";
 
 const r = await statRegularFile("/var/log/app.log");
 if (r.missing) return;
-if (!r.stat.isFile()) throw new Error("expected a regular file");
 console.log(`size=${r.stat.size}`);
 ```
 
@@ -60,19 +60,11 @@ const result = await readRegularFile({
   filePath: "/var/log/app.log",
   maxBytes: 4 * 1024 * 1024,
 });
-if (result.missing) return null;
-if (!result.regular) throw new Error("not a regular file");
 processLog(result.buffer);
 ```
 
-Result shape:
-
-```ts
-type Result =
-  | { missing: true }
-  | { missing: false; regular: false; stat: Stats }
-  | { missing: false; regular: true; stat: Stats; buffer: Buffer };
-```
+The result is `{ buffer, stat }`. Missing files preserve the normal `ENOENT`
+shape; non-regular targets throw.
 
 Throws `FsSafeError` with code `too-large` if the file exceeds `maxBytes`. Other I/O errors propagate as `NodeJS.ErrnoException`.
 
@@ -91,9 +83,8 @@ import { appendRegularFile } from "@openclaw/fs-safe/advanced";
 
 await appendRegularFile({
   filePath: "/var/log/app.log",
-  data: `[${new Date().toISOString()}] ${line}\n`,
+  content: `[${new Date().toISOString()}] ${line}\n`,
   encoding: "utf8",
-  prependNewlineIfNeeded: true,
 });
 ```
 
@@ -102,28 +93,30 @@ await appendRegularFile({
 ```ts
 type AppendRegularFileOptions = {
   filePath: string;
-  data: string | Buffer;
-  encoding?: BufferEncoding;             // default utf8 when data is string
-  prependNewlineIfNeeded?: boolean;      // insert "\n" if file does not end with one
-  flags?: number;                         // raw open flags; default O_WRONLY | O_APPEND
-  mode?: number;                          // default 0o644 if file is created
+  content: string | Uint8Array;
+  encoding?: BufferEncoding; // default utf8 when content is string
+  maxFileBytes?: number;     // skip if the resulting file would exceed this
+  mode?: number;             // default 0o600
+  rejectSymlinkParents?: boolean;
 };
 ```
 
-`prependNewlineIfNeeded` reads the trailing byte of the existing file and prepends a `\n` to your data if it isn't already present. Useful for log appenders that want to preserve line boundaries even when callers forget the newline.
+The helper refuses symlink and hardlinked final targets. With
+`rejectSymlinkParents: true`, it also rejects symlinked ancestor directories.
 
 ### `appendRegularFileSync(options)`
 
 Synchronous. Same options.
 
-### `resolveRegularFileAppendFlags(append, truncateExisting)`
+### `resolveRegularFileAppendFlags()`
 
-Helper that returns the right open-flag bitmask for combinations of "append" / "truncate". Use it when you're building your own open path and want to match the append helpers' behavior:
+Helper that returns the append helpers' `O_WRONLY | O_APPEND | O_CREAT` flags,
+plus `O_NOFOLLOW` where the platform provides it:
 
 ```ts
 import { resolveRegularFileAppendFlags } from "@openclaw/fs-safe/advanced";
 
-const flags = resolveRegularFileAppendFlags(true, false); // O_WRONLY | O_APPEND | O_CREAT
+const flags = resolveRegularFileAppendFlags();
 ```
 
 ## Difference from `Root` methods
@@ -131,9 +124,9 @@ const flags = resolveRegularFileAppendFlags(true, false); // O_WRONLY | O_APPEND
 | `regular-file` | `Root` |
 |---|---|
 | Absolute paths only. | Relative to the root. |
-| No identity check post-open. | Identity check on every read/write. |
+| Verifies path and descriptor identity around reads. | Enforces the same checks within a trusted root. |
 | Caller must be confident the path is trusted. | Boundary check is automatic. |
-| Returns explicit `{missing, regular}` shape. | Throws `FsSafeError` with `code`. |
+| Stat reports missing explicitly; reads throw on missing/non-file. | Throws `FsSafeError` with `code`. |
 
 If your call site already trusts the path (it came from your own config, not a caller), `regular-file` is a thinner, faster surface. If the path is caller-influenced, prefer `root()` or wrap in [`pathScope()`](path-scope.md).
 
@@ -142,13 +135,15 @@ If your call site already trusts the path (it came from your own config, not a c
 ### Read a config file if it's there, else seed
 
 ```ts
-const r = await readRegularFile({ filePath: "/etc/app/config.json", maxBytes: 64 * 1024 });
-if (r.missing) {
+const info = await statRegularFile("/etc/app/config.json");
+if (info.missing) {
   await writeJson("/etc/app/config.json", defaultConfig);
-} else if (r.regular) {
-  applyConfig(JSON.parse(r.buffer.toString("utf8")));
 } else {
-  throw new Error("/etc/app/config.json is not a regular file");
+  const r = await readRegularFile({
+    filePath: "/etc/app/config.json",
+    maxBytes: 64 * 1024,
+  });
+  applyConfig(JSON.parse(r.buffer.toString("utf8")));
 }
 ```
 
@@ -156,7 +151,7 @@ if (r.missing) {
 
 ```ts
 const r = await statRegularFile(p);
-if (r.missing || !r.stat.isFile()) return false;
+if (r.missing) return false;
 return true;
 ```
 
@@ -164,7 +159,6 @@ return true;
 
 ```ts
 const r = await readRegularFile({ filePath: logPath, maxBytes: 1 * 1024 * 1024 });
-if (r.missing || !r.regular) return [];
 return r.buffer.toString("utf8").split("\n").slice(-100);
 ```
 

package/docs/security-model.md

@@ -90,6 +90,7 @@ The library does not advertise different security guarantees per platform — it
 | Mode bits are not a full policy engine | `replaceFileAtomic` and secret-file helpers set requested modes, but you should still set umask and inspect modes when policy requires it. |
 | Archive extraction is path safety, not content safety | Unsafe entry paths and links are rejected; malicious payload contents remain your application layer's problem. |
 | Helper failures degrade fd-relative hardening | `helper-unavailable` falls back in `auto` mode and fails closed in `require` mode. Atomicity and identity checks remain, but parent-directory swaps between validation and mutation are less tightly pinned without the helper. |
+| FUSE mounts with rename-unstable inode numbers | Some FUSE mounts (rclone is a confirmed example) do not preserve source inode identity at the rename destination. The explicit `renameIdentity: "verify-content-with-lock"` compatibility mode verifies content under a cooperative lock for that boundary only; subsequent path identity checks and the default remain strict. See [Writing](writing.md) for the weaker opt-in contract. |
 
 ## Recommended deployment shape
 

package/docs/sidecar-lock.md

@@ -51,7 +51,7 @@ type FileLockAcquireOptions<TPayload extends Record<string, unknown>> = {
   staleMs?: number;                      // default 30_000
   timeoutMs?: number;                    // overall acquire deadline; default unbounded
   retry?: FileLockRetryOptions;
-  staleRecovery?: "fail-closed" | "remove-if-unchanged"; // default "fail-closed"
+  staleRecovery?: "fail-closed" | "remove-if-unchanged"; // legacy value also fails closed
   allowReentrant?: boolean;              // if this process already holds it, increment a count instead of failing
   payload: () => TPayload | Promise<TPayload>;
   shouldReclaim?: (params: {
@@ -62,7 +62,7 @@ type FileLockAcquireOptions<TPayload extends Record<string, unknown>> = {
     nowMs: number;
     heldByThisProcess: boolean;
   }) => boolean | Promise<boolean>;
-  shouldRemoveStaleLock?: (snapshot: {
+  shouldRemoveStaleLock?: (snapshot: {          // deprecated; retained but not invoked
     lockPath: string;
     normalizedTargetPath: string;
     raw: string;
@@ -170,40 +170,24 @@ const handle = await acquireFileLock(targetPath, {
 });
 ```
 
-`heldByThisProcess` is true when this manager already holds the lock (relevant for the reentrant case). A `true` result marks the observed sidecar as stale; `staleRecovery` then decides whether acquisition fails closed or tries caller-approved removal.
+`heldByThisProcess` is true when this manager already holds the lock (relevant for the reentrant case). A `true` result marks the observed sidecar as stale and acquisition throws an error with code `file_lock_stale`.
 
-## Stale recovery: `remove-if-unchanged`
+## Stale recovery is fail-closed
 
-The default `staleRecovery: "fail-closed"` never removes third-party sidecars. Use `staleRecovery: "remove-if-unchanged"` only when your app has a reliable owner-liveness policy and can prove a stale owner cannot still be writing.
+fs-safe never removes a stale third-party sidecar during acquisition. Checking a pathname's content and identity before unlinking it is not atomic: another process can replace the lock between the final check and the unlink. Every stale result therefore fails closed with error code `file_lock_stale`.
 
-```ts
-const handle = await acquireFileLock(targetPath, {
-  staleMs: 60_000,
-  staleRecovery: "remove-if-unchanged",
-  payload: () => ({ pid: process.pid, createdAt: new Date().toISOString() }),
-  shouldReclaim: ({ payload }) => {
-    const pid = Number(payload?.pid);
-    return Number.isInteger(pid) && pid > 0 && ownerIsDefinitelyDead(pid);
-  },
-  shouldRemoveStaleLock: ({ payload }) => {
-    const pid = Number(payload?.pid);
-    return Number.isInteger(pid) && pid > 0 && ownerIsDefinitelyDead(pid);
-  },
-});
-```
-
-`shouldRemoveStaleLock` receives the exact lock snapshot that `fs-safe` inspected. `fs-safe` re-reads the sidecar and removes it only if the raw content and file identity are unchanged. If the callback is missing, returns false, or the file changed, acquisition fails closed or keeps retrying according to the normal retry policy.
+The `"remove-if-unchanged"` value and `shouldRemoveStaleLock` callback remain accepted as deprecated compatibility inputs. They are ignored and the callback is not invoked. To recover, stop or otherwise exclude every process that can acquire the lock, remove the confirmed stale sidecar under that external authority, and retry acquisition.
 
 ## What sidecar locks defend against
 
 - **Two processes writing the same file at once.** `acquire` serializes the critical section.
-- **Accidentally deleting a fresh lock during stale recovery.** Stale third-party locks fail closed by default. Opt-in removal rechecks the observed snapshot before unlinking.
+- **Accidentally deleting a fresh lock during stale recovery.** Stale third-party locks always fail closed and are never unlinked during acquisition.
 - **Race between simultaneous acquire attempts.** `O_CREAT | O_EXCL` ensures one wins.
 
 ## What they do **not** defend against
 
 - **Misbehaving holders that ignore the lock.** Locks are advisory — only callers that go through `acquire` are bound.
-- **Automatic stale lock deletion.** If a process crashes, use the payload and your own supervisor/process table to decide when removal is safe, then opt into `remove-if-unchanged`.
+- **Automatic stale lock deletion.** If a process crashes, recover only under external authority that excludes every competing lock acquirer.
 - **Multi-host coordination over network filesystems.** Behavior depends on the underlying filesystem's `O_EXCL` semantics; treat as best-effort.
 
 ## Common patterns

package/docs/writing.md

@@ -192,7 +192,7 @@ await fs.write("data/blob.bin", buffer, { mkdir: false }); // override
 | `not-found` | Parent does not exist and `mkdir` is false. |
 | `not-empty` | `remove()` on a non-empty directory. |
 | `not-removable` | `remove()` could not unlink/rmdir (typically permissions or device busy). |
-| `path-mismatch` | Post-write fd identity check did not match. Almost always a parallel writer. |
+| `path-mismatch` | Post-write fd identity check did not match. Almost always a parallel writer, or a FUSE mount with unstable inode numbers — see `renameIdentity` below. |
 | `too-large` | `copyIn()` source exceeded `maxBytes`. |
 | `symlink` | A path component is a symlink and policy is `reject`. |
 | `hardlink` | `sourceHardlinks: "reject"` saw `nlink > 1`. |
@@ -232,6 +232,26 @@ try {
 await fs.append(today, line);
 ```
 
+## FUSE mounts and unstable inode numbers
+
+Some FUSE mounts — rclone is a confirmed example — assign the destination a different inode number from the source temp file as a result of rename, even within a single process with zero concurrency. Repeated stats of an unchanged destination remain stable, but the source-to-destination `(dev, ino)` comparison always fails with `path-mismatch`.
+
+Set `renameIdentity: "verify-content-with-lock"` on the root (or per call) to use a SHA-256 content comparison under a cooperative sidecar lock instead:
+
+```ts
+const fs = await root("/mnt/rclone-workspace", {
+  renameIdentity: "verify-content-with-lock",
+});
+
+await fs.write("state.json", body); // succeeds on rclone FUSE
+```
+
+**How it works.** The full write runs under an exclusive per-target lock named `.fs-safe-write-<sha256>.lock` in the root. Keeping the lock in the already-canonical root avoids creating an unguarded lock path through a missing or raced target parent. The guarded Node fallback accepts the source-temp-to-destination inode mismatch only when the SHA-256 of the re-read bytes matches the SHA-256 of the bytes written. Subsequent path identity checks remain strict, so this mode requires an unchanged destination path to report stable identity. It deliberately bypasses the stricter fd-relative Python helper because that helper requires rename to preserve inode identity. The lock is released before the call returns.
+
+**Security note.** `verify-content-with-lock` proves that the bytes observed after rename match the requested write and prevents *cooperating* writers from interleaving. It does **not** prove that the destination still names the temp-file object, retain the Python helper's fd-relative parent pinning, or stop a same-UID process that ignores the advisory lock. Do not use this option on directories writable by untrusted same-UID processes. Strict identity verification remains the default.
+
+Lock recovery is fail-closed. If a process crashes and leaves the root-level `.fs-safe-write-<sha256>.lock`, a later write reports the stale lock instead of deleting it based on a host-local PID. Recover only under external authority that excludes every competing writer; see [File lock](sidecar-lock.md#stale-recovery-is-fail-closed).
+
 ## See also
 
 - [Atomic writes](atomic.md) — the lower-level `replaceFileAtomic` and friends.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/fs-safe",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Capability-style filesystem roots for Node.js apps that handle untrusted relative paths.",
   "license": "MIT",
   "repository": {
@@ -97,24 +97,12 @@
       "default": "./dist/test-hooks.js"
     }
   },
-  "optionalDependencies": {
-    "jszip": "^3.10.1",
-    "tar": "7.5.16"
-  },
-  "devDependencies": {
-    "@types/node": "^22.19.20",
-    "@vitest/coverage-v8": "4.1.8",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.8"
-  },
-  "engines": {
-    "node": ">=22"
-  },
   "scripts": {
     "benchmark": "node scripts/benchmark.mjs",
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
     "lint:file-size": "node scripts/check-file-size.mjs",
     "lint:fs-boundary": "node scripts/check-fs-boundary-primitives.mjs",
+    "prepack": "node scripts/prepack-build.mjs",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:security": "vitest run test/fs-safe.test.ts test/read-boundary-bypass.test.ts test/write-boundary-bypass.test.ts test/additional-boundary-bypass.test.ts test/adversarial-boundary-payloads.test.ts",
@@ -126,5 +114,20 @@
     "crabbox:run": "crabbox run",
     "crabbox:stop": "crabbox stop",
     "crabbox:warmup": "crabbox warmup"
-  }
-}
+  },
+  "optionalDependencies": {
+    "jszip": "^3.10.1",
+    "tar": "7.5.20"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "4.1.10",
+    "typescript": "^7.0.2",
+    "vite": "8.1.5",
+    "vitest": "^4.1.10"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "pnpm@10.34.5"
+}