@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock.d.ts

@@ -0,0 +1,14 @@
+import type { SidecarLockAcquireOptions, SidecarLockHandle, SidecarLockHeldEntry, WithSidecarLockOptions } from "./sidecar-lock-types.js";
+export type { SidecarLockStaleSnapshot } from "./sidecar-lock-reclaim.js";
+export type { SidecarLockAcquireOptions, SidecarLockCompromisedInfo, SidecarLockHandle, SidecarLockHeldEntry, SidecarLockRetryOptions, SidecarLockStaleRecovery, WithSidecarLockOptions, } from "./sidecar-lock-types.js";
+/** True when a retain-unaware package copy registered the process-exit handlers first. */
+export declare function exitCleanupCannotRetain(): boolean;
+export declare function createSidecarLockManager(key: string): {
+    acquire: <TPayload extends Record<string, unknown>>(options: SidecarLockAcquireOptions<TPayload>) => Promise<SidecarLockHandle>;
+    withLock: <T, TPayload extends Record<string, unknown>>(options: SidecarLockAcquireOptions<TPayload>, fn: () => Promise<T>) => Promise<T>;
+    drain: () => Promise<void>;
+    reset: () => void;
+    heldEntries: () => SidecarLockHeldEntry[];
+};
+export declare function withSidecarLock<T, TPayload extends Record<string, unknown>>(targetPath: string, options: WithSidecarLockOptions<TPayload>, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=sidecar-lock.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sidecar-lock.d.ts","sourceRoot":"","sources":["../src/sidecar-lock.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,YAAY,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AAqIjC,0FAA0F;AAC1F,wBAAgB,uBAAuB,IAAI,OAAO,CAMjD;AAuFD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM;cAU3B,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACpD,yBAAyB,CAAC,QAAQ,CAAC,KAC3C,OAAO,CAAC,iBAAiB,CAAC;eAkBL,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACxD,yBAAyB,CAAC,QAAQ,CAAC,MACxC,MAAM,OAAO,CAAC,CAAC,CAAC,KACnB,OAAO,CAAC,CAAC,CAAC;iBAqBW,OAAO,CAAC,IAAI,CAAC;iBAQnB,IAAI;uBAIE,oBAAoB,EAAE;EAW/C;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAMZ"}

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock.js

@@ -0,0 +1,265 @@
+import fsSync from "node:fs";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentity } from "./file-identity.js";
+import { removeSidecarLockIfUnchanged, sidecarLockSnapshotMatches, } from "./sidecar-lock-reclaim.js";
+import { acquireSidecarLock } from "./sidecar-lock-acquire.js";
+import { createHeldSidecarLockHandle } from "./sidecar-lock-handle.js";
+import { createSuppressedError } from "./suppressed-error.js";
+const GLOBAL_STATE_KEY = Symbol.for("fsSafe.sidecarLockManagers");
+const GLOBAL_CLEANUP_KEY = Symbol.for("fsSafe.sidecarLockCleanupRegistered");
+const GLOBAL_CLEANUP_HANDLER_KEY = Symbol.for("fsSafe.sidecarLockCleanupHandler");
+const GLOBAL_BEFORE_EXIT_KEY = Symbol.for("fsSafe.sidecarLockBeforeExitCleanup");
+// Set by copies whose exit handlers honor retainOnExit. When an older package
+// copy registered the handlers first, this marker stays absent and retained
+// acquisitions must fail closed rather than silently lose the guarantee.
+const GLOBAL_RETAIN_AWARE_KEY = Symbol.for("fsSafe.sidecarLockRetainAwareCleanup");
+function getGlobalManagers() {
+    const globalWithState = globalThis;
+    if (!globalWithState[GLOBAL_STATE_KEY]) {
+        globalWithState[GLOBAL_STATE_KEY] = new Map();
+    }
+    return globalWithState[GLOBAL_STATE_KEY];
+}
+function resolveManagerState(key) {
+    const managers = getGlobalManagers();
+    let state = managers.get(key);
+    if (!state) {
+        state = {
+            cleanupRegistered: false,
+            held: new Map(),
+            reclaimCleanupRegistered: false,
+            reclaimGuards: new Set(),
+        };
+        managers.set(key, state);
+    }
+    else {
+        // The global manager symbol is shared across package copies and hot reloads.
+        // Backfill state created by fs-safe versions that predate reclaim guards.
+        state.reclaimCleanupRegistered ??= false;
+        state.reclaimGuards ??= new Set();
+        for (const held of state.held.values()) {
+            held.refCount ??= 1;
+        }
+    }
+    return state;
+}
+function snapshotMatchesSync(lockPath, observed) {
+    let fd;
+    try {
+        const beforeStat = fsSync.lstatSync(lockPath);
+        if (!beforeStat.isFile()) {
+            return false;
+        }
+        const openFlags = fsSync.constants.O_RDONLY |
+            (process.platform !== "win32" && typeof fsSync.constants.O_NOFOLLOW === "number"
+                ? fsSync.constants.O_NOFOLLOW
+                : 0) |
+            (typeof fsSync.constants.O_NONBLOCK === "number" ? fsSync.constants.O_NONBLOCK : 0);
+        fd = fsSync.openSync(lockPath, openFlags);
+        const openedStat = fsSync.fstatSync(fd);
+        if (!openedStat.isFile()) {
+            return false;
+        }
+        if (observed.raw !== undefined && openedStat.size !== Buffer.byteLength(observed.raw)) {
+            return false;
+        }
+        const raw = fsSync.readFileSync(fd, "utf8");
+        const afterStat = fsSync.lstatSync(lockPath);
+        if (!afterStat.isFile() || !sameFileIdentity(beforeStat, afterStat)) {
+            return false;
+        }
+        return sidecarLockSnapshotMatches({ raw, payload: null, stat: afterStat }, observed);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fsSync.closeSync(fd);
+            }
+            catch {
+                // Best-effort process-exit cleanup.
+            }
+        }
+    }
+}
+function releaseAllReclaimGuardsSync(state) {
+    for (const reclaimGuardPath of state.reclaimGuards) {
+        try {
+            fsSync.rmdirSync(reclaimGuardPath);
+            state.reclaimGuards.delete(reclaimGuardPath);
+        }
+        catch {
+            // Best-effort process-exit cleanup. A surviving guard fails closed.
+        }
+    }
+}
+function releaseAllLocksSync(state, options) {
+    for (const [normalizedTargetPath, held] of state.held) {
+        void held.handle.close().catch(() => undefined);
+        try {
+            const retained = options?.preserveRetained === true && held.retainOnExit;
+            if (!retained && !held.lockRoot && snapshotMatchesSync(held.lockPath, held.snapshot)) {
+                fsSync.rmSync(held.lockPath, { force: true });
+            }
+        }
+        catch {
+            // Best-effort process-exit cleanup.
+        }
+        state.held.delete(normalizedTargetPath);
+    }
+    releaseAllReclaimGuardsSync(state);
+}
+function ensureGlobalExitCleanupRegistered() {
+    const globalWithCleanup = globalThis;
+    if (globalWithCleanup[GLOBAL_CLEANUP_KEY])
+        return;
+    globalWithCleanup[GLOBAL_CLEANUP_KEY] = true;
+    globalWithCleanup[GLOBAL_RETAIN_AWARE_KEY] = true;
+    const cleanup = () => {
+        for (const state of getGlobalManagers().values()) {
+            releaseAllLocksSync(state, { preserveRetained: true });
+        }
+    };
+    globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY] = cleanup;
+    process.on("exit", cleanup);
+}
+/** True when a retain-unaware package copy registered the process-exit handlers first. */
+export function exitCleanupCannotRetain() {
+    const globalWithCleanup = globalThis;
+    return globalWithCleanup[GLOBAL_CLEANUP_KEY] === true && globalWithCleanup[GLOBAL_RETAIN_AWARE_KEY] !== true;
+}
+function ensureGlobalBeforeExitCleanupRegistered() {
+    const globalWithCleanup = globalThis;
+    if (globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY]) {
+        return globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY];
+    }
+    // Independent of the exit registration, which an older package copy may own.
+    const lifecycle = { armed: false };
+    globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY] = lifecycle;
+    process.on("beforeExit", () => {
+        if (!lifecycle.armed)
+            return;
+        // Cleanup itself schedules I/O; retry only after another acquisition.
+        lifecycle.armed = false;
+        for (const state of getGlobalManagers().values()) {
+            for (const [normalizedTargetPath, held] of Array.from(state.held.entries())) {
+                if (held.lockRoot && !held.retainOnExit) {
+                    void releaseHeldLock(state, normalizedTargetPath, held, { force: true }).catch(() => undefined);
+                }
+            }
+        }
+    });
+    return lifecycle;
+}
+async function releaseHeldLock(state, normalizedTargetPath, held, options = {}) {
+    const current = state.held.get(normalizedTargetPath);
+    if (current !== held) {
+        return false;
+    }
+    if (held.releasePromise) {
+        await held.releasePromise;
+        return true;
+    }
+    if (options.force) {
+        held.refCount = 0;
+    }
+    else if (!options.retry && held.refCount > 0) {
+        held.refCount -= 1;
+    }
+    if (held.refCount > 0) {
+        return false;
+    }
+    held.releasePromise = (async () => {
+        await held.handle.close().catch(() => undefined);
+        await removeSidecarLockIfUnchanged(held.lockPath, held.snapshot, {
+            lockRoot: held.lockRoot,
+            parsePayload: held.parsePayload,
+        });
+        if (state.held.get(normalizedTargetPath) === held) {
+            state.held.delete(normalizedTargetPath);
+        }
+        if (held.compromiseTimer) {
+            clearInterval(held.compromiseTimer);
+            held.compromiseTimer = undefined;
+        }
+    })();
+    try {
+        await held.releasePromise;
+        return true;
+    }
+    finally {
+        held.releasePromise = undefined;
+    }
+}
+function handleForHeldLock(state, normalizedTargetPath, held) {
+    ensureGlobalBeforeExitCleanupRegistered().armed = true;
+    return createHeldSidecarLockHandle({
+        normalizedTargetPath,
+        held,
+        release: async (options) => await releaseHeldLock(state, normalizedTargetPath, held, { retry: options?.retry }),
+    });
+}
+export function createSidecarLockManager(key) {
+    const state = resolveManagerState(key);
+    function ensureExitCleanupRegistered() {
+        state.cleanupRegistered = true;
+        state.reclaimCleanupRegistered = true;
+        ensureGlobalExitCleanupRegistered();
+        ensureGlobalBeforeExitCleanupRegistered().armed = true;
+    }
+    async function acquire(options) {
+        if (options.retainOnExit === true && exitCleanupCannotRetain()) {
+            throw new FsSafeError("helper-unavailable", "retainOnExit requires this process's exit handlers to be retain-aware; an older package copy registered them first");
+        }
+        return await acquireSidecarLock(options, {
+            held: state.held,
+            reclaimGuards: state.reclaimGuards,
+            ensureExitCleanupRegistered,
+            handleForHeldLock: (normalizedTargetPath, held) => handleForHeldLock(state, normalizedTargetPath, held),
+            releaseHeldLock: async (normalizedTargetPath, held, releaseOptions) => await releaseHeldLock(state, normalizedTargetPath, held, releaseOptions),
+        });
+    }
+    async function withLock(options, fn) {
+        const lock = await acquire(options);
+        let result;
+        try {
+            result = await fn();
+        }
+        catch (bodyError) {
+            try {
+                await lock.release();
+            }
+            catch (releaseError) {
+                throw createSuppressedError(releaseError, bodyError, "file lock callback and release both failed");
+            }
+            throw bodyError;
+        }
+        await lock.release();
+        return result;
+    }
+    async function drain() {
+        for (const [normalizedTargetPath, held] of Array.from(state.held.entries())) {
+            await releaseHeldLock(state, normalizedTargetPath, held, { force: true }).catch(() => undefined);
+        }
+    }
+    function reset() {
+        releaseAllLocksSync(state);
+    }
+    function heldEntries() {
+        return Array.from(state.held.entries()).map(([normalizedTargetPath, held]) => ({
+            normalizedTargetPath,
+            lockPath: held.lockPath,
+            acquiredAt: held.acquiredAt,
+            metadata: held.metadata,
+            forceRelease: () => releaseHeldLock(state, normalizedTargetPath, held, { force: true }),
+        }));
+    }
+    return { acquire, withLock, drain, reset, heldEntries };
+}
+export async function withSidecarLock(targetPath, options, fn) {
+    const manager = createSidecarLockManager(options.managerKey ?? `fs-safe.sidecar-lock:${targetPath}`);
+    const { managerKey: _managerKey, ...acquireOptions } = options;
+    return await manager.withLock({ ...acquireOptions, targetPath }, fn);
+}

