@openclaw/fs-safe 0.11.0 → 0.13.0

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

@@ -6,13 +6,50 @@ 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 { serializePathWrite } from "./write-queue.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+const validatedDurableQueueEntryPaths = new WeakSet();
+function assertQueuePathString(value, label) {
+    if (typeof value !== "string") {
+        throw new FsSafeError("invalid-path", `${label} must be a string`);
+    }
+}
+export function validateDurableQueueEntryPaths(paths) {
+    const jsonPath = paths.jsonPath;
+    const deliveredPath = paths.deliveredPath;
+    const requestedProcessingPath = paths.processingPath;
+    assertQueuePathString(jsonPath, "queue JSON path");
+    assertQueuePathString(deliveredPath, "queue delivered path");
+    if (requestedProcessingPath !== undefined) {
+        assertQueuePathString(requestedProcessingPath, "queue processing path");
+    }
+    assertNoWindowsPathAlias(jsonPath);
+    assertNoWindowsPathAlias(deliveredPath);
+    if (requestedProcessingPath !== undefined) {
+        assertNoWindowsPathAlias(requestedProcessingPath);
+    }
+    const processingPath = requestedProcessingPath || processingPathFromJsonPath(jsonPath);
+    const validated = Object.freeze({ deliveredPath, jsonPath, processingPath });
+    validatedDurableQueueEntryPaths.add(validated);
+    return validated;
+}
+function ownDurableQueueEntryPaths(paths) {
+    if (validatedDurableQueueEntryPaths.has(paths)) {
+        return paths;
+    }
+    return validateDurableQueueEntryPaths(paths);
+}
+function processingPathFromJsonPath(jsonPath) {
+    return jsonPath.endsWith(".json")
+        ? `${jsonPath.slice(0, -".json".length)}.processing`
+        : `${jsonPath}.processing`;
+}
 export function durableQueueProcessingPath(paths) {
-    if (paths.processingPath)
-        return paths.processingPath;
-    return paths.jsonPath.endsWith(".json")
-        ? `${paths.jsonPath.slice(0, -".json".length)}.processing`
-        : `${paths.jsonPath}.processing`;
+    const processingPath = paths.processingPath;
+    if (processingPath)
+        return processingPath;
+    return processingPathFromJsonPath(paths.jsonPath);
 }
 async function regularQueueFileIdentity(filePath) {
     const identity = await lstatOrNull(filePath);
@@ -24,18 +61,27 @@ async function regularQueueFileIdentity(filePath) {
     return identity;
 }
 async function withQueueEntryLock(paths, run) {
-    return await serializePathWrite(paths.jsonPath, async () => await withQueueTransferLock(path.resolve(paths.jsonPath), run));
+    const resolvedJsonPath = path.resolve(paths.jsonPath);
+    assertNoWindowsPathAlias(resolvedJsonPath);
+    return await serializePathWrite(paths.jsonPath, async () => await withQueueTransferLock(resolvedJsonPath, run));
 }
 async function claimDurableQueueEntryUnlocked(paths, options = {}) {
-    const processingPath = durableQueueProcessingPath(paths);
+    const processingPath = paths.processingPath;
     await recoverDurableQueueRetirement({ jsonPath: paths.jsonPath, processingPath });
     const existingProcessing = await regularQueueFileIdentity(processingPath);
     if (existingProcessing) {
         const pending = await lstatOrNull(paths.jsonPath);
-        if (pending &&
+        const retiresPending = pending !== null &&
             !pending.isSymbolicLink() &&
             pending.isFile() &&
-            sameFileIdentityForCleanup(pending, existingProcessing)) {
+            sameFileIdentityForCleanup(pending, existingProcessing);
+        if (!retiresPending ||
+            path.resolve(path.dirname(processingPath)) !== path.resolve(path.dirname(paths.jsonPath))) {
+            // An existing claim can contain a migration whose publication sync failed.
+            // Retirement already syncs this edge when both names share a parent.
+            await syncDirectory(path.dirname(processingPath));
+        }
+        if (retiresPending) {
             await retireDurableQueueSource({ jsonPath: paths.jsonPath, processingPath });
         }
         return processingPath;
@@ -54,7 +100,10 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
     }
     catch (error) {
         if (getErrorCode(error) === "EEXIST") {
-            return (await regularQueueFileIdentity(processingPath)) ? processingPath : null;
+            if (!(await regularQueueFileIdentity(processingPath)))
+                return null;
+            await syncDirectory(path.dirname(processingPath));
+            return processingPath;
         }
         if (getErrorCode(error) === "ENOENT")
             return null;
@@ -69,88 +118,130 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
     return processingPath;
 }
 export async function claimDurableQueueEntry(paths, options = {}) {
-    if (!(await lstatOrNull(path.dirname(paths.jsonPath))))
+    const validatedPaths = ownDurableQueueEntryPaths(paths);
+    if (!(await lstatOrNull(path.dirname(validatedPaths.jsonPath))))
         return null;
-    return await withQueueEntryLock(paths, async () => await claimDurableQueueEntryUnlocked(paths, options));
+    return await withQueueEntryLock(validatedPaths, async () => await claimDurableQueueEntryUnlocked(validatedPaths, options));
+}
+// The caller retains its read pin until this owner releases it or migration settles.
+export async function migrateDurableQueueEntry(paths, expected, releaseReadPin, run) {
+    const validatedPaths = ownDurableQueueEntryPaths(paths);
+    return await withQueueEntryLock(validatedPaths, async () => {
+        const processingPath = validatedPaths.processingPath;
+        const assertCurrent = async () => {
+            try {
+                await inspectFileIdentity(() => {
+                    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");
+                    }
+                    return current;
+                }, expected);
+            }
+            catch (error) {
+                if (getErrorCode(error) === "ENOENT") {
+                    throw new FsSafeError("path-mismatch", "queue processing claim disappeared before migration", { cause: error });
+                }
+                throw error;
+            }
+        };
+        await assertCurrent();
+        return await run(processingPath, async () => {
+            await 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();
+            }
+        });
+    });
 }
 export async function completeDeliveredQueueEntry(paths) {
-    if (!(await lstatOrNull(path.dirname(paths.deliveredPath))))
+    const validatedPaths = ownDurableQueueEntryPaths(paths);
+    if (!(await lstatOrNull(path.dirname(validatedPaths.deliveredPath))))
         return false;
-    return await withQueueEntryLock(paths, async () => {
-        if (!(await regularQueueFileIdentity(paths.deliveredPath)))
+    return await withQueueEntryLock(validatedPaths, async () => {
+        if (!(await regularQueueFileIdentity(validatedPaths.deliveredPath)))
             return false;
-        if (await regularQueueFileIdentity(durableQueueProcessingPath(paths))) {
-            await fs.unlink(paths.deliveredPath);
-            await syncDirectory(path.dirname(paths.deliveredPath));
+        if (await regularQueueFileIdentity(validatedPaths.processingPath)) {
+            await fs.unlink(validatedPaths.deliveredPath);
+            await syncDirectory(path.dirname(validatedPaths.deliveredPath));
             return false;
         }
-        await fs.unlink(paths.deliveredPath);
-        await syncDirectory(path.dirname(paths.deliveredPath));
+        await fs.unlink(validatedPaths.deliveredPath);
+        await syncDirectory(path.dirname(validatedPaths.deliveredPath));
         return true;
     });
 }
 export async function acknowledgeDurableQueueEntry(paths) {
-    if (!(await lstatOrNull(path.dirname(paths.jsonPath))))
+    const validatedPaths = ownDurableQueueEntryPaths(paths);
+    if (!(await lstatOrNull(path.dirname(validatedPaths.jsonPath))))
         return;
-    await withQueueEntryLock(paths, async () => {
-        const processingPath = durableQueueProcessingPath(paths);
+    await withQueueEntryLock(validatedPaths, async () => {
+        const processingPath = validatedPaths.processingPath;
         const processing = await regularQueueFileIdentity(processingPath);
-        const delivered = await regularQueueFileIdentity(paths.deliveredPath);
+        const delivered = await regularQueueFileIdentity(validatedPaths.deliveredPath);
         if (!processing) {
             if (delivered) {
-                await fs.unlink(paths.deliveredPath);
+                await fs.unlink(validatedPaths.deliveredPath);
             }
-            await syncDirectory(path.dirname(paths.deliveredPath));
-            if (await regularQueueFileIdentity(paths.jsonPath)) {
+            await syncDirectory(path.dirname(validatedPaths.deliveredPath));
+            if (await regularQueueFileIdentity(validatedPaths.jsonPath)) {
                 throw new FsSafeError("path-mismatch", "queue acknowledgement requires a processing claim");
             }
             return;
         }
         if (delivered)
-            await fs.unlink(paths.deliveredPath);
-        await fs.rename(processingPath, paths.deliveredPath);
-        await syncDirectory(path.dirname(paths.deliveredPath));
-        await fs.unlink(paths.deliveredPath);
-        await syncDirectory(path.dirname(paths.deliveredPath));
+            await fs.unlink(validatedPaths.deliveredPath);
+        await fs.rename(processingPath, validatedPaths.deliveredPath);
+        await syncDirectory(path.dirname(validatedPaths.deliveredPath));
+        await fs.unlink(validatedPaths.deliveredPath);
+        await syncDirectory(path.dirname(validatedPaths.deliveredPath));
     });
 }
 export async function moveDurableQueueEntryToFailed(params) {
-    await withQueueEntryLock(params.paths, async () => {
-        const processingPath = durableQueueProcessingPath(params.paths);
+    const pathsInput = params.paths;
+    const paths = ownDurableQueueEntryPaths(pathsInput);
+    const failedPath = params.failedPath;
+    assertQueuePathString(failedPath, "failed queue path");
+    assertNoWindowsPathAlias(failedPath);
+    await withQueueEntryLock(paths, async () => {
+        const processingPath = paths.processingPath;
         const processing = await regularQueueFileIdentity(processingPath);
-        const existingFailed = await regularQueueFileIdentity(params.failedPath);
+        const existingFailed = await regularQueueFileIdentity(failedPath);
         if (!processing && existingFailed) {
-            await syncDirectory(path.dirname(params.failedPath));
+            await syncDirectory(path.dirname(failedPath));
             await syncDirectory(path.dirname(processingPath));
-            const recoveredFailed = await regularQueueFileIdentity(params.failedPath);
+            const recoveredFailed = await regularQueueFileIdentity(failedPath);
             if (!recoveredFailed ||
                 !sameFileIdentityForCleanup(existingFailed, recoveredFailed)) {
                 throw new FsSafeError("path-mismatch", "failed queue destination changed during recovery");
             }
-            if (await regularQueueFileIdentity(params.paths.jsonPath)) {
+            if (await regularQueueFileIdentity(paths.jsonPath)) {
                 throw new FsSafeError("already-exists", "failed queue destination already exists");
             }
             return;
         }
         const sourcePath = processing
             ? processingPath
-            : await claimDurableQueueEntryUnlocked(params.paths);
+            : await claimDurableQueueEntryUnlocked(paths);
         if (!sourcePath) {
             throw Object.assign(new Error("queue entry does not exist"), { code: "ENOENT" });
         }
         const source = await regularQueueFileIdentity(sourcePath);
-        const failed = await regularQueueFileIdentity(params.failedPath);
+        const failed = await regularQueueFileIdentity(failedPath);
         if (failed) {
             if (source && sameFileIdentityForCleanup(source, failed)) {
-                await syncDirectory(path.dirname(params.failedPath));
+                await syncDirectory(path.dirname(failedPath));
                 await fs.unlink(sourcePath);
                 await syncDirectory(path.dirname(sourcePath));
                 return;
             }
             throw new FsSafeError("already-exists", "failed queue destination already exists");
         }
-        await fs.link(sourcePath, params.failedPath);
-        await syncDirectory(path.dirname(params.failedPath));
+        await fs.link(sourcePath, failedPath);
+        await syncDirectory(path.dirname(failedPath));
         await fs.unlink(sourcePath);
         await syncDirectory(path.dirname(sourcePath));
     });

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

@@ -0,0 +1,11 @@
+export type QueueValidationRoot = {
+    path: string;
+    allowSymlinkBase: boolean;
+};
+export declare function resolveQueueFilesystemPath(value: string): string;
+export declare function queueValidationRoots(queueDir: string, failedDir: string): Promise<{
+    queueRoot: QueueValidationRoot;
+    failedRoot: QueueValidationRoot;
+}>;
+export declare function queueValidationRoot(dir: string): QueueValidationRoot;
+//# sourceMappingURL=json-durable-queue-paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-durable-queue-paths.d.ts","sourceRoot":"","sources":["../src/json-durable-queue-paths.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIhE;AAqBD,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,SAAS,EAAE,mBAAmB,CAAC;IAAC,UAAU,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAU9E;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAKpE"}

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

@@ -0,0 +1,42 @@
+import path from "node:path";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+export function resolveQueueFilesystemPath(value) {
+    const resolved = resolvePathPreservingWindowsRoot(value);
+    assertNoWindowsPathAlias(resolved);
+    return resolved;
+}
+function commonPathAncestor(paths) {
+    const resolved = paths.map(resolveQueueFilesystemPath);
+    const root = path.parse(resolved[0] ?? process.cwd()).root;
+    const parts = resolved.map((entry) => path.relative(root, entry).split(path.sep));
+    const common = [];
+    for (let index = 0; parts.every((part) => index < part.length); index++) {
+        const segment = parts[0]?.[index];
+        if (!segment || !parts.every((part) => part[index] === segment))
+            break;
+        common.push(segment);
+    }
+    return path.join(root, ...common);
+}
+function samePathRoot(paths) {
+    const roots = paths.map((entry) => path.parse(resolveQueueFilesystemPath(entry)).root);
+    const first = process.platform === "win32" ? roots[0]?.toLowerCase() : roots[0];
+    return roots.every((root) => (process.platform === "win32" ? root.toLowerCase() : root) === first);
+}
+export async function queueValidationRoots(queueDir, failedDir) {
+    if (samePathRoot([queueDir, failedDir])) {
+        const common = commonPathAncestor([queueDir, failedDir]);
+        const root = queueValidationRoot(common);
+        return { failedRoot: root, queueRoot: root };
+    }
+    return {
+        failedRoot: queueValidationRoot(failedDir),
+        queueRoot: queueValidationRoot(queueDir),
+    };
+}
+export function queueValidationRoot(dir) {
+    return {
+        path: path.parse(resolveQueueFilesystemPath(dir)).root,
+        allowSymlinkBase: process.platform === "darwin",
+    };
+}

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

@@ -0,0 +1,6 @@
+import { type BigIntStats } from "node:fs";
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-durable-queue-read.d.ts","sourceRoot":"","sources":["../src/json-durable-queue-read.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAO/C,eAAO,MAAM,0CAA0C,QAAmB,CAAC;AA8B3E,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,CAAC,EAClD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,EAC9B,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxF,OAAO,CAAC,CAAC,CAAC,CA+BZ"}

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

@@ -0,0 +1,61 @@
+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 { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+export const DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES = 16 * 1024 * 1024;
+async function inspectQueueEntry(inspect, maxBytes, expected) {
+    let inspectionFailed = false;
+    try {
+        return await inspectFileIdentity(async () => {
+            try {
+                const stat = inspect();
+                if (stat.isSymbolicLink() || !stat.isFile()) {
+                    throw new Error("queue entry is not a regular file");
+                }
+                if (stat.nlink > 1n)
+                    throw new Error("queue entry hardlinks are not allowed");
+                if (stat.size > maxBytes)
+                    throw new Error(`queue entry exceeds ${maxBytes} bytes`);
+                return stat;
+            }
+            catch (error) {
+                inspectionFailed = true;
+                throw error;
+            }
+        }, expected);
+    }
+    catch (error) {
+        // Translate only the identity helper's rejection, never inspection errors.
+        if (inspectionFailed)
+            throw error;
+        throw new Error("queue entry changed during read", { cause: error });
+    }
+}
+export async function withJsonDurableQueueEntry(filePath, options, run) {
+    const maxBytes = normalizeMaxBytes(options.maxBytes, {
+        defaultValue: DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES,
+    });
+    assertNoWindowsPathAlias(filePath);
+    const inspectPath = () => fs.lstatSync(filePath, { bigint: true });
+    const initialStat = await 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 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,
+            createLimitError: () => new Error(`queue entry exceeds ${maxBytes} bytes`),
+        });
+        // The migration owner may release this pin only at the verified publication
+        // boundary; until then an unlinked inode cannot be recycled into a new claim.
+        return await run(JSON.parse(bytes.toString("utf8")), openedStat, releaseReadPin);
+    }
+    finally {
+        await releaseReadPin();
+    }
+}

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

@@ -1,3 +1,4 @@
+export { DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES } from "./json-durable-queue-read.js";
 export type JsonDurableQueueEntryPaths = {
     jsonPath: string;
     deliveredPath: string;
@@ -14,7 +15,6 @@ export type JsonDurableQueueLoadOptions<T> = {
     cleanupTmpMaxAgeMs?: number;
     maxBytes?: number;
 };
-export declare const DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES: number;
 export declare function unlinkBestEffort(filePath: string): Promise<void>;
 export declare function jsonDurableQueueEntryExists(filePath: string): Promise<boolean>;
 export declare function resolveJsonDurableQueueEntryPaths(queueDir: string, id: string): JsonDurableQueueEntryPaths;

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

@@ -1 +1 @@
-{"version":3,"file":"json-durable-queue.d.ts","sourceRoot":"","sources":["../src/json-durable-queue.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAOF,eAAO,MAAM,0CAA0C,QAAmB,CAAC;AAM3E,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtE;AAED,wBAAsB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpF;AAmBD,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GACT,0BAA0B,CAO5B;AAED,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhB;AAiLD,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhB;AAyDD,wBAAsB,yBAAyB,CAAC,CAAC,EAC/C,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,CAAC,CAAC,CASZ;AAED,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/F;AAED,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,MAAM,EAAE;IACzD,KAAK,EAAE,0BAA0B,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAsBpB;AAED,wBAAsB,kCAAkC,CAAC,CAAC,EACxD,OAAO,EAAE,2BAA2B,CAAC,CAAC,CAAC,GACtC,OAAO,CAAC,CAAC,EAAE,CAAC,CA+Dd;AAED,wBAAsB,iCAAiC,CAAC,MAAM,EAAE;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,OAAO,CAAC,IAAI,CAAC,CAShB"}
+{"version":3,"file":"json-durable-queue.d.ts","sourceRoot":"","sources":["../src/json-durable-queue.ts"],"names":[],"mappings":"AAgCA,OAAO,EAAE,0CAA0C,EAAE,MAAM,8BAA8B,CAAC;AAE1F,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAMF,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGtE;AAED,wBAAsB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAWpF;AAmBD,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GACT,0BAA0B,CAQ5B;AAED,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhB;AAwID,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;AAmBD,wBAAsB,yBAAyB,CAAC,CAAC,EAC/C,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,CAAC,CAAC,CAEZ;AAgBD,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/F;AAED,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,MAAM,EAAE;IACzD,KAAK,EAAE,0BAA0B,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAwBpB;AAED,wBAAsB,kCAAkC,CAAC,CAAC,EACxD,OAAO,EAAE,2BAA2B,CAAC,CAAC,CAAC,GACtC,OAAO,CAAC,CAAC,EAAE,CAAC,CA2Ed;AAED,wBAAsB,iCAAiC,CAAC,MAAM,EAAE;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,OAAO,CAAC,IAAI,CAAC,CAehB"}