@lousy-agents/lint 5.15.6 → 5.16.0

package/dist/index.js

@@ -566,7 +566,7 @@ module.exports = webpackEmptyAsyncContext;
 
 
 },
-2749(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+6179(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -884,16 +884,24 @@ function createBoundedReadStream(opened, maxBytes) {
 }
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/file-identity.js
+
 function isZero(value) {
     return value === 0 || value === 0n;
 }
+function sameStatValue(left, right) {
+    return typeof left === typeof right ? left === right : BigInt(left) === BigInt(right);
+}
+function sha256Hex(data, encoding) {
+    const buffer = typeof data === "string" ? Buffer.from(data, encoding ?? "utf8") : data;
+    return (0,external_node_crypto_.createHash)("sha256").update(buffer).digest("hex");
+}
 function file_identity_sameFileIdentity(left, right, platform = process.platform) {
-    if (left.ino !== right.ino) {
+    if (!sameStatValue(left.ino, right.ino)) {
         return false;
     }
     // On Windows, path-based stat calls can report dev=0 while fd-based stat
     // reports a real volume serial; treat either-side dev=0 as "unknown device".
-    if (left.dev === right.dev) {
+    if (sameStatValue(left.dev, right.dev)) {
         return true;
     }
     return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
@@ -2287,6 +2295,377 @@ async function runPinnedPathHelper(params) {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock.js
+
+
+
+
+const GLOBAL_STATE_KEY = Symbol.for("fsSafe.sidecarLockManagers");
+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() };
+        managers.set(key, state);
+    }
+    return state;
+}
+async function readLockSnapshot(lockPath) {
+    try {
+        const stat = await promises_.lstat(lockPath);
+        const raw = await promises_.readFile(lockPath, "utf8");
+        try {
+            const parsed = JSON.parse(raw);
+            const payload = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+            return { raw, payload, stat };
+        }
+        catch {
+            return { raw, payload: null, stat };
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+function snapshotMatches(current, observed) {
+    if (observed.stat && current.stat && !file_identity_sameFileIdentity(observed.stat, current.stat)) {
+        return false;
+    }
+    if (observed.raw !== undefined) {
+        return current.raw === observed.raw;
+    }
+    return observed.stat !== undefined && current.stat !== undefined;
+}
+async function removeLockIfUnchanged(lockPath, observed) {
+    const current = await readLockSnapshot(lockPath);
+    if (!current || !observed) {
+        return false;
+    }
+    if (!snapshotMatches(current, observed)) {
+        // The lock changed after we decided it was stale. Leave the fresh holder's
+        // file alone; deleting by path here would break mutual exclusion.
+        return false;
+    }
+    await promises_.rm(lockPath, { force: true }).catch(() => undefined);
+    return true;
+}
+async function lockSnapshotStillPresent(lockPath, observed) {
+    const current = await readLockSnapshot(lockPath);
+    return !!current && !!observed && snapshotMatches(current, observed);
+}
+async function removeStaleLockIfAllowed(params) {
+    if (!params.shouldRemoveStaleLock) {
+        return "not-approved";
+    }
+    if (params.snapshot.raw === undefined) {
+        return "not-approved";
+    }
+    if (!(await params.shouldRemoveStaleLock({
+        lockPath: params.lockPath,
+        normalizedTargetPath: params.normalizedTargetPath,
+        raw: params.snapshot.raw,
+        payload: params.snapshot.payload,
+    }))) {
+        return "not-approved";
+    }
+    const current = await readLockSnapshot(params.lockPath);
+    if (!current || !snapshotMatches(current, params.snapshot)) {
+        return "changed";
+    }
+    try {
+        await promises_.rm(params.lockPath, { force: true });
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return "changed";
+        }
+        return "not-approved";
+    }
+    return "removed";
+}
+function snapshotMatchesSync(lockPath, observed) {
+    try {
+        const stat = external_node_fs_.lstatSync(lockPath);
+        if (observed.stat && !file_identity_sameFileIdentity(observed.stat, stat)) {
+            return false;
+        }
+        return observed.raw === undefined || external_node_fs_.readFileSync(lockPath, "utf8") === observed.raw;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveNormalizedTargetPath(targetPath) {
+    const resolved = external_node_path_.resolve(targetPath);
+    const dir = external_node_path_.dirname(resolved);
+    await promises_.mkdir(dir, { recursive: true });
+    try {
+        return external_node_path_.join(await promises_.realpath(dir), external_node_path_.basename(resolved));
+    }
+    catch {
+        return resolved;
+    }
+}
+function computeDelayMs(retry, attempt) {
+    const minTimeout = retry.minTimeout ?? 50;
+    const maxTimeout = retry.maxTimeout ?? 1000;
+    const factor = retry.factor ?? 1;
+    const base = Math.min(maxTimeout, Math.max(minTimeout, minTimeout * factor ** attempt));
+    const jitter = retry.randomize ? 1 + Math.random() : 1;
+    return Math.min(maxTimeout, Math.round(base * jitter));
+}
+async function defaultShouldReclaim(params) {
+    const createdAt = typeof params.payload?.createdAt === "string" ? params.payload.createdAt : "";
+    const createdAtMs = Date.parse(createdAt);
+    if (Number.isFinite(createdAtMs) && params.nowMs - createdAtMs > params.staleMs) {
+        return true;
+    }
+    try {
+        const stat = await promises_.stat(params.lockPath);
+        return params.nowMs - stat.mtimeMs > params.staleMs;
+    }
+    catch {
+        return true;
+    }
+}
+function releaseAllLocksSync(state) {
+    for (const [normalizedTargetPath, held] of state.held) {
+        void held.handle.close().catch(() => undefined);
+        try {
+            if (snapshotMatchesSync(held.lockPath, held.snapshot)) {
+                external_node_fs_.rmSync(held.lockPath, { force: true });
+            }
+        }
+        catch {
+            // Best-effort process-exit cleanup.
+        }
+        state.held.delete(normalizedTargetPath);
+    }
+}
+async function releaseHeldLock(state, normalizedTargetPath, held, opts = {}) {
+    const current = state.held.get(normalizedTargetPath);
+    if (current !== held) {
+        return false;
+    }
+    if (opts.force) {
+        held.count = 0;
+    }
+    else {
+        held.count -= 1;
+        if (held.count > 0) {
+            return false;
+        }
+    }
+    if (held.releasePromise) {
+        await held.releasePromise.catch(() => undefined);
+        return true;
+    }
+    state.held.delete(normalizedTargetPath);
+    held.releasePromise = (async () => {
+        await held.handle.close().catch(() => undefined);
+        await removeLockIfUnchanged(held.lockPath, held.snapshot);
+    })();
+    try {
+        await held.releasePromise;
+        return true;
+    }
+    finally {
+        held.releasePromise = undefined;
+    }
+}
+function createSidecarLockManager(key) {
+    const state = resolveManagerState(key);
+    function ensureExitCleanupRegistered() {
+        if (state.cleanupRegistered) {
+            return;
+        }
+        state.cleanupRegistered = true;
+        process.on("exit", () => releaseAllLocksSync(state));
+    }
+    async function acquire(options) {
+        ensureExitCleanupRegistered();
+        const normalizedTargetPath = await resolveNormalizedTargetPath(options.targetPath);
+        const lockPath = options.lockPath ?? `${normalizedTargetPath}.lock`;
+        const held = state.held.get(normalizedTargetPath);
+        if (held && options.allowReentrant) {
+            held.count += 1;
+            const release = () => releaseHeldLock(state, normalizedTargetPath, held).then(() => undefined);
+            return {
+                lockPath,
+                normalizedTargetPath,
+                release,
+                [Symbol.asyncDispose]: release,
+            };
+        }
+        const startedAt = Date.now();
+        const retry = options.retry ?? {};
+        const maxRetries = options.timeoutMs === Number.POSITIVE_INFINITY ? undefined : retry.retries;
+        let attempt = 0;
+        while (true) {
+            let handle = null;
+            try {
+                handle = await promises_.open(lockPath, "wx");
+                const payload = await options.payload();
+                const raw = `${JSON.stringify(payload, null, 2)}\n`;
+                await handle.writeFile(raw, "utf8");
+                const snapshot = { raw, payload, stat: await handle.stat() };
+                const createdHeld = {
+                    count: 1,
+                    handle,
+                    lockPath,
+                    snapshot,
+                    acquiredAt: Date.now(),
+                    metadata: options.metadata ?? {},
+                };
+                state.held.set(normalizedTargetPath, createdHeld);
+                const release = () => releaseHeldLock(state, normalizedTargetPath, createdHeld).then(() => undefined);
+                return {
+                    lockPath,
+                    normalizedTargetPath,
+                    release,
+                    [Symbol.asyncDispose]: release,
+                };
+            }
+            catch (err) {
+                if (handle) {
+                    const failedSnapshot = { payload: null };
+                    try {
+                        failedSnapshot.stat = await handle.stat();
+                    }
+                    catch {
+                        // Best-effort cleanup of a failed exclusive create.
+                    }
+                    const current = state.held.get(normalizedTargetPath);
+                    if (current?.handle === handle) {
+                        state.held.delete(normalizedTargetPath);
+                    }
+                    // If payload serialization/write fails, the file may be empty or
+                    // partial JSON, so remove while our exclusive handle is still open.
+                    await promises_.rm(lockPath, { force: true }).catch(() => undefined);
+                    await handle.close().catch(() => undefined);
+                    // Windows can refuse removing an open file; retry after close but
+                    // only if the path still points at the file identity we created.
+                    await removeLockIfUnchanged(lockPath, failedSnapshot);
+                }
+                if (err.code !== "EEXIST") {
+                    throw err;
+                }
+                const nowMs = Date.now();
+                const snapshot = await readLockSnapshot(lockPath);
+                if (!snapshot) {
+                    continue;
+                }
+                const shouldReclaim = options.shouldReclaim ?? defaultShouldReclaim;
+                if (await shouldReclaim({
+                    lockPath,
+                    normalizedTargetPath,
+                    payload: snapshot?.payload ?? null,
+                    staleMs: options.staleMs,
+                    nowMs,
+                    heldByThisProcess: state.held.has(normalizedTargetPath),
+                })) {
+                    if (!(await lockSnapshotStillPresent(lockPath, snapshot))) {
+                        continue;
+                    }
+                    const staleRecovery = options.staleRecovery ?? "fail-closed";
+                    if (staleRecovery === "remove-if-unchanged") {
+                        const removal = await removeStaleLockIfAllowed({
+                            lockPath,
+                            normalizedTargetPath,
+                            snapshot,
+                            shouldRemoveStaleLock: options.shouldRemoveStaleLock,
+                        });
+                        if (removal === "removed" || removal === "changed") {
+                            continue;
+                        }
+                    }
+                    throw Object.assign(new Error(`file lock stale for ${normalizedTargetPath}`), {
+                        code: "file_lock_stale",
+                        lockPath,
+                        normalizedTargetPath,
+                    });
+                }
+                const elapsed = Date.now() - startedAt;
+                if ((options.timeoutMs !== undefined &&
+                    options.timeoutMs !== Number.POSITIVE_INFINITY &&
+                    elapsed >= options.timeoutMs) ||
+                    (maxRetries !== undefined && attempt >= maxRetries)) {
+                    throw Object.assign(new Error(`file lock timeout for ${normalizedTargetPath}`), {
+                        code: "file_lock_timeout",
+                        lockPath,
+                        normalizedTargetPath,
+                    });
+                }
+                const remaining = options.timeoutMs === undefined || options.timeoutMs === Number.POSITIVE_INFINITY
+                    ? Number.POSITIVE_INFINITY
+                    : Math.max(0, options.timeoutMs - elapsed);
+                const delay = Math.min(computeDelayMs(retry, attempt), remaining);
+                attempt += 1;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    async function withLock(options, fn) {
+        const lock = await acquire(options);
+        try {
+            return await fn();
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    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 };
+}
+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);
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
+let test_hooks_fsSafeTestHooks;
+function allowFsSafeTestHooks() {
+    return  false || process.env.VITEST === "true";
+}
+function getFsSafeTestHooks() {
+    return test_hooks_fsSafeTestHooks;
+}
+function __setFsSafeTestHooksForTest(hooks) {
+    if (hooks && !allowFsSafeTestHooks()) {
+        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
+    }
+    test_hooks_fsSafeTestHooks = hooks;
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-write.js
 
 
@@ -2300,6 +2679,8 @@ async function runPinnedPathHelper(params) {
 
 
 
+
+
 function byteLength(input, encoding) {
     return typeof input === "string"
         ? Buffer.byteLength(input, encoding ?? "utf8")
@@ -2357,6 +2738,12 @@ async function runPinnedWriteHelper(params) {
     validatePinnedOperationPayload({
         relativeParentPath: params.relativeParentPath,
     });
+    // The Python helper deliberately enforces the strict post-rename inode
+    // contract. The explicit compatibility policy therefore uses the guarded
+    // Node fallback, where content verification can replace that one check.
+    if (params.onRenameIdentityMismatch === "verify-content") {
+        return await runPinnedWriteFallback(params);
+    }
     if (getFsSafePythonConfig().mode === "off") {
         return await runPinnedWriteFallback(params);
     }
@@ -2371,8 +2758,11 @@ async function runPinnedWriteHelper(params) {
             throw error;
         }
     }
+    const input = params.input.kind === "stream"
+        ? { kind: "buffer", data: Buffer.from(await inputToBase64(params.input, params.maxBytes), "base64") }
+        : params.input;
     const payload = {
-        base64: await inputToBase64(params.input, params.maxBytes),
+        base64: await inputToBase64(input, params.maxBytes),
         basename: params.basename,
         maxBytes: params.maxBytes ?? -1,
         mkdir: params.mkdir,
@@ -2390,11 +2780,32 @@ async function runPinnedWriteHelper(params) {
     }
     catch (error) {
         if (canFallbackFromPythonError(error)) {
-            return await runPinnedWriteFallback(params);
+            return await runPinnedWriteFallback({ ...params, input });
         }
         throw error;
     }
 }
+async function runPinnedWriteWithRenamePolicy(params) {
+    const { targetPath, renameIdentity, ...writeParams } = params;
+    if (renameIdentity !== "verify-content-with-lock") {
+        return await runPinnedWriteHelper(writeParams);
+    }
+    const relativeTargetPath = writeParams.relativeParentPath
+        ? `${writeParams.relativeParentPath}/${writeParams.basename}`
+        : writeParams.basename;
+    const lockPath = external_node_path_.join(writeParams.rootPath, `.fs-safe-write-${sha256Hex(relativeTargetPath)}.lock`);
+    return await withSidecarLock(writeParams.rootPath, {
+        managerKey: `fs-safe.write:${targetPath}`,
+        lockPath,
+        staleMs: 30_000,
+        timeoutMs: 5_000,
+        payload: () => ({ pid: process.pid, createdAt: new Date().toISOString() }),
+        retry: { retries: 5, minTimeout: 100, maxTimeout: 2_000, factor: 2 },
+    }, async () => await runPinnedWriteHelper({
+        ...writeParams,
+        onRenameIdentityMismatch: "verify-content",
+    }));
+}
 async function runPinnedCopyHelper(params) {
     assertSafeBasename(params.basename);
     validatePinnedOperationPayload({
@@ -2450,7 +2861,10 @@ async function runPinnedWriteFallback(params) {
             else {
                 await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
             }
+            await handle.sync();
             const stat = await handle.stat();
+            await handle.close().catch(() => undefined);
+            await syncDirectoryBestEffort(parentPath);
             created = false;
             return { dev: stat.dev, ino: stat.ino };
         }
@@ -2498,11 +2912,49 @@ async function runPinnedWriteFallback(params) {
         await withAsyncDirectoryGuards([parentGuard], async () => {
             await promises_.rename(tempPath, targetPath);
             renamed = true;
+            await getFsSafeTestHooks()?.afterPinnedWriteFallbackRename?.(targetPath);
             await syncDirectoryBestEffort(parentPath);
             targetStat = await promises_.lstat(targetPath);
-            if (targetStat.isSymbolicLink() || !file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
+            if (targetStat.isSymbolicLink()) {
                 throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
             }
+            if (!file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
+                // On filesystems like rclone FUSE, rename(2) can give the destination a
+                // different inode from the source temp fd even with zero concurrency. The
+                // caller must ensure mutual exclusion before passing "verify-content";
+                // fall back to a content hash for this rename-boundary check only.
+                if (params.onRenameIdentityMismatch !== "verify-content") {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                if (params.input.kind !== "buffer") {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                const expectedHash = sha256Hex(params.input.data, params.input.encoding);
+                const readFlags = external_node_fs_.constants.O_RDONLY |
+                    (process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_.constants
+                        ? external_node_fs_.constants.O_NOFOLLOW
+                        : 0);
+                const readHandle = await promises_.open(targetPath, readFlags);
+                let actualHash;
+                let readHandleStat;
+                try {
+                    // Capture fd-based identity before reading — this is stable across all
+                    // subsequent lookups (on FUSE and locally), unlike the lstat-based
+                    // targetStat that triggered this fallback.
+                    readHandleStat = await readHandle.stat();
+                    actualHash = sha256Hex(await readHandle.readFile());
+                }
+                finally {
+                    await readHandle.close().catch(() => undefined);
+                }
+                if (actualHash !== expectedHash) {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                // Replace the unreliable lstat-based targetStat with the fd-based stat so
+                // the returned identity is consistent with what subsequent verifications
+                // (e.g. verifyAtomicWriteResult) will obtain by opening the same file.
+                targetStat = readHandleStat;
+            }
         });
     }
     catch (error) {
@@ -3598,21 +4050,6 @@ function normalizePinnedPathError(error) {
     });
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
-let test_hooks_fsSafeTestHooks;
-function allowFsSafeTestHooks() {
-    return  false || process.env.VITEST === "true";
-}
-function getFsSafeTestHooks() {
-    return test_hooks_fsSafeTestHooks;
-}
-function __setFsSafeTestHooksForTest(hooks) {
-    if (hooks && !allowFsSafeTestHooks()) {
-        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
-    }
-    test_hooks_fsSafeTestHooks = hooks;
-}
-
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/json-stringify.js
 function stringifyJsonDocument(value, replacer, space) {
     const text = JSON.stringify(value, replacer, space);
@@ -3948,6 +4385,7 @@ class RootHandle {
             data,
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
+            renameIdentity: this.defaults.renameIdentity,
             ...options,
             denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
@@ -4382,21 +4820,23 @@ async function writeFileInRoot(root, params) {
 async function commitPinnedWriteInRoot(root, pinned, params) {
     let identity;
     try {
-        identity = await runPinnedWriteHelper({
+        identity = await runPinnedWriteWithRenamePolicy({
             rootPath: pinned.rootReal,
             relativeParentPath: pinned.relativeParentPath,
             basename: pinned.basename,
+            targetPath: pinned.targetPath,
+            renameIdentity: params.renameIdentity,
             mkdir: params.mkdir !== false,
             mode: params.mode ?? pinned.mode,
             overwrite: params.overwrite,
-            input: {
-                kind: "buffer",
-                data: params.data,
-                encoding: params.encoding,
-            },
+            input: { kind: "buffer", data: params.data, encoding: params.encoding },
         });
     }
     catch (error) {
+        const errorCode = error?.code;
+        if (errorCode === "file_lock_stale" || errorCode === "file_lock_timeout") {
+            throw error;
+        }
         if (params.overwrite === false && isAlreadyExistsError(error)) {
             throw new errors_FsSafeError("already-exists", "file already exists", {
                 cause: error instanceof Error ? error : undefined,
@@ -35399,77 +35839,6 @@ function safeDestr(value, options = {}) {
 
 
 
-;// CONCATENATED MODULE: ../../node_modules/defu/dist/defu.mjs
-function defu_isPlainObject(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
-    return false;
-  }
-  if (Symbol.iterator in value) {
-    return false;
-  }
-  if (Symbol.toStringTag in value) {
-    return Object.prototype.toString.call(value) === "[object Module]";
-  }
-  return true;
-}
-
-function defu_defu(baseObject, defaults, namespace = ".", merger) {
-  if (!defu_isPlainObject(defaults)) {
-    return defu_defu(baseObject, {}, namespace, merger);
-  }
-  const object = { ...defaults };
-  for (const key of Object.keys(baseObject)) {
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = baseObject[key];
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (merger && merger(object, key, value, namespace)) {
-      continue;
-    }
-    if (Array.isArray(value) && Array.isArray(object[key])) {
-      object[key] = [...value, ...object[key]];
-    } else if (defu_isPlainObject(value) && defu_isPlainObject(object[key])) {
-      object[key] = defu_defu(
-        value,
-        object[key],
-        (namespace ? `${namespace}.` : "") + key.toString(),
-        merger
-      );
-    } else {
-      object[key] = value;
-    }
-  }
-  return object;
-}
-function defu_createDefu(merger) {
-  return (...arguments_) => (
-    // eslint-disable-next-line unicorn/no-array-reduce
-    arguments_.reduce((p, c) => defu_defu(p, c, "", merger), {})
-  );
-}
-const dist_defu_defu = defu_createDefu();
-const defuFn = defu_createDefu((object, key, currentValue) => {
-  if (object[key] !== void 0 && typeof currentValue === "function") {
-    object[key] = currentValue(object[key]);
-    return true;
-  }
-});
-const defuArrayFn = defu_createDefu((object, key, currentValue) => {
-  if (Array.isArray(object[key]) && typeof currentValue === "function") {
-    object[key] = currentValue(object[key]);
-    return true;
-  }
-});
-
-
-
 ;// CONCATENATED MODULE: ../../node_modules/rc9/dist/index.mjs
 
 
@@ -35630,6 +35999,77 @@ function updateUser(config, options) {
 //#endregion
 
 
+;// CONCATENATED MODULE: ../../node_modules/defu/dist/defu.mjs
+function defu_isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+
+function defu_defu(baseObject, defaults, namespace = ".", merger) {
+  if (!defu_isPlainObject(defaults)) {
+    return defu_defu(baseObject, {}, namespace, merger);
+  }
+  const object = { ...defaults };
+  for (const key of Object.keys(baseObject)) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (defu_isPlainObject(value) && defu_isPlainObject(object[key])) {
+      object[key] = defu_defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function defu_createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => defu_defu(p, c, "", merger), {})
+  );
+}
+const dist_defu_defu = defu_createDefu();
+const defuFn = (/* unused pure expression or super */ null && (defu_createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+})));
+const defuArrayFn = (/* unused pure expression or super */ null && (defu_createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+})));
+
+
+
 // EXTERNAL MODULE: ../../node_modules/confbox/dist/_chunks/_format.mjs
 var _format = __webpack_require__(5492);
 ;// CONCATENATED MODULE: ../../node_modules/confbox/dist/_chunks/json.mjs
@@ -40535,7 +40975,7 @@ exports.prettifyError = prettifyError;
 
 },
 3519(__unused_rspack_module, exports, __webpack_require__) {
-var __webpack_unused_export__;
+var __rspack_unused_export;
 
 
 var composer = __webpack_require__(8480);
@@ -40557,35 +40997,35 @@ var visit = __webpack_require__(4364);
 
 
 
-__webpack_unused_export__ = composer.Composer;
-__webpack_unused_export__ = Document.Document;
-__webpack_unused_export__ = Schema.Schema;
-__webpack_unused_export__ = errors.YAMLError;
-__webpack_unused_export__ = errors.YAMLParseError;
-__webpack_unused_export__ = errors.YAMLWarning;
-__webpack_unused_export__ = Alias.Alias;
-__webpack_unused_export__ = identity.isAlias;
-__webpack_unused_export__ = identity.isCollection;
-__webpack_unused_export__ = identity.isDocument;
-__webpack_unused_export__ = identity.isMap;
-__webpack_unused_export__ = identity.isNode;
-__webpack_unused_export__ = identity.isPair;
-__webpack_unused_export__ = identity.isScalar;
-__webpack_unused_export__ = identity.isSeq;
-__webpack_unused_export__ = Pair.Pair;
-__webpack_unused_export__ = Scalar.Scalar;
-__webpack_unused_export__ = YAMLMap.YAMLMap;
-__webpack_unused_export__ = YAMLSeq.YAMLSeq;
-__webpack_unused_export__ = cst;
-__webpack_unused_export__ = lexer.Lexer;
-__webpack_unused_export__ = lineCounter.LineCounter;
-__webpack_unused_export__ = parser.Parser;
+__rspack_unused_export = composer.Composer;
+__rspack_unused_export = Document.Document;
+__rspack_unused_export = Schema.Schema;
+__rspack_unused_export = errors.YAMLError;
+__rspack_unused_export = errors.YAMLParseError;
+__rspack_unused_export = errors.YAMLWarning;
+__rspack_unused_export = Alias.Alias;
+__rspack_unused_export = identity.isAlias;
+__rspack_unused_export = identity.isCollection;
+__rspack_unused_export = identity.isDocument;
+__rspack_unused_export = identity.isMap;
+__rspack_unused_export = identity.isNode;
+__rspack_unused_export = identity.isPair;
+__rspack_unused_export = identity.isScalar;
+__rspack_unused_export = identity.isSeq;
+__rspack_unused_export = Pair.Pair;
+__rspack_unused_export = Scalar.Scalar;
+__rspack_unused_export = YAMLMap.YAMLMap;
+__rspack_unused_export = YAMLSeq.YAMLSeq;
+__rspack_unused_export = cst;
+__rspack_unused_export = lexer.Lexer;
+__rspack_unused_export = lineCounter.LineCounter;
+__rspack_unused_export = parser.Parser;
 exports.qg = publicApi.parse;
-__webpack_unused_export__ = publicApi.parseAllDocuments;
-__webpack_unused_export__ = publicApi.parseDocument;
-__webpack_unused_export__ = publicApi.stringify;
-__webpack_unused_export__ = visit.visit;
-__webpack_unused_export__ = visit.visitAsync;
+__rspack_unused_export = publicApi.parseAllDocuments;
+__rspack_unused_export = publicApi.parseDocument;
+__rspack_unused_export = publicApi.stringify;
+__rspack_unused_export = visit.visit;
+__rspack_unused_export = visit.visitAsync;
 
 
 },
@@ -46497,14 +46937,14 @@ __webpack_require__.r = (exports) => {
       var installedChunks = {410: 0,};
       var installChunk = (data) => {
     var __rspack_esm_ids = data.__rspack_esm_ids;
-    var __webpack_modules__ = data.__webpack_modules__;
+    var moreModules = data.__webpack_modules__;
     var __rspack_esm_runtime = data.__rspack_esm_runtime;
     // add "modules" to the modules object,
     // then flag all "ids" as loaded and fire callback
     var moduleId, chunkId, i = 0;
-    for (moduleId in __webpack_modules__) {
-        if (__webpack_require__.o(__webpack_modules__, moduleId)) {
-            __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
+    for (moduleId in moreModules) {
+        if (__webpack_require__.o(moreModules, moduleId)) {
+            __webpack_require__.m[moduleId] = moreModules[moduleId];
         }
     }
     if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
@@ -46517,6 +46957,7 @@ __webpack_require__.r = (exports) => {
     }
     
 };
+
         __webpack_require__.f.j = function (chunkId, promises) {
           // import() chunk loading for javascript
 var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
@@ -46549,7 +46990,7 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(2749);
+var __webpack_exports__ = __webpack_require__(6179);
 var __webpack_exports__DEFAULT_LINT_RULES = __webpack_exports__.Kd;
 var __webpack_exports__LintValidationError = __webpack_exports__.F5;
 var __webpack_exports__createFormatter = __webpack_exports__.xi;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/lint",
-    "version": "5.15.6",
+    "version": "5.16.0",
     "description": "Programmatic lint API for validating AI coding assistant configurations — skills, agents, hooks, and instructions",
     "type": "module",
     "repository": {