@openclaw/fs-safe 0.16.0 → 0.18.0

package/dist/json-durable-queue-ownership.js

@@ -6,7 +6,7 @@ import path from "node:path";
 import { syncDirectory } from "./directory-durability.js";
 import { FsSafeError } from "./errors.js";
 import { sameFileIdentityForCleanup, sha256Hex } from "./file-identity.js";
-import { inspectFileIdentity } from "./strict-file-identity.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { serializePathWrite } from "./write-queue.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 const validatedDurableQueueEntryPaths = new WeakSet();
@@ -45,12 +45,14 @@ function processingPathFromJsonPath(jsonPath) {
         ? `${jsonPath.slice(0, -".json".length)}.processing`
         : `${jsonPath}.processing`;
 }
-async function regularQueueFileIdentity(filePath) {
-    const identity = await lstatOrNull(filePath);
+function regularQueueFileIdentity(filePath, subject = "entry") {
+    const identity = lstatOrNull(filePath);
     if (!identity)
         return null;
     if (identity.isSymbolicLink() || !identity.isFile()) {
-        throw new Error(`queue entry is not a regular file: ${filePath}`);
+        throw subject === "retirement"
+            ? new FsSafeError("path-mismatch", "queue retirement path is not a regular file")
+            : new Error(`queue entry is not a regular file: ${filePath}`);
     }
     return identity;
 }
@@ -62,9 +64,9 @@ async function withQueueEntryLock(paths, run) {
 async function claimDurableQueueEntryUnlocked(paths, options = {}) {
     const processingPath = paths.processingPath;
     await recoverDurableQueueRetirement({ jsonPath: paths.jsonPath, processingPath });
-    const existingProcessing = await regularQueueFileIdentity(processingPath);
+    const existingProcessing = regularQueueFileIdentity(processingPath);
     if (existingProcessing) {
-        const pending = await lstatOrNull(paths.jsonPath);
+        const pending = lstatOrNull(paths.jsonPath);
         const retiresPending = pending !== null &&
             !pending.isSymbolicLink() &&
             pending.isFile() &&
@@ -80,7 +82,7 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
         }
         return processingPath;
     }
-    const pending = await lstatOrNull(paths.jsonPath);
+    const pending = lstatOrNull(paths.jsonPath);
     if (!pending || pending.isSymbolicLink() || !pending.isFile())
         return null;
     if (pending.nlink > 1n || !sameFileIdentityForCleanup(pending, pending)) {
@@ -94,7 +96,7 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
     }
     catch (error) {
         if (getErrorCode(error) === "EEXIST") {
-            if (!(await regularQueueFileIdentity(processingPath)))
+            if (!regularQueueFileIdentity(processingPath))
                 return null;
             await syncDirectory(path.dirname(processingPath));
             return processingPath;
@@ -104,7 +106,7 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
         throw error;
     }
     await syncDirectory(path.dirname(processingPath));
-    const claimed = await regularQueueFileIdentity(processingPath);
+    const claimed = regularQueueFileIdentity(processingPath);
     if (!claimed || claimed.nlink > 2n) {
         throw new FsSafeError("path-mismatch", "queue claim is not an owned regular file");
     }
@@ -113,7 +115,7 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
 }
 export async function claimDurableQueueEntry(paths, options = {}) {
     const validatedPaths = ownDurableQueueEntryPaths(paths);
-    if (!(await lstatOrNull(path.dirname(validatedPaths.jsonPath))))
+    if (!lstatOrNull(path.dirname(validatedPaths.jsonPath)))
         return null;
     return await withQueueEntryLock(validatedPaths, async () => await claimDurableQueueEntryUnlocked(validatedPaths, options));
 }
@@ -122,9 +124,9 @@ export async function migrateDurableQueueEntry(paths, expected, releaseReadPin,
     const validatedPaths = ownDurableQueueEntryPaths(paths);
     return await withQueueEntryLock(validatedPaths, async () => {
         const processingPath = validatedPaths.processingPath;
-        const assertCurrent = async () => {
+        const assertCurrent = () => {
             try {
-                await inspectFileIdentity(() => {
+                inspectFileIdentitySync(() => {
                     const current = fsSync.lstatSync(processingPath, { bigint: true });
                     if (current.isSymbolicLink() || !current.isFile() || current.nlink !== 1n) {
                         throw new FsSafeError("path-mismatch", "queue migration requires its original processing claim");
@@ -139,49 +141,45 @@ export async function migrateDurableQueueEntry(paths, expected, releaseReadPin,
                 throw error;
             }
         };
-        await assertCurrent();
+        assertCurrent();
         return await run(processingPath, async () => {
-            await assertCurrent();
+            assertCurrent();
             if (process.platform === "win32") {
                 // Windows cannot replace our still-open target. Keep the transfer lock
                 // across release and reject changes made while the async close settles.
                 await releaseReadPin();
-                await assertCurrent();
+                assertCurrent();
             }
         });
     });
 }
 export async function completeDeliveredQueueEntry(paths) {
     const validatedPaths = ownDurableQueueEntryPaths(paths);
-    if (!(await lstatOrNull(path.dirname(validatedPaths.deliveredPath))))
+    if (!lstatOrNull(path.dirname(validatedPaths.deliveredPath)))
         return false;
     return await withQueueEntryLock(validatedPaths, async () => {
-        if (!(await regularQueueFileIdentity(validatedPaths.deliveredPath)))
+        if (!regularQueueFileIdentity(validatedPaths.deliveredPath))
             return false;
-        if (await regularQueueFileIdentity(validatedPaths.processingPath)) {
-            await fs.unlink(validatedPaths.deliveredPath);
-            await syncDirectory(path.dirname(validatedPaths.deliveredPath));
-            return false;
-        }
+        const processing = regularQueueFileIdentity(validatedPaths.processingPath);
         await fs.unlink(validatedPaths.deliveredPath);
         await syncDirectory(path.dirname(validatedPaths.deliveredPath));
-        return true;
+        return !processing;
     });
 }
 export async function acknowledgeDurableQueueEntry(paths) {
     const validatedPaths = ownDurableQueueEntryPaths(paths);
-    if (!(await lstatOrNull(path.dirname(validatedPaths.jsonPath))))
+    if (!lstatOrNull(path.dirname(validatedPaths.jsonPath)))
         return;
     await withQueueEntryLock(validatedPaths, async () => {
         const processingPath = validatedPaths.processingPath;
-        const processing = await regularQueueFileIdentity(processingPath);
-        const delivered = await regularQueueFileIdentity(validatedPaths.deliveredPath);
+        const processing = regularQueueFileIdentity(processingPath);
+        const delivered = regularQueueFileIdentity(validatedPaths.deliveredPath);
         if (!processing) {
             if (delivered) {
                 await fs.unlink(validatedPaths.deliveredPath);
             }
             await syncDirectory(path.dirname(validatedPaths.deliveredPath));
-            if (await regularQueueFileIdentity(validatedPaths.jsonPath)) {
+            if (regularQueueFileIdentity(validatedPaths.jsonPath)) {
                 throw new FsSafeError("path-mismatch", "queue acknowledgement requires a processing claim");
             }
             return;
@@ -202,17 +200,17 @@ export async function moveDurableQueueEntryToFailed(params) {
     assertNoWindowsPathAlias(failedPath);
     await withQueueEntryLock(paths, async () => {
         const processingPath = paths.processingPath;
-        const processing = await regularQueueFileIdentity(processingPath);
-        const existingFailed = await regularQueueFileIdentity(failedPath);
+        const processing = regularQueueFileIdentity(processingPath);
+        const existingFailed = regularQueueFileIdentity(failedPath);
         if (!processing && existingFailed) {
             await syncDirectory(path.dirname(failedPath));
             await syncDirectory(path.dirname(processingPath));
-            const recoveredFailed = await regularQueueFileIdentity(failedPath);
+            const recoveredFailed = regularQueueFileIdentity(failedPath);
             if (!recoveredFailed ||
                 !sameFileIdentityForCleanup(existingFailed, recoveredFailed)) {
                 throw new FsSafeError("path-mismatch", "failed queue destination changed during recovery");
             }
-            if (await regularQueueFileIdentity(paths.jsonPath)) {
+            if (regularQueueFileIdentity(paths.jsonPath)) {
                 throw new FsSafeError("already-exists", "failed queue destination already exists");
             }
             return;
@@ -223,18 +221,13 @@ export async function moveDurableQueueEntryToFailed(params) {
         if (!sourcePath) {
             throw Object.assign(new Error("queue entry does not exist"), { code: "ENOENT" });
         }
-        const source = await regularQueueFileIdentity(sourcePath);
-        const failed = await regularQueueFileIdentity(failedPath);
-        if (failed) {
-            if (source && sameFileIdentityForCleanup(source, failed)) {
-                await syncDirectory(path.dirname(failedPath));
-                await fs.unlink(sourcePath);
-                await syncDirectory(path.dirname(sourcePath));
-                return;
-            }
+        const source = regularQueueFileIdentity(sourcePath);
+        const failed = regularQueueFileIdentity(failedPath);
+        if (failed && (!source || !sameFileIdentityForCleanup(source, failed))) {
             throw new FsSafeError("already-exists", "failed queue destination already exists");
         }
-        await fs.link(sourcePath, failedPath);
+        if (!failed)
+            await fs.link(sourcePath, failedPath);
         await syncDirectory(path.dirname(failedPath));
         await fs.unlink(sourcePath);
         await syncDirectory(path.dirname(sourcePath));
@@ -247,7 +240,7 @@ export function getErrorCode(error) {
         ? String(error.code)
         : null;
 }
-async function lstatOrNull(filePath) {
+function lstatOrNull(filePath) {
     try {
         return fsSync.lstatSync(filePath, { bigint: true });
     }
@@ -262,28 +255,11 @@ function assertDirectory(identity, label) {
         throw new FsSafeError("path-mismatch", `${label} is not an owned directory`);
     }
 }
-async function regularFileIdentity(filePath) {
-    const identity = await lstatOrNull(filePath);
-    if (!identity)
-        return null;
-    if (identity.isSymbolicLink() || !identity.isFile()) {
-        throw new FsSafeError("path-mismatch", "queue retirement path is not a regular file");
-    }
-    return identity;
-}
 function retirementPaths(jsonPath) {
     const rootPath = path.join(path.dirname(jsonPath), RETIREMENT_ROOT_NAME);
     const dirPath = path.join(rootPath, path.basename(jsonPath));
     return { dirPath, entryPath: path.join(dirPath, RETIREMENT_ENTRY_NAME), rootPath };
 }
-async function inspectRetirementRoot(jsonPath) {
-    const rootPath = retirementPaths(jsonPath).rootPath;
-    const root = await lstatOrNull(rootPath);
-    if (!root)
-        return null;
-    assertDirectory(root, "queue retirement root");
-    return rootPath;
-}
 async function ensureRetirementRoot(jsonPath) {
     const parentPath = path.dirname(jsonPath);
     const rootPath = retirementPaths(jsonPath).rootPath;
@@ -304,11 +280,12 @@ async function removeRetirementRecord(params) {
     await syncDirectory(params.rootPath);
 }
 async function recoverDurableQueueRetirement(params) {
-    const rootPath = await inspectRetirementRoot(params.jsonPath);
-    if (!rootPath)
+    const { rootPath, dirPath, entryPath } = retirementPaths(params.jsonPath);
+    const root = lstatOrNull(rootPath);
+    if (!root)
         return;
-    const { dirPath, entryPath } = retirementPaths(params.jsonPath);
-    const dir = await lstatOrNull(dirPath);
+    assertDirectory(root, "queue retirement root");
+    const dir = lstatOrNull(dirPath);
     if (!dir)
         return;
     assertDirectory(dir, "queue retirement record");
@@ -320,13 +297,13 @@ async function recoverDurableQueueRetirement(params) {
     if (names.length !== 1 || names[0] !== RETIREMENT_ENTRY_NAME) {
         throw new FsSafeError("path-mismatch", "queue retirement record is ambiguous");
     }
-    const entry = await regularFileIdentity(entryPath);
-    const processing = await regularFileIdentity(params.processingPath);
+    const entry = regularQueueFileIdentity(entryPath, "retirement");
+    const processing = regularQueueFileIdentity(params.processingPath, "retirement");
     if (!entry || !processing) {
         throw new FsSafeError("path-mismatch", "queue retirement ownership is incomplete");
     }
     if (!sameFileIdentityForCleanup(entry, processing)) {
-        const pending = await regularFileIdentity(params.jsonPath);
+        const pending = regularQueueFileIdentity(params.jsonPath, "retirement");
         if (!pending) {
             await fs.link(entryPath, params.jsonPath);
             await syncDirectory(path.dirname(params.jsonPath));

package/dist/json-durable-queue-read.d.ts

@@ -3,4 +3,3 @@ export declare const DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES: number;
 export declare function withJsonDurableQueueEntry<T, R>(filePath: string, options: {
     maxBytes?: number;
 }, run: (entry: T, identity: BigIntStats, releaseReadPin: () => Promise<void>) => Promise<R>): Promise<R>;
-//# sourceMappingURL=json-durable-queue-read.d.ts.map

package/dist/json-durable-queue-read.js

@@ -2,13 +2,13 @@ import fs, {} from "node:fs";
 import { normalizeMaxBytes } from "./byte-budget.js";
 import { readBoundedAsync } from "./bounded-read.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
-import { inspectFileIdentity } from "./strict-file-identity.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export const DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES = 16 * 1024 * 1024;
-async function inspectQueueEntry(inspect, maxBytes, expected) {
+function inspectQueueEntry(inspect, maxBytes, expected) {
     let inspectionFailed = false;
     try {
-        return await inspectFileIdentity(async () => {
+        return inspectFileIdentitySync(() => {
             try {
                 const stat = inspect();
                 if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -39,13 +39,13 @@ export async function withJsonDurableQueueEntry(filePath, options, run) {
     });
     assertNoWindowsPathAlias(filePath);
     const inspectPath = () => fs.lstatSync(filePath, { bigint: true });
-    const initialStat = await inspectQueueEntry(inspectPath, maxBytes);
+    const initialStat = inspectQueueEntry(inspectPath, maxBytes);
     const handle = await fs.promises.open(filePath, resolveReadOpenFlags());
     let closePromise;
     const releaseReadPin = () => closePromise ??= (async () => { await handle.close(); })();
     try {
-        const openedStat = await inspectQueueEntry(() => fs.fstatSync(handle.fd, { bigint: true }), maxBytes, initialStat);
-        await inspectQueueEntry(inspectPath, maxBytes, openedStat);
+        const openedStat = inspectQueueEntry(() => fs.fstatSync(handle.fd, { bigint: true }), maxBytes, initialStat);
+        inspectQueueEntry(inspectPath, maxBytes, openedStat);
         const bytes = await readBoundedAsync(maxBytes, async (buffer, length) => (await handle.read(buffer, 0, length, null)).bytesRead, {
             initialSize: openedStat.size >= 0n && Number.isSafeInteger(Number(openedStat.size))
                 ? Number(openedStat.size) : undefined,

package/dist/json-durable-queue.d.ts

@@ -43,4 +43,3 @@ export declare function moveJsonDurableQueueEntryToFailed(params: {
     failedDir: string;
     id: string;
 }): Promise<void>;
-//# sourceMappingURL=json-durable-queue.d.ts.map

package/dist/json-durable-queue.js

@@ -1,13 +1,10 @@
 import fs, {} from "node:fs";
 import path from "node:path";
 import { syncDirectory } from "./directory-durability.js";
-import { syncQueueDirectoryCreation } from "./json-durable-queue-directory.js";
-import { queueValidationRoot, queueValidationRoots, resolveQueueFilesystemPath, } from "./json-durable-queue-paths.js";
+import { queueDirectories } from "./json-durable-queue-directory.js";
 import { getErrorCode, acknowledgeDurableQueueEntry, claimDurableQueueEntry, completeDeliveredQueueEntry, migrateDurableQueueEntry, moveDurableQueueEntryToFailed, validateDurableQueueEntryPaths, } from "./json-durable-queue-ownership.js";
 import { withJsonDurableQueueEntry } from "./json-durable-queue-read.js";
 import { stringifyJsonDocument } from "./json-stringify.js";
-import { realpathSync } from "./realpath.js";
-import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { replaceFileAtomicWithDirectorySync } from "./replace-file.js";
 import { assertSafePathSegment } from "./safe-path-segment.js";
 import { admitStandalonePublicationPath } from "./standalone-publication-path.js";
@@ -61,129 +58,9 @@ export async function ensureJsonDurableQueueDirs(params) {
     const failedDir = params.failedDir;
     assertNoWindowsPathAlias(queueDir);
     assertNoWindowsPathAlias(failedDir);
-    const roots = await queueValidationRoots(queueDir, failedDir);
-    await ensureJsonDurableQueueDir(queueDir, roots.queueRoot);
-    await ensureJsonDurableQueueDir(failedDir, roots.failedRoot);
-}
-async function ensureJsonDurableQueueDir(dir, validationRoot) {
-    const root = validationRoot
-        ? validationRoot
-        : queueValidationRoot(dir);
-    await assertNoSymlinkDirectorySegments(root, dir, true);
-    await fs.promises.mkdir(recursiveMkdirPath(dir), { recursive: true, mode: 0o700 });
-    await assertNoSymlinkDirectorySegments(root, dir, false);
-    await chmodQueueDirectory(dir);
-    await syncQueueDirectoryCreation(dir, root.path);
-}
-async function assertJsonDurableQueueDir(dir, validationRoot) {
-    const root = validationRoot
-        ? validationRoot
-        : queueValidationRoot(dir);
-    await assertNoSymlinkDirectorySegments(root, dir, false);
-}
-async function isDarwinSystemAlias(dir, stat) {
-    if (process.platform !== "darwin" || !stat.isSymbolicLink()) {
-        return false;
-    }
-    const resolved = path.resolve(dir);
-    if (resolved !== "/tmp" && resolved !== "/var") {
-        return false;
-    }
-    try {
-        return realpathSync.native(resolved) === `/private${resolved}`;
-    }
-    catch {
-        return false;
-    }
-}
-async function assertNoSymlinkDirectorySegments(validationRoot, dir, allowMissing) {
-    let base = resolveQueueFilesystemPath(validationRoot.path);
-    let target = resolveQueueFilesystemPath(dir);
-    let current = base;
-    let baseStat = fs.lstatSync(base);
-    if (baseStat.isSymbolicLink() && validationRoot.allowSymlinkBase) {
-        const relative = path.relative(base, target);
-        if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-            throw new Error(`durable queue path is not a directory: ${dir}`);
-        }
-        base = realpathSync.native(base);
-        target = path.join(base, ...relative.split(path.sep).filter(Boolean));
-        current = base;
-        baseStat = fs.lstatSync(base);
-    }
-    if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {
-        throw new Error(`durable queue path is not a directory: ${dir}`);
-    }
-    const segments = path.relative(base, target).split(path.sep).filter(Boolean);
-    for (let index = 0; index < segments.length; index++) {
-        const segment = segments[index];
-        if (segment === undefined) {
-            continue;
-        }
-        current = path.join(current, segment);
-        let stat;
-        try {
-            stat = fs.lstatSync(current);
-        }
-        catch (error) {
-            if (allowMissing && error.code === "ENOENT") {
-                return;
-            }
-            throw error;
-        }
-        if (stat.isSymbolicLink() || !stat.isDirectory()) {
-            if (stat.isSymbolicLink() && validationRoot.allowSymlinkBase) {
-                if (await isDarwinSystemAlias(current, stat)) {
-                    current = realpathSync.native(current);
-                    continue;
-                }
-            }
-            throw new Error(`durable queue path is not a directory: ${dir}`);
-        }
-    }
-}
-async function chmodQueueDirectory(dir) {
-    const noFollow = typeof fs.constants.O_NOFOLLOW === "number" && process.platform !== "win32"
-        ? fs.constants.O_NOFOLLOW
-        : 0;
-    const directoryFlag = typeof fs.constants.O_DIRECTORY === "number" && process.platform !== "win32"
-        ? fs.constants.O_DIRECTORY
-        : 0;
-    if (noFollow || directoryFlag) {
-        let handle;
-        try {
-            handle = await fs.promises.open(dir, fs.constants.O_RDONLY | noFollow | directoryFlag);
-            const stat = fs.fstatSync(handle.fd);
-            if (!stat.isDirectory()) {
-                throw new Error(`durable queue path is not a directory: ${dir}`);
-            }
-            try {
-                await handle.chmod(0o700);
-            }
-            catch {
-                // Best-effort on platforms that do not enforce POSIX modes.
-            }
-            return;
-        }
-        finally {
-            try {
-                await handle?.close();
-            }
-            catch {
-                // Best-effort cleanup after chmod/open failures.
-            }
-        }
-    }
-    const stat = fs.lstatSync(dir);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw new Error(`durable queue path is not a directory: ${dir}`);
-    }
-    try {
-        await fs.promises.chmod(dir, 0o700);
-    }
-    catch {
-        // Best-effort on platforms that do not enforce POSIX modes.
-    }
+    const directories = await queueDirectories(queueDir, failedDir);
+    await directories.queue.ensure();
+    await directories.failed.ensure();
 }
 export async function writeJsonDurableQueueEntry(params) {
     await writeQueueEntry(params);
@@ -213,15 +90,16 @@ export async function ackJsonDurableQueueEntry(paths) {
     await acknowledgeDurableQueueEntry(paths);
 }
 export async function loadJsonDurableQueueEntry(params) {
+    const pathsInput = params.paths;
+    const paths = validateDurableQueueEntryPaths(pathsInput);
+    const claimedPath = await claimDurableQueueEntry(paths);
+    if (!claimedPath)
+        return null;
+    const readOptions = { maxBytes: params.maxBytes };
+    let processingStarted = false;
     try {
-        const pathsInput = params.paths;
-        const paths = validateDurableQueueEntryPaths(pathsInput);
-        const claimedPath = await claimDurableQueueEntry(paths);
-        if (!claimedPath)
-            return null;
-        return await withJsonDurableQueueEntry(claimedPath, {
-            maxBytes: params.maxBytes,
-        }, async (raw, identity, releaseReadPin) => {
+        return await withJsonDurableQueueEntry(claimedPath, readOptions, async (raw, identity, releaseReadPin) => {
+            processingStarted = true;
             const read = params.read;
             const result = read ? await Reflect.apply(read, params, [raw, paths.jsonPath]) : { entry: raw };
             if (result.migrated) {
@@ -233,7 +111,7 @@ export async function loadJsonDurableQueueEntry(params) {
         });
     }
     catch (error) {
-        if (getErrorCode(error) === "ENOENT") {
+        if (!processingStarted && getErrorCode(error) === "ENOENT") {
             return null;
         }
         throw error;
@@ -327,9 +205,9 @@ export async function moveJsonDurableQueueEntryToFailed(params) {
     assertSafeQueueEntryId(id);
     assertNoWindowsPathAlias(queueDir);
     assertNoWindowsPathAlias(failedDir);
-    const roots = await queueValidationRoots(queueDir, failedDir);
-    await assertJsonDurableQueueDir(queueDir, roots.queueRoot);
-    await ensureJsonDurableQueueDir(failedDir, roots.failedRoot);
+    const directories = await queueDirectories(queueDir, failedDir);
+    await directories.queue.assert();
+    await directories.failed.ensure();
     const paths = validateDurableQueueEntryPaths(resolveJsonDurableQueueEntryPaths(queueDir, id));
     await moveDurableQueueEntryToFailed({
         paths,

package/dist/json-store.d.ts

@@ -6,4 +6,3 @@ export type JsonStoreOptions<T> = JsonFileStoreOptions & {
 };
 export type { JsonFileStoreOptions, JsonStore, JsonStoreLockOptions };
 export declare function jsonStore<T>(options: JsonStoreOptions<T>): JsonStore<T>;
-//# sourceMappingURL=json-store.d.ts.map

package/dist/json-stringify.d.ts

@@ -1,2 +1 @@
 export declare function stringifyJsonDocument(value: unknown, replacer?: Parameters<typeof JSON.stringify>[1], space?: Parameters<typeof JSON.stringify>[2]): string;
-//# sourceMappingURL=json-stringify.d.ts.map

package/dist/json.d.ts

@@ -47,4 +47,3 @@ export declare function readJsonIfExists<T>(filePath: string, options?: ReadJson
 export declare function readJsonSync<T = unknown>(filePath: string, options?: ReadJsonOptions): T;
 export type WriteJsonOptions = Pick<WriteTextAtomicOptions, "dirMode" | "durable" | "mode" | "trailingNewline">;
 export declare function writeJson(filePath: string, value: unknown, options?: WriteJsonOptions): Promise<void>;
-//# sourceMappingURL=json.d.ts.map