package/node_modules/@openclaw/fs-safe/dist/staged-directory.d.ts

@@ -0,0 +1,16 @@
+import type { DirectoryReceipt } from "./directory-durability.js";
+import type { FileIdentityStat } from "./file-identity.js";
+import type { StagedFileReceipt } from "./staged-file-types.js";
+type DirectorySnapshot = StagedFileReceipt["directory"];
+export declare function exactIdentityMatches(expected: FileIdentityStat, actual: Readonly<{
+    dev: bigint;
+    ino: bigint;
+}>): boolean;
+export declare function describeStagedDirectory(fd: number, pathname: string): DirectorySnapshot;
+export declare function assertStagedDirectoryCurrent(receipt: DirectorySnapshot): void;
+export declare function openStagedDirectory(directory: string | DirectoryReceipt): {
+    fd: number;
+    receipt: DirectorySnapshot;
+};
+export {};
+//# sourceMappingURL=staged-directory.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/staged-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staged-directory.d.ts","sourceRoot":"","sources":["../src/staged-directory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,KAAK,iBAAiB,GAAG,iBAAiB,CAAC,WAAW,CAAC,CAAC;AAExD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAC7C,OAAO,CAKT;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAYvF;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAQ7E;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,GAAG;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,iBAAiB,CAAC;CAC5B,CA+BA"}

