@openclaw/fs-safe 0.5.6 → 0.7.0

package/dist/archive.js

@@ -3,9 +3,9 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { createArchiveOutputPathTracker, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
+import { createArchiveOutputPathTracker, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 import { createPipelineTimeoutError, waitForDeadline, withExtractionDeadline, } from "./archive-deadline.js";
-import { assertArchiveEntryCountWithinLimit, assertArchiveEntryPathComponentsWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, } from "./archive-limits.js";
+import { assertArchiveEntryCountWithinLimit, assertArchiveEntryPathComponentsWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, resolveTarMeterLimits, } from "./archive-limits.js";
 import { resolveArchiveKind } from "./archive-kind.js";
 import { mergeExtractedTreeIntoDestination, prepareArchiveDestinationDir, prepareArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
 import { createTarEntryPreflightChecker, readTarEntryInfo, } from "./archive-tar.js";
@@ -17,9 +17,10 @@ import { ArchiveSecurityError } from "./archive-errors.js";
 import { extractNativeArchive } from "./archive-native.js";
 import { stageArchiveFileForExtraction } from "./archive-input.js";
 import { getNativeBinding } from "./native.js";
-import { resolveArchiveEntryMode, shouldExtractArchiveEntry, } from "./archive-policy.js";
-import { importOptionalTar, normalizeTarParserError } from "./archive-tar-runtime.js";
+import { resolveArchiveEntryMode, resolveArchiveFilteredEntryPolicy, shouldExtractArchiveEntry, } from "./archive-policy.js";
+import { importOptionalTar, NODE_TAR_RATIO_DISABLED, normalizeTarParserError } from "./archive-tar-runtime.js";
 import { preflightTarMetadata } from "./archive-tar-meta.js";
+import { createTarAdmissionPlan } from "./archive-tar-admission.js";
 import { writeSiblingTempFile } from "./sibling-temp.js";
 export { isWindowsDrivePath, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 export { resolveArchiveKind, resolvePackedRootDir } from "./archive-kind.js";
@@ -45,12 +46,16 @@ async function readZipEntryStream(entry) {
 }
 function resolveZipOutputPath(params) {
     validateArchiveEntryPath(params.entryPath);
-    const relPath = stripArchivePath(params.entryPath, params.strip);
+    const canonicalPath = stripArchivePath(params.entryPath, 0);
+    if (!canonicalPath)
+        return null;
+    const relPath = stripArchivePath(canonicalPath, params.strip);
     if (!relPath) {
         return null;
     }
     validateArchiveEntryPath(relPath);
     return {
+        canonicalPath,
         relPath,
         outPath: resolveArchiveOutputPath({
             rootDir: params.destinationDir,
@@ -151,10 +156,13 @@ async function extractZip(params) {
                     if (!shouldExtractArchiveEntry({
                         filter: params.entryFilter,
                         onFiltered: params.onFiltered,
-                        entry: { path: entry.name, kind: entryKind, size: entrySize },
+                        entry: { path: output.canonicalPath, kind: entryKind, size: entrySize },
                     })) {
                         continue;
                     }
+                    if (isSymlink) {
+                        throw new ArchiveSecurityError("entry-link", `zip entry is a link: ${entry.name}`);
+                    }
                     const mode = zipEntryMode(entry, params.entryModes);
                     await prepareZipOutputPath({
                         destinationDir: stagingRealDir,
@@ -163,14 +171,12 @@ async function extractZip(params) {
                         outPath: output.outPath,
                         originalPath: entry.name,
                         isDirectory: entry.dir,
+                        deadline: params.deadline,
                     });
                     if (entry.dir) {
                         await fs.chmod(output.outPath, mode);
                         continue;
                     }
-                    if (isSymlink) {
-                        throw new ArchiveSecurityError("entry-link", `zip entry is a link: ${entry.name}`);
-                    }
                     await writeZipFileEntry({
                         entry,
                         outPath: output.outPath,
@@ -184,6 +190,7 @@ async function extractZip(params) {
                     sourceDir: stagingRealDir,
                     destinationDir: params.destDir,
                     destinationRealDir,
+                    deadline: params.deadline,
                 });
                 params.deadline.check();
             },
@@ -194,11 +201,14 @@ async function extractZip(params) {
     }
 }
 export async function extractArchive(params) {
+    const onFiltered = resolveArchiveFilteredEntryPolicy(params.onFiltered);
     const kind = params.kind ?? resolveArchiveKind(params.archivePath);
     if (!kind) {
         throw new Error(`unsupported archive: ${params.archivePath}`);
     }
     const label = kind === "zip" ? "extract zip" : "extract tar";
+    const limits = resolveExtractLimits(params.limits);
+    const tarLimits = resolveTarMeterLimits(limits);
     const native = getNativeBinding();
     if (native) {
         await withExtractionDeadline(params.timeoutMs, label, async (deadline) => extractNativeArchive({
@@ -207,31 +217,34 @@ export async function extractArchive(params) {
             destDir: params.destDir,
             kind,
             stripComponents: params.stripComponents,
-            limits: params.limits,
+            limits,
+            tarLimits,
             deadline,
             entryModes: params.entryModes,
             entryFilter: params.entryFilter,
-            onFiltered: params.onFiltered,
+            onFiltered,
         }));
         return;
     }
     if (kind === "tar-zstd" || kind === "tar-bzip2") {
-        throw new FsSafeError("helper-unavailable", `${kind} archives require a supported bundled native binding`);
+        throw new FsSafeError("helper-unavailable", `${kind} archives require the matching optional native platform package; ` +
+            "install @openclaw/fs-safe with optional dependencies enabled on a supported platform and use FS_SAFE_NATIVE_MODE=auto or require");
     }
     if (kind === "tar") {
         await withExtractionDeadline(params.timeoutMs, label, async (deadline) => {
             const tar = await importOptionalTar();
-            const limits = resolveExtractLimits(params.limits);
             const stagedArchive = await stageArchiveFileForExtraction({
                 archivePath: params.archivePath,
                 limits,
                 deadline,
             });
             try {
+                const manifest = [];
                 await preflightTarMetadata({
                     archivePath: stagedArchive.path,
-                    maxMetaEntryBytes: limits.maxMetaEntryBytes,
+                    limits: tarLimits,
                     signal: deadline.signal,
+                    onMember: (entry) => { manifest.push(entry); },
                 });
                 deadline.check();
                 const destinationRealDir = await prepareArchiveDestinationDir(params.destDir);
@@ -239,49 +252,54 @@ export async function extractArchive(params) {
                     destinationRealDir,
                     run: async (stagingDir) => {
                         deadline.check();
+                        const strip = Math.max(0, Math.floor(params.stripComponents ?? 0));
                         const checkTarEntrySafety = createTarEntryPreflightChecker({
                             rootDir: destinationRealDir,
                             stripComponents: params.stripComponents,
                             limits,
                             entryFilter: params.entryFilter,
-                            onFiltered: params.onFiltered,
+                            onFiltered,
                         });
+                        const admission = createTarAdmissionPlan(manifest, (entry) => {
+                            deadline.check();
+                            return checkTarEntrySafety(entry);
+                        }, strip);
                         const acceptedEntries = [];
-                        // A canonical cwd is not enough here: tar can still follow
-                        // pre-existing child symlinks in the live destination tree.
-                        // Extract into a private staging dir first, then merge through
-                        // the same safe-open boundary checks used by direct file writes.
+                        // Extract privately, then merge through the safe-open boundary.
                         const extractor = tar.x({
                             cwd: stagingDir,
-                            strip: Math.max(0, Math.floor(params.stripComponents ?? 0)),
+                            // fs-safe owns stripping: node-tar counts the `.` and empty path
+                            // components that stripArchivePath() drops, so the two disagree.
+                            strip: 0,
                             gzip: params.tarGzip,
                             signal: deadline.signal,
                             preservePaths: false,
                             noChmod: true,
                             preserveOwner: false,
+                            noMtime: true,
                             strict: true,
-                            maxMetaEntrySize: limits.maxMetaEntryBytes,
+                            maxMetaEntrySize: tarLimits.maxMetaEntryBytes,
+                            maxDecompressionRatio: NODE_TAR_RATIO_DISABLED,
                             filter(_entryPath, entry) {
                                 try {
                                     const info = readTarEntryInfo(entry);
-                                    const accepted = checkTarEntrySafety(info);
-                                    if (accepted) {
-                                        entry.path = normalizeArchiveEntryPath(info.path);
-                                        const relPath = stripArchivePath(info.path, Math.max(0, Math.floor(params.stripComponents ?? 0)));
-                                        if (relPath) {
-                                            acceptedEntries.push({
-                                                path: relPath,
-                                                mode: resolveArchiveEntryMode({
-                                                    kind: info.type === "Directory" || info.type === "GNUDumpDir"
-                                                        ? "directory"
-                                                        : "file",
-                                                    archivedMode: info.mode,
-                                                    policy: params.entryModes,
-                                                }),
-                                            });
-                                        }
+                                    const relPath = admission.consume(info);
+                                    if (!relPath) {
+                                        return false;
                                     }
-                                    return accepted;
+                                    // Writes and the mode pass use the admitted output identity.
+                                    entry.path = relPath;
+                                    acceptedEntries.push({
+                                        path: relPath,
+                                        mode: resolveArchiveEntryMode({
+                                            kind: info.type === "Directory" || info.type === "GNUDumpDir"
+                                                ? "directory"
+                                                : "file",
+                                            archivedMode: info.mode,
+                                            policy: params.entryModes,
+                                        }),
+                                    });
+                                    return true;
                                 }
                                 catch (error) {
                                     // Abort through the parser so pipeline tears down both the
@@ -297,8 +315,7 @@ export async function extractArchive(params) {
                                 }
                                 catch (err) {
                                     const error = err instanceof Error ? err : new Error(String(err));
-                                    // Node's EventEmitter calls listeners with `this` bound to the
-                                    // emitter (tar.Unpack), which exposes Parser.abort().
+                                    // EventEmitter binds `this` to tar.Unpack, exposing abort().
                                     const emitter = this;
                                     emitter.abort?.(error);
                                 }
@@ -312,19 +329,23 @@ export async function extractArchive(params) {
                         catch (error) {
                             throw normalizeTarParserError(createPipelineTimeoutError(error, deadline));
                         }
+                        admission.finish();
                         for (const accepted of acceptedEntries) {
+                            deadline.check();
                             const outputPath = resolveArchiveOutputPath({
                                 rootDir: stagingDir,
                                 relPath: accepted.path,
                                 originalPath: accepted.path,
                             });
                             await fs.chmod(outputPath, accepted.mode);
+                            deadline.check();
                         }
                         deadline.check();
                         await mergeExtractedTreeIntoDestination({
                             sourceDir: stagingDir,
                             destinationDir: params.destDir,
                             destinationRealDir,
+                            deadline,
                         });
                         deadline.check();
                     },
@@ -340,10 +361,10 @@ export async function extractArchive(params) {
         archivePath: params.archivePath,
         destDir: params.destDir,
         stripComponents: params.stripComponents,
-        limits: params.limits,
+        limits,
         deadline,
         entryModes: params.entryModes,
         entryFilter: params.entryFilter,
-        onFiltered: params.onFiltered,
+        onFiltered,
     }));
 }

package/dist/atomic.d.ts

@@ -1,4 +1,4 @@
-export { replaceFileAtomic, replaceFileAtomicSync, type ReplaceFileAtomicFileSystem, type ReplaceFileAtomicOptions, type ReplaceFileAtomicRestoreCleanup, type ReplaceFileAtomicRestoreFailureDetails, type ReplaceFileAtomicResult, type ReplaceFileCopyFallbackRestorePolicy, type ReplaceFileDestinationHardlinkPolicy, type ReplaceFileAtomicSyncFileSystem, type ReplaceFileAtomicSyncOptions, } from "./replace-file.js";
+export { replaceFileAtomic, replaceFileAtomicSync, type RenameIdentityPolicy, type ReplaceFileAtomicFileSystem, type ReplaceFileAtomicOptions, type ReplaceFileAtomicRestoreCleanup, type ReplaceFileAtomicRestoreFailureDetails, type ReplaceFileAtomicResult, type ReplaceFileCopyFallbackRestorePolicy, type ReplaceFileDestinationHardlinkPolicy, type ReplaceFileAtomicSyncFileSystem, type ReplaceFileAtomicSyncOptions, } from "./replace-file.js";
 export { writeTextAtomic, type WriteTextAtomicOptions } from "./text-atomic.js";
 export { replaceDirectoryAtomic, type ReplaceDirectoryAtomicOptions } from "./replace-directory.js";
 export { movePathWithCopyFallback, type MovePathWithCopyFallbackOptions } from "./move-path.js";

package/dist/atomic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,KAAK,sCAAsC,EAC3C,KAAK,uBAAuB,EAC5B,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,KAAK,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAAE,KAAK,+BAA+B,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,KAAK,sCAAsC,EAC3C,KAAK,uBAAuB,EAC5B,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,KAAK,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAAE,KAAK,+BAA+B,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/bounded-read-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bounded-read-stream.d.ts","sourceRoot":"","sources":["../src/bounded-read-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,SAAS,EAAE,MAAM,aAAa,CAAC;AAGlD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAwBnE;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE;IAAE,MAAM,EAAE;QAAE,gBAAgB,IAAI,MAAM,CAAC,cAAc,CAAA;KAAE,CAAA;CAAE,EACjE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,MAAM,CAAC,cAAc,CAWvB"}
+{"version":3,"file":"bounded-read-stream.d.ts","sourceRoot":"","sources":["../src/bounded-read-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,SAAS,EAAE,MAAM,aAAa,CAAC;AAIlD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAmBnE;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE;IAAE,MAAM,EAAE;QAAE,gBAAgB,IAAI,MAAM,CAAC,cAAc,CAAA;KAAE,CAAA;CAAE,EACjE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,MAAM,CAAC,cAAc,CAWvB"}

package/dist/bounded-read-stream.js

@@ -1,10 +1,8 @@
 import { pipeline, Transform } from "node:stream";
+import { normalizeMaxBytes } from "./byte-budget.js";
 import { FsSafeError } from "./errors.js";
 export function createMaxBytesTransform(maxBytes) {
-    if (maxBytes !== Number.POSITIVE_INFINITY &&
-        (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) {
-        throw new RangeError("maxBytes must be a non-negative safe integer or Infinity");
-    }
+    normalizeMaxBytes(maxBytes);
     let bytes = 0;
     return new Transform({
         transform(chunk, _encoding, callback) {

package/dist/bounded-read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bounded-read.d.ts","sourceRoot":"","sources":["../src/bounded-read.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD,KAAK,kBAAkB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;AA4DnD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAIjB;AAcD,oFAAoF;AACpF,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAI7F;AAED,mFAAmF;AACnF,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAalF"}
+{"version":3,"file":"bounded-read.d.ts","sourceRoot":"","sources":["../src/bounded-read.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD,KAAK,kBAAkB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;AAmDnD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAIjB;AAcD,oFAAoF;AACpF,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAI7F;AAED,mFAAmF;AACnF,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAalF"}

package/dist/bounded-read.js

@@ -1,14 +1,7 @@
 import fs from "node:fs";
+import { normalizeMaxBytes } from "./byte-budget.js";
 import { FsSafeError } from "./errors.js";
 const READ_CHUNK_BYTES = 64 * 1024;
-function assertMaxBytes(maxBytes) {
-    if (maxBytes === Number.POSITIVE_INFINITY) {
-        return;
-    }
-    if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) {
-        throw new RangeError("maxBytes must be a non-negative safe integer or Infinity");
-    }
-}
 function createScratchBuffer(maxBytes) {
     const initialReadBytes = Number.isFinite(maxBytes)
         ? Math.min(READ_CHUNK_BYTES, maxBytes + 1)
@@ -29,7 +22,7 @@ function appendChunk(params) {
     return total;
 }
 async function readBoundedAsync(maxBytes, readChunk) {
-    assertMaxBytes(maxBytes);
+    normalizeMaxBytes(maxBytes);
     const chunks = [];
     const scratch = createScratchBuffer(maxBytes);
     let total = 0;
@@ -71,7 +64,7 @@ export async function readFileDescriptorBounded(fd, maxBytes) {
 }
 /** Sync bounded read from a numeric descriptor. The caller owns the descriptor. */
 export function readFileDescriptorBoundedSync(fd, maxBytes) {
-    assertMaxBytes(maxBytes);
+    normalizeMaxBytes(maxBytes);
     const chunks = [];
     const scratch = createScratchBuffer(maxBytes);
     let total = 0;

package/dist/byte-budget.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeMaxBytes(value: number | undefined, options?: {
+    defaultValue?: number;
+    label?: string;
+}): number | undefined;
+//# sourceMappingURL=byte-budget.d.ts.map

package/dist/byte-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte-budget.d.ts","sourceRoot":"","sources":["../src/byte-budget.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACtD,MAAM,GAAG,SAAS,CASpB"}

package/dist/byte-budget.js

@@ -0,0 +1,9 @@
+export function normalizeMaxBytes(value, options = {}) {
+    const selected = value === undefined ? options.defaultValue : value;
+    if (selected === undefined || selected === Number.POSITIVE_INFINITY)
+        return selected;
+    if (!Number.isSafeInteger(selected) || selected < 0) {
+        throw new RangeError(`${options.label ?? "maxBytes"} must be a non-negative safe integer or Infinity`);
+    }
+    return selected;
+}

package/dist/file-hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-hash.d.ts","sourceRoot":"","sources":["../src/file-hash.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAGnE,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,UAAU,CAAC;AAElD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,cAAc,CAClC,MAAM,EAAE,UAAU,EAClB,MAAM,GAAE,aAAa,GAAG,SAA8B,GACrD,OAAO,CAAC,gBAAgB,CAAC,CAoB3B;AA2CD,wBAAsB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAElF"}
+{"version":3,"file":"file-hash.d.ts","sourceRoot":"","sources":["../src/file-hash.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAInE,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,UAAU,CAAC;AAElD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,cAAc,CAClC,MAAM,EAAE,UAAU,EAClB,MAAM,GAAE,aAAa,GAAG,SAA8B,GACrD,OAAO,CAAC,gBAAgB,CAAC,CAoB3B;AA+CD,wBAAsB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAElF"}

package/dist/file-hash.js

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
 import { getNativeBinding } from "./native.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
 export async function hashFileHandle(handle, native = getNativeBinding()) {
     const stat = await handle.stat();
     if (!stat.isFile()) {
@@ -25,13 +25,16 @@ export async function hashFileHandle(handle, native = getNativeBinding()) {
     }
 }
 async function hashPath(filePath) {
-    const before = await fs.lstat(filePath);
-    if (before.isSymbolicLink()) {
-        throw new FsSafeError("symlink", "SHA-256 path must not be a symbolic link");
-    }
-    if (!before.isFile()) {
-        throw new FsSafeError("not-file", "SHA-256 path is not a regular file");
-    }
+    const before = await inspectFileIdentity(async () => {
+        const stat = await fs.lstat(filePath, { bigint: true });
+        if (stat.isSymbolicLink()) {
+            throw new FsSafeError("symlink", "SHA-256 path must not be a symbolic link");
+        }
+        if (!stat.isFile()) {
+            throw new FsSafeError("not-file", "SHA-256 path is not a regular file");
+        }
+        return stat;
+    });
     let handle;
     try {
         handle = await fs.open(filePath, resolveReadOpenFlags());
@@ -45,17 +48,20 @@ async function hashPath(filePath) {
         throw error;
     }
     try {
-        const opened = await handle.stat();
-        const current = await fs.lstat(filePath);
-        if (!opened.isFile()) {
-            throw new FsSafeError("not-file", "SHA-256 path is not a regular file");
-        }
-        if (current.isSymbolicLink() ||
-            !current.isFile() ||
-            !sameFileIdentity(before, opened) ||
-            !sameFileIdentity(opened, current)) {
-            throw new FsSafeError("path-mismatch", "SHA-256 path changed while opening");
-        }
+        const opened = await inspectFileIdentity(async () => {
+            const stat = await handle.stat({ bigint: true });
+            if (!stat.isFile()) {
+                throw new FsSafeError("not-file", "SHA-256 path is not a regular file");
+            }
+            return stat;
+        }, before);
+        await inspectFileIdentity(async () => {
+            const stat = await fs.lstat(filePath, { bigint: true });
+            if (stat.isSymbolicLink() || !stat.isFile()) {
+                throw new FsSafeError("path-mismatch", "SHA-256 path changed while opening");
+            }
+            return stat;
+        }, opened);
         return await hashFileHandle(handle);
     }
     finally {

package/dist/file-lock-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-lock-sync.d.ts","sourceRoot":"","sources":["../src/file-lock-sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAOL,KAAK,wBAAwB,EAC9B,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EACV,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,yBAAyB,CAAC;AAGjC,MAAM,MAAM,0BAA0B,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,uBAAuB,CAAC;IAChC,aAAa,CAAC,EAAE,wBAAwB,CAAC;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,QAAQ,CAAC;IACxB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,iBAAiB,EAAE,KAAK,CAAC;KAC1B,KAAK,OAAO,CAAC;IACd,qBAAqB,CAAC,EAAE,CAAC,QAAQ,EAAE,wBAAwB,KAAK,OAAO,CAAC;IACxE,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,0BAA0B,KAAK,IAAI,CAAC;IAC3D,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,IAAI,OAAO,CAAC;IAC3B,OAAO,IAAI,IAAI,CAAC;IAChB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B,CAAC;AA0IF,wBAAgB,mBAAmB,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,0BAA0B,CAAC,QAAQ,CAAC,GAC5C,kBAAkB,CAuJpB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,0BAA0B,CAAC,QAAQ,CAAC,EAC7C,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAOH"}
+{"version":3,"file":"file-lock-sync.d.ts","sourceRoot":"","sources":["../src/file-lock-sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAOL,KAAK,wBAAwB,EAC9B,MAAM,2BAA2B,CAAC;AAOnC,OAAO,KAAK,EACV,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,yBAAyB,CAAC;AAIjC,MAAM,MAAM,0BAA0B,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,uBAAuB,CAAC;IAChC,aAAa,CAAC,EAAE,wBAAwB,CAAC;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,QAAQ,CAAC;IACxB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,iBAAiB,EAAE,KAAK,CAAC;KAC1B,KAAK,OAAO,CAAC;IACd,qBAAqB,CAAC,EAAE,CAAC,QAAQ,EAAE,wBAAwB,KAAK,OAAO,CAAC;IACxE,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,0BAA0B,KAAK,IAAI,CAAC;IAC3D,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,IAAI,OAAO,CAAC;IAC3B,OAAO,IAAI,IAAI,CAAC;IAChB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B,CAAC;AA0IF,wBAAgB,mBAAmB,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,0BAA0B,CAAC,QAAQ,CAAC,GAC5C,kBAAkB,CAwKpB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,0BAA0B,CAAC,QAAQ,CAAC,EAC7C,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAOH"}

package/dist/file-lock-sync.js

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { readSidecarLockSnapshotSync, relativeSidecarLockPath, removeSidecarLockIfUnchangedSync, serializeSidecarLockPayload, sidecarLockSnapshotMatches, } from "./sidecar-lock-reclaim.js";
-import { computeSidecarLockDelayMs, sidecarLockPayloadCreatedAtMs, } from "./sidecar-lock-policy.js";
+import { computeSidecarLockDelayMs, sidecarLockPayloadCreatedAtMs, validateSidecarLockRetryOptions, validateSidecarLockTimeoutMs, } from "./sidecar-lock-policy.js";
+import { getFsSafeLockConfig } from "./lock-config.js";
 import { sleepSync } from "./timing.js";
 const SYNC_HELD_LOCKS_KEY = Symbol.for("fsSafe.syncSidecarLocks");
 const SYNC_CLEANUP_REGISTERED_KEY = Symbol.for("fsSafe.syncSidecarLockCleanupRegistered");
@@ -126,6 +127,11 @@ function reclaimGuardExists(reclaimGuardPath) {
     }
 }
 export function acquireFileLockSync(targetPath, options) {
+    const defaults = getFsSafeLockConfig();
+    const retry = options.retry ?? defaults.retry ?? {};
+    const timeoutMs = options.timeoutMs ?? defaults.timeoutMs;
+    validateSidecarLockRetryOptions(retry);
+    validateSidecarLockTimeoutMs(timeoutMs);
     const normalizedTargetPath = normalizeTargetPath(targetPath);
     const lockPath = boundedLockPath(options.lockPath ?? `${normalizedTargetPath}.lock`, options.lockRoot);
     const heldLocks = getSyncHeldLocks();
@@ -137,14 +143,16 @@ export function acquireFileLockSync(targetPath, options) {
         held.refCount += 1;
         return createSyncHeldLockHandle(held);
     }
-    const staleMs = options.staleMs ?? 30_000;
-    const retry = options.retry ?? {};
+    // Process defaults fill the same fields here as withLockDefaults() fills for
+    // the asynchronous manager, so both acquirers honor configureFsSafeLocks().
+    const staleMs = options.staleMs ?? defaults.staleMs ?? 30_000;
+    const staleRecovery = options.staleRecovery ?? defaults.staleRecovery;
     const startedAt = Date.now();
     let attempt = 0;
     const reclaimGuardPath = `${lockPath}.reclaim`;
     const waitForRetry = () => {
         const elapsed = Date.now() - startedAt;
-        const timedOut = options.timeoutMs !== undefined && elapsed >= options.timeoutMs;
+        const timedOut = timeoutMs !== undefined && elapsed >= timeoutMs;
         if (timedOut || (retry.retries !== undefined && attempt >= retry.retries)) {
             throw Object.assign(new Error(`file lock timeout for ${normalizedTargetPath}`), {
                 code: "file_lock_timeout",
@@ -152,7 +160,10 @@ export function acquireFileLockSync(targetPath, options) {
                 normalizedTargetPath,
             });
         }
-        sleepSync(computeSidecarLockDelayMs(retry, attempt));
+        const remaining = timeoutMs === undefined || timeoutMs === Number.POSITIVE_INFINITY
+            ? Number.POSITIVE_INFINITY
+            : Math.max(0, timeoutMs - elapsed);
+        sleepSync(Math.min(computeSidecarLockDelayMs(retry, attempt), remaining));
         attempt += 1;
     };
     while (true) {
@@ -190,9 +201,15 @@ export function acquireFileLockSync(targetPath, options) {
             const returnedHandle = createSyncHeldLockHandle(createdHeld);
             if (options.onCompromised && (options.compromiseCheckIntervalMs ?? 0) > 0) {
                 createdHeld.timer = setInterval(() => {
-                    if (!returnedHandle.verifyStillHeld()) {
-                        if (createdHeld.timer)
-                            clearInterval(createdHeld.timer);
+                    let stillHeld;
+                    try {
+                        stillHeld = returnedHandle.verifyStillHeld();
+                    }
+                    catch {
+                        stillHeld = false;
+                    }
+                    if (!stillHeld && createdHeld.timer) {
+                        clearInterval(createdHeld.timer);
                         createdHeld.timer = undefined;
                         options.onCompromised?.({ lockPath, normalizedTargetPath });
                     }
@@ -232,7 +249,7 @@ export function acquireFileLockSync(targetPath, options) {
                 })
                 : defaultShouldReclaim(snapshot.payload, lockPath, staleMs, nowMs);
             if (reclaim) {
-                if (options.staleRecovery === "remove-if-unchanged" &&
+                if (staleRecovery === "remove-if-unchanged" &&
                     snapshot.raw !== undefined &&
                     options.shouldRemoveStaleLock?.({
                         lockPath,

package/dist/file-store-boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-store-boundary.d.ts","sourceRoot":"","sources":["../src/file-store-boundary.ts"],"names":[],"mappings":"AAGA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAA4C,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAGhF,MAAM,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAOjD,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,IAAI,EAChB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhB;AA+CD,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,MAAM,EAAE,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAuC1D;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAWrE;AAUD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,eAAe,CAOlB;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,eAAe,GAAG,OAAO,CAAC;CAC1C,GAAG,eAAe,CAyDlB"}
+{"version":3,"file":"file-store-boundary.d.ts","sourceRoot":"","sources":["../src/file-store-boundary.ts"],"names":[],"mappings":"AAGA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvD,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAA4C,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAGhF,MAAM,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAOjD,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,IAAI,EAChB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKhB;AAgDD,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,MAAM,EAAE,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAwC1D;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAWrE;AAUD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,eAAe,CAOlB;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,eAAe,GAAG,OAAO,CAAC;CAC1C,GAAG,eAAe,CAyDlB"}

package/dist/file-store-boundary.js

@@ -2,6 +2,7 @@ import syncFs from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Transform } from "node:stream";
+import { normalizeMaxBytes } from "./byte-budget.js";
 import { pipeline } from "node:stream/promises";
 import { assertSyncDirectoryGuard as assertDirectoryGuardSync, createSyncDirectoryGuard, } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
@@ -22,9 +23,10 @@ export async function ensureParentInRoot(scopedRoot, relativePath, mode) {
     await chmodDirectoryInRootBestEffort(scopedRoot, parent, mode).catch(() => undefined);
 }
 export async function openWritableStoreRoot(params) {
+    const maxBytes = normalizeMaxBytes(params.maxBytes);
     await fs.mkdir(params.rootDir, { recursive: true, mode: params.dirMode });
     await fs.chmod(params.rootDir, params.dirMode).catch(() => undefined);
-    return await root(params.rootDir, { hardlinks: "reject", maxBytes: params.maxBytes });
+    return await root(params.rootDir, { hardlinks: "reject", maxBytes });
 }
 async function chmodDirectoryInRootBestEffort(scopedRoot, relativePath, mode) {
     const dirPath = await scopedRoot.resolve(relativePath);
@@ -49,7 +51,8 @@ async function chmodDirectoryInRootBestEffort(scopedRoot, relativePath, mode) {
     }
 }
 function createMaxBytesTransform(maxBytes) {
-    if (maxBytes === undefined) {
+    const limit = normalizeMaxBytes(maxBytes);
+    if (limit === undefined) {
         return undefined;
     }
     let total = 0;
@@ -57,8 +60,8 @@ function createMaxBytesTransform(maxBytes) {
         transform(chunk, _encoding, callback) {
             const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
             total += buffer.byteLength;
-            if (total > maxBytes) {
-                callback(new FsSafeError("too-large", `file exceeds maximum size of ${maxBytes} bytes`));
+            if (total > limit) {
+                callback(new FsSafeError("too-large", `file exceeds maximum size of ${limit} bytes`));
                 return;
             }
             callback(null, buffer);
@@ -66,6 +69,7 @@ function createMaxBytesTransform(maxBytes) {
     });
 }
 export async function writeStreamToTempSource(params) {
+    const maxBytes = normalizeMaxBytes(params.maxBytes);
     const tempRoot = resolveSecureTempRoot({
         fallbackPrefix: "fs-safe-file-store",
         unsafeFallbackLabel: "file store temp dir",
@@ -81,7 +85,7 @@ export async function writeStreamToTempSource(params) {
         writable.once("close", () => {
             handleClosedByStream = true;
         });
-        const limiter = createMaxBytesTransform(params.maxBytes);
+        const limiter = createMaxBytesTransform(maxBytes);
         if (limiter) {
             await pipeline(params.stream, limiter, writable);
         }

package/dist/file-store-limit.d.ts

@@ -0,0 +1,2 @@
+export declare function assertFileStoreMaxBytes(size: number, maxBytes?: number): void;
+//# sourceMappingURL=file-store-limit.d.ts.map

package/dist/file-store-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-store-limit.d.ts","sourceRoot":"","sources":["../src/file-store-limit.ts"],"names":[],"mappings":"AAGA,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAK7E"}

package/dist/file-store-limit.js

@@ -0,0 +1,8 @@
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { FsSafeError } from "./errors.js";
+export function assertFileStoreMaxBytes(size, maxBytes) {
+    const limit = normalizeMaxBytes(maxBytes);
+    if (limit !== undefined && size > limit) {
+        throw new FsSafeError("too-large", `file exceeds maximum size of ${limit} bytes`);
+    }
+}

package/dist/file-store-sync-write.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-store-sync-write.d.ts","sourceRoot":"","sources":["../src/file-store-sync-write.ts"],"names":[],"mappings":"AAuBA,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CA+ET"}
+{"version":3,"file":"file-store-sync-write.d.ts","sourceRoot":"","sources":["../src/file-store-sync-write.ts"],"names":[],"mappings":"AAwBA,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CA6GT"}