package/node_modules/@openclaw/fs-safe/dist/staged-directory.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+export function exactIdentityMatches(expected, actual) {
+    return ["dev", "ino"].every((key) => {
+        const value = expected[key];
+        return (typeof value === "bigint" || Number.isSafeInteger(value)) && BigInt(value) === actual[key];
+    });
+}
+export function describeStagedDirectory(fd, pathname) {
+    const identity = fs.fstatSync(fd, { bigint: true });
+    if (!identity.isDirectory()) {
+        throw new FsSafeError("not-file", "staging parent must be a directory");
+    }
+    const receipt = Object.freeze({
+        path: path.resolve(pathname),
+        realPath: fs.realpathSync(pathname),
+        identity: Object.freeze({ dev: identity.dev, ino: identity.ino }),
+    });
+    assertStagedDirectoryCurrent(receipt);
+    return receipt;
+}
+export function assertStagedDirectoryCurrent(receipt) {
+    const current = fs.lstatSync(receipt.path, { bigint: true });
+    if (!current.isDirectory() || !exactIdentityMatches(receipt.identity, current) ||
+        fs.realpathSync(receipt.path) !== receipt.realPath) {
+        throw new FsSafeError("path-mismatch", "staging directory pathname changed");
+    }
+}
+export function openStagedDirectory(directory) {
+    // Copy supplied facts before any asynchronous work; receipts are not authority.
+    const pathname = path.resolve(typeof directory === "string" ? directory : directory.path);
+    const expected = typeof directory === "string" ? undefined : {
+        realPath: directory.realPath, dev: directory.identity.dev, ino: directory.identity.ino,
+    };
+    const before = fs.lstatSync(pathname, { bigint: true });
+    if (!before.isDirectory()) {
+        throw new FsSafeError("not-file", "staging parent must be a real directory");
+    }
+    if (expected && (!exactIdentityMatches(expected, before) || fs.realpathSync(pathname) !== expected.realPath)) {
+        throw new FsSafeError("path-mismatch", "stale staging directory receipt");
+    }
+    const fd = fs.openSync(pathname, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    try {
+        const receipt = describeStagedDirectory(fd, pathname);
+        if (!exactIdentityMatches(before, receipt.identity)) {
+            throw new FsSafeError("path-mismatch", "staging directory changed while opening");
+        }
+        return { fd, receipt };
+    }
+    catch (error) {
+        try {
+            fs.closeSync(fd);
+        }
+        catch (closeError) {
+            throw new AggregateError([error, closeError], "staging directory admission and close failed");
+        }
+        throw error;
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/staged-file-types.d.ts

@@ -0,0 +1,56 @@
+export type StagedFileReceipt = Readonly<{
+    directory: Readonly<{
+        path: string;
+        realPath: string;
+        identity: Readonly<{
+            dev: bigint;
+            ino: bigint;
+        }>;
+    }>;
+    temporaryBasename: string;
+    /** Preparation-time metadata of the private stage, not a final-file fingerprint. */
+    identity: Readonly<{
+        dev: bigint;
+        ino: bigint;
+        mode: number;
+        nlink: bigint;
+        size: bigint;
+        uid: number;
+        gid: number;
+        mtimeNs: bigint;
+        ctimeNs: bigint;
+    }>;
+}>;
+export type PublishedFileReceipt = Readonly<{
+    status: "published";
+    staged: StagedFileReceipt;
+    basename: string;
+    overwrite: boolean;
+}>;
+export type StagedFilePublication = Readonly<{
+    status: "not-published";
+}> | PublishedFileReceipt | Readonly<{
+    status: "indeterminate";
+    basename: string;
+    overwrite: boolean;
+}>;
+export type StagedFileCleanupReceipt = Readonly<{
+    temporaryBasename: string;
+    publication: StagedFilePublication;
+    status: "removed" | "name-absent" | "preserved" | "failed" | "not-needed";
+    resources: "closed" | "close-failed";
+}>;
+export type StagedFileFailureDetails = Readonly<{
+    phase: "prepare" | "publish" | "cleanup";
+    publication: StagedFilePublication;
+    cleanup?: StagedFileCleanupReceipt;
+}>;
+export interface StagedFile extends AsyncDisposable {
+    readonly receipt: StagedFileReceipt;
+    assertCurrent(): Promise<void>;
+    publish(basename: string, options: {
+        overwrite: boolean;
+    }): Promise<PublishedFileReceipt>;
+    cleanup(): Promise<StagedFileCleanupReceipt>;
+}
+//# sourceMappingURL=staged-file-types.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/staged-file-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staged-file-types.d.ts","sourceRoot":"","sources":["../src/staged-file-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,SAAS,EAAE,QAAQ,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,QAAQ,CAAC;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAClD,CAAC,CAAC;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oFAAoF;IACpF,QAAQ,EAAE,QAAQ,CAAC;QACjB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACJ,CAAC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAC7B,QAAQ,CAAC;IAAE,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC,GACrC,oBAAoB,GACpB,QAAQ,CAAC;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAEhF,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,qBAAqB,CAAC;IACnC,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,GAAG,QAAQ,GAAG,YAAY,CAAC;IAC1E,SAAS,EAAE,QAAQ,GAAG,cAAc,CAAC;CACtC,CAAC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IACzC,WAAW,EAAE,qBAAqB,CAAC;IACnC,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACpC,CAAC,CAAC;AAEH,MAAM,WAAW,UAAW,SAAQ,eAAe;IACjD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC1F,OAAO,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAC9C"}

package/node_modules/@openclaw/fs-safe/dist/staged-file-types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@openclaw/fs-safe/dist/store.d.ts

@@ -0,0 +1,4 @@
+export { fileStore, fileStoreSync, type FileStore, type FileStoreOptions, type FileStorePruneOptions, type FileStoreReadOptions, type FileStoreSync, type FileStoreWriteOptions, } from "./file-store.js";
+export { jsonStore, type JsonStore, type JsonFileStoreOptions, type JsonStoreLockOptions, type JsonStoreOptions, } from "./json-store.js";
+export { ackJsonDurableQueueEntry, ensureJsonDurableQueueDirs, jsonDurableQueueEntryExists, loadJsonDurableQueueEntry, loadPendingJsonDurableQueueEntries, moveJsonDurableQueueEntryToFailed, readJsonDurableQueueEntry, resolveJsonDurableQueueEntryPaths, unlinkBestEffort, writeJsonDurableQueueEntry, type JsonDurableQueueEntryPaths, type JsonDurableQueueLoadOptions, type JsonDurableQueueReadResult, } from "./json-durable-queue.js";
+//# sourceMappingURL=store.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,aAAa,EACb,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,qBAAqB,GAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,SAAS,EACT,KAAK,SAAS,EACd,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,yBAAyB,EACzB,kCAAkC,EAClC,iCAAiC,EACjC,yBAAyB,EACzB,iCAAiC,EACjC,gBAAgB,EAChB,0BAA0B,EAC1B,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,GAChC,MAAM,yBAAyB,CAAC"}

package/node_modules/@openclaw/fs-safe/dist/store.js

@@ -0,0 +1,3 @@
+export { fileStore, fileStoreSync, } from "./file-store.js";
+export { jsonStore, } from "./json-store.js";
+export { ackJsonDurableQueueEntry, ensureJsonDurableQueueDirs, jsonDurableQueueEntryExists, loadJsonDurableQueueEntry, loadPendingJsonDurableQueueEntries, moveJsonDurableQueueEntryToFailed, readJsonDurableQueueEntry, resolveJsonDurableQueueEntryPaths, unlinkBestEffort, writeJsonDurableQueueEntry, } from "./json-durable-queue.js";

package/node_modules/@openclaw/fs-safe/dist/strict-file-identity.d.ts

@@ -0,0 +1,6 @@
+import type { BigIntStats } from "node:fs";
+type ExactFileIdentity = Pick<BigIntStats, "dev" | "ino">;
+export declare function inspectFileIdentity<T extends ExactFileIdentity>(inspect: () => T | Promise<T>, expected?: ExactFileIdentity, platform?: NodeJS.Platform): Promise<T>;
+export declare function inspectFileIdentitySync<T extends ExactFileIdentity>(inspect: () => T, expected?: ExactFileIdentity, platform?: NodeJS.Platform): T;
+export {};
+//# sourceMappingURL=strict-file-identity.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/strict-file-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-file-identity.d.ts","sourceRoot":"","sources":["../src/strict-file-identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C,KAAK,iBAAiB,GAAG,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;AA+B1D,wBAAsB,mBAAmB,CAAC,CAAC,SAAS,iBAAiB,EACnE,OAAO,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC7B,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,OAAO,CAAC,CAAC,CAAC,CAOZ;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,iBAAiB,EACjE,OAAO,EAAE,MAAM,CAAC,EAChB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,CAAC,CAOH"}

package/node_modules/@openclaw/fs-safe/dist/strict-file-identity.js

@@ -0,0 +1,51 @@
+import { FsSafeError } from "./errors.js";
+import { recordFileObservationFailure } from "./file-observation.js";
+function identityMismatch() {
+    const error = new FsSafeError("path-mismatch", "file identity changed or could not be verified");
+    recordFileObservationFailure(error, "identity");
+    return error;
+}
+function identityCheck(expected, platform) {
+    const known = {};
+    const check = (stat) => {
+        let complete = true;
+        for (const field of ["dev", "ino"]) {
+            const value = stat[field];
+            // Numeric receipts cannot recover identity bits already lost to rounding.
+            if (typeof value !== "bigint")
+                throw identityMismatch();
+            if (platform === "win32" && value === 0n) {
+                complete = false;
+            }
+            else {
+                if (known[field] !== undefined && known[field] !== value)
+                    throw identityMismatch();
+                known[field] = value;
+            }
+        }
+        return complete;
+    };
+    if (expected && !check(expected))
+        throw identityMismatch();
+    return check;
+}
+// Retry only unknown Windows identities, retaining every known component so a
+// later observation cannot erase a definite mismatch. Never reopen the file.
+export async function inspectFileIdentity(inspect, expected, platform = process.platform) {
+    const check = identityCheck(expected, platform);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const stat = await inspect();
+        if (check(stat))
+            return stat;
+    }
+    throw identityMismatch();
+}
+export function inspectFileIdentitySync(inspect, expected, platform = process.platform) {
+    const check = identityCheck(expected, platform);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const stat = inspect();
+        if (check(stat))
+            return stat;
+    }
+    throw identityMismatch();
+}

package/node_modules/@openclaw/fs-safe/dist/string-coerce.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeNullableString(value: unknown): string | null;
+export declare function normalizeOptionalString(value: unknown): string | undefined;
+export declare function normalizeOptionalLowercaseString(value: unknown): string | undefined;
+export declare function normalizeLowercaseStringOrEmpty(value: unknown): string;
+//# sourceMappingURL=string-coerce.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/string-coerce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-coerce.d.ts","sourceRoot":"","sources":["../src/string-coerce.ts"],"names":[],"mappings":"AAAA,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAMrE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE1E;AAED,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAEnF;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEtE"}

package/node_modules/@openclaw/fs-safe/dist/string-coerce.js

@@ -0,0 +1,16 @@
+export function normalizeNullableString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+export function normalizeOptionalString(value) {
+    return normalizeNullableString(value) ?? undefined;
+}
+export function normalizeOptionalLowercaseString(value) {
+    return normalizeOptionalString(value)?.toLowerCase();
+}
+export function normalizeLowercaseStringOrEmpty(value) {
+    return normalizeOptionalLowercaseString(value) ?? "";
+}

package/node_modules/@openclaw/fs-safe/dist/suppressed-error.d.ts

@@ -0,0 +1,6 @@
+export type SuppressedErrorLike = Error & {
+    error: unknown;
+    suppressed: unknown;
+};
+export declare function createSuppressedError(error: unknown, suppressed: unknown, message: string): SuppressedErrorLike;
+//# sourceMappingURL=suppressed-error.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/suppressed-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suppressed-error.d.ts","sourceRoot":"","sources":["../src/suppressed-error.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG;IACxC,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAQF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,MAAM,GACd,mBAAmB,CAgBrB"}

package/node_modules/@openclaw/fs-safe/dist/suppressed-error.js

@@ -0,0 +1,15 @@
+export function createSuppressedError(error, suppressed, message) {
+    const constructor = globalThis.SuppressedError;
+    if (constructor) {
+        return new constructor(error, suppressed, message);
+    }
+    const combined = new Error(message, {
+        cause: error instanceof Error ? error : undefined,
+    });
+    combined.name = "SuppressedError";
+    Object.defineProperties(combined, {
+        error: { configurable: true, value: error },
+        suppressed: { configurable: true, value: suppressed },
+    });
+    return combined;
+}

package/node_modules/@openclaw/fs-safe/dist/symlink-parents.d.ts

@@ -0,0 +1,12 @@
+export type AssertNoSymlinkParentsOptions = {
+    rootDir: string;
+    targetPath: string;
+    allowMissing?: boolean;
+    allowOutsideRoot?: boolean;
+    allowRootChildSymlink?: boolean;
+    requireDirectories?: boolean;
+    messagePrefix?: string;
+};
+export declare function assertNoSymlinkParents(params: AssertNoSymlinkParentsOptions): Promise<void>;
+export declare function assertNoSymlinkParentsSync(params: AssertNoSymlinkParentsOptions): void;
+//# sourceMappingURL=symlink-parents.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/symlink-parents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symlink-parents.d.ts","sourceRoot":"","sources":["../src/symlink-parents.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAyBF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,6BAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CA6Bf;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,6BAA6B,GACpC,IAAI,CA6BN"}