dominds 1.25.16 → 1.25.18

package/dist/llm/kernel-driver/drive.js

@@ -714,6 +714,146 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
         },
     },
 ];
+const CONTEXT_HEALTH_TOOL_RESULT_VISIBLE_BYTE_LIMIT = 2000;
+const CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_ZH = '这次函数返回内容太大，清理头脑之前当前不可见。';
+const CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_EN = 'This function returned too much content, so it is not visible before clear_mind.';
+function getContextHealthRemediationLevel(snapshot) {
+    if (snapshot?.kind !== 'available') {
+        return undefined;
+    }
+    return snapshot.level === 'caution' || snapshot.level === 'critical' ? snapshot.level : undefined;
+}
+function pickContextHealthForLargeToolResultVisibility(args) {
+    if (args.current?.kind === 'available') {
+        return args.current;
+    }
+    return args.previous;
+}
+function formatContextHealthLargeToolReturnUnavailable(args) {
+    const approxBytes = new Intl.NumberFormat(args.language === 'zh' ? 'zh-CN' : 'en-US').format(args.originalBytes);
+    if (args.language === 'zh') {
+        if (args.dlg instanceof dialog_1.SideDialog) {
+            return [
+                CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_ZH,
+                '',
+                '不要重试获取这类大段输出。现在先做两件事：',
+                '1. 把需要回传给主线对话的结论、证据定位和风险整理清楚。',
+                '2. 若还有恢复工作会丢的信息，写入提醒项。',
+                '',
+                '然后尽快完成当前支线回复；如果你有 clear_mind({})，再调用它开启新一程。',
+                '',
+                `详情：本次返回约 ${approxBytes} 字节。`,
+            ].join('\n');
+        }
+        return [
+            CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_ZH,
+            '',
+            '不要重试获取这类大段输出。现在先做两件事：',
+            '1. 把下一程还需要知道的信息写入差遣牒合适章节。',
+            '2. 把差遣牒没有覆盖、但恢复工作会丢的信息写入提醒项。',
+            '',
+            '然后调用 clear_mind({}) 开启新一程。',
+            '',
+            `详情：本次返回约 ${approxBytes} 字节。`,
+        ].join('\n');
+    }
+    if (args.dlg instanceof dialog_1.SideDialog) {
+        return [
+            CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_EN,
+            '',
+            'Do not retry fetching this kind of large output. Do two things now:',
+            '1. Organize the conclusion, evidence pointers, and risks that need to go back to the Main Dialog.',
+            '2. If any resume-critical details would otherwise be lost, write them into reminders.',
+            '',
+            'Then finish the current Side Dialog reply as soon as possible; if you have clear_mind({}), call it to start a new course.',
+            '',
+            `Detail: this return was about ${approxBytes} bytes.`,
+        ].join('\n');
+    }
+    return [
+        CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_EN,
+        '',
+        'Do not retry fetching this kind of large output. Do two things now:',
+        '1. Write the information the next course still needs into the appropriate Taskdoc sections.',
+        '2. Write any resume-critical details not covered by Taskdoc into reminders.',
+        '',
+        'Then call clear_mind({}) to start a new course.',
+        '',
+        `Detail: this return was about ${approxBytes} bytes.`,
+    ].join('\n');
+}
+function countToolResultVisibleBytes(output) {
+    const items = output.contentItems;
+    if (!Array.isArray(items) || items.length === 0) {
+        return Buffer.byteLength(output.content, 'utf8');
+    }
+    let bytes = Buffer.byteLength(output.content, 'utf8');
+    for (const item of items) {
+        switch (item.type) {
+            case 'input_text':
+                bytes += Buffer.byteLength(item.text, 'utf8');
+                break;
+            case 'input_image':
+                bytes += item.byteLength;
+                break;
+            default: {
+                throw new Error(`Unsupported function result content item: ${String(item.type)}`);
+            }
+        }
+    }
+    return bytes;
+}
+function applyContextHealthToolResultVisibilityLimit(args) {
+    if (getContextHealthRemediationLevel(args.contextHealth) === undefined) {
+        return { output: args.output, largeReturnUnavailable: false };
+    }
+    const visibleBytes = countToolResultVisibleBytes(args.output);
+    if (visibleBytes <= CONTEXT_HEALTH_TOOL_RESULT_VISIBLE_BYTE_LIMIT) {
+        return { output: args.output, largeReturnUnavailable: false };
+    }
+    return {
+        output: {
+            content: formatContextHealthLargeToolReturnUnavailable({
+                dlg: args.dlg,
+                originalBytes: visibleBytes,
+                language: args.language,
+            }),
+            outcome: args.output.outcome,
+        },
+        largeReturnUnavailable: true,
+    };
+}
+function isContextHealthLargeToolReturnUnavailableResult(content) {
+    return (content.includes(CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_ZH) ||
+        content.includes(CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_EN));
+}
+function latestInputLikeMessageIsContextHealthLargeToolReturnUnavailableResult(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const msg = messages[index];
+        if (msg === undefined) {
+            continue;
+        }
+        switch (msg.type) {
+            case 'func_result_msg':
+                return isContextHealthLargeToolReturnUnavailableResult(msg.content);
+            case 'prompting_msg':
+            case 'tellask_result_msg':
+            case 'tellask_carryover_msg':
+                return false;
+            case 'environment_msg':
+            case 'transient_guide_msg':
+            case 'saying_msg':
+            case 'thinking_msg':
+            case 'func_call_msg':
+                break;
+            default: {
+                const _exhaustive = msg;
+                throw new Error(`Unsupported chat message while checking latest input-like message: ${_exhaustive}`);
+            }
+        }
+    }
+    return false;
+}
 function mergeTellaskVirtualTools(baseTools, options) {
     const merged = [...baseTools];
     const seen = new Set(merged.map((tool) => tool.name));
@@ -1806,6 +1946,7 @@ async function executeFunctionCalls(args) {
     const functionPromises = preparedCalls.map(async ({ func, originalFunc, callGenseq, argsStr, tool, preparedInvocationArgs, }) => {
         let result;
         let outcome = 'success';
+        let forceImmediateFollowup = false;
         let rethrowError;
         if (!tool) {
             outcome = 'failure';
@@ -1846,16 +1987,24 @@ async function executeFunctionCalls(args) {
                     throwIfAborted(args.abortSignal, args.dlg);
                     const output = await tool.call(args.dlg, args.agent, preparedInvocationArgs.args);
                     throwIfAborted(args.abortSignal, args.dlg);
-                    outcome = output.outcome;
+                    const visibleResult = applyContextHealthToolResultVisibilityLimit({
+                        dlg: args.dlg,
+                        output,
+                        contextHealth: args.contextHealthForToolResultVisibility,
+                        language: (0, work_language_1.getWorkLanguage)(),
+                    });
+                    const visibleOutput = visibleResult.output;
+                    forceImmediateFollowup = visibleResult.largeReturnUnavailable;
+                    outcome = visibleOutput.outcome;
                     result = {
                         type: 'func_result_msg',
                         id: func.id,
                         rawId: func.rawId,
                         effectiveId: func.effectiveId,
                         name: func.name,
-                        content: output.content,
-                        contentItems: Array.isArray(output.contentItems)
-                            ? [...output.contentItems]
+                        content: visibleOutput.content,
+                        contentItems: Array.isArray(visibleOutput.contentItems)
+                            ? [...visibleOutput.contentItems]
                             : undefined,
                         role: 'tool',
                         genseq: callGenseq,
@@ -1886,7 +2035,7 @@ async function executeFunctionCalls(args) {
         if (rethrowError !== undefined) {
             throw rethrowError;
         }
-        return { func, originalFunc, outcome, result };
+        return { func, originalFunc, outcome, forceImmediateFollowup, result };
     });
     return await Promise.all(functionPromises);
 }
@@ -1934,12 +2083,16 @@ async function executeFunctionRound(args) {
         agentTools: args.agentTools,
         funcCalls: tellaskRound.normalCalls,
         abortSignal: args.abortSignal,
+        contextHealthForToolResultVisibility: args.contextHealthForToolResultVisibility,
     });
     const genericExecutionByOriginalCall = new Map(genericExecutions.map((execution) => [execution.originalFunc, execution]));
     const funcToolByName = new Map(args.agentTools
         .filter((tool) => tool.type === 'func')
         .map((tool) => [tool.name, tool]));
     const genericOutcomeByCallId = new Map(genericExecutions.map((execution) => [execution.result.id, execution.outcome]));
+    const forceImmediateFollowupCallIds = new Set(genericExecutions
+        .filter((execution) => execution.forceImmediateFollowup)
+        .map((execution) => execution.result.id));
     const immediateFollowupCallIds = [];
     for (const call of tellaskRound.normalCalls) {
         const tool = funcToolByName.get(call.name);
@@ -1947,7 +2100,8 @@ async function executeFunctionRound(args) {
         if (outcome === undefined) {
             throw new Error(`kernel-driver function outcome invariant violation: missing outcome for call id '${call.id}' (${call.name})`);
         }
-        if (shouldImmediatelyFollowUpToolOutcome(tool, outcome)) {
+        if (forceImmediateFollowupCallIds.has(call.id) ||
+            shouldImmediatelyFollowUpToolOutcome(tool, outcome)) {
             immediateFollowupCallIds.push(call.id);
         }
     }
@@ -2364,7 +2518,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         cautionRemediationCadenceGenerations,
                         criticalCountdownRemaining,
                     });
-                    if (healthDecision.kind === 'continue') {
+                    if (healthDecision.kind === 'continue' &&
+                        !latestInputLikeMessageIsContextHealthLargeToolReturnUnavailableResult(dlg.msgs)) {
                         if (healthDecision.reason === 'critical_force_new_course') {
                             const language = (0, work_language_1.getWorkLanguage)();
                             const newCoursePrompt = (0, driver_messages_1.formatNewCourseStartPrompt)(language, {
@@ -3083,6 +3238,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         return { usage: res.usage, llmGenModel: res.llmGenModel };
                     };
                     const previousAssistantSayingGenseq = lastAssistantSayingGenseq;
+                    const contextHealthBeforeGen = dlg.getLastContextHealth();
                     const llmOutput = await streamOrBatch();
                     if (typeof llmOutput.llmGenModel === 'string' && llmOutput.llmGenModel.trim() !== '') {
                         llmGenModelForGen = llmOutput.llmGenModel.trim();
@@ -3279,6 +3435,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         abortSignal,
                         allowTellaskFunctions: policy.allowTellaskFunctions,
                         activePromptReplyDirective: currentPrompt?.tellaskReplyDirective,
+                        contextHealthForToolResultVisibility: pickContextHealthForLargeToolResultVisibility({
+                            previous: contextHealthBeforeGen,
+                            current: contextHealthForGen,
+                        }),
                     });
                     if (routed.tellaskToolOutputs.length > 0) {
                         newMsgs.push(...routed.tellaskToolOutputs);

package/dist/persistence.js

@@ -345,7 +345,7 @@ async function normalizeIdleWhileReplyObligationPending(dialogId, status, previo
         executionMarker: healedExecutionMarker,
     };
 }
-const quarantiningMainDialogs = new Set();
+const quarantiningMainDialogs = new Map();
 const PERSISTABLE_DIALOG_STATUSES = ['running', 'completed', 'archived'];
 const RUN_STATUS_DIR = 'run';
 const DONE_STATUS_DIR = 'done';
@@ -5458,74 +5458,119 @@ class DialogPersistence {
     static async quarantineMalformedDialog(dialogId, status, reason, error) {
         const mainDialogId = dialogId.rootId === dialogId.selfId ? dialogId : new dialog_1.DialogID(dialogId.rootId);
         const quarantineKey = `${status}|${mainDialogId.selfId}`;
-        if (quarantiningMainDialogs.has(quarantineKey)) {
-            return;
-        }
-        quarantiningMainDialogs.add(quarantineKey);
-        let quarantined = false;
-        try {
-            await prepareDialogQuarantineHook?.({
-                dialogId,
-                mainDialogId,
-                status,
-                reason,
-                error,
-            });
-            this.quarantinedMainDialogScopes.add(this.getMainDialogWriteBackCancelScopeKey(mainDialogId, status));
-            this.cancelMainDialogWriteBacks(mainDialogId, status);
-            const sourcePath = this.getMainDialogPath(mainDialogId, status);
-            if (!(await this.pathExists(sourcePath))) {
-                return;
-            }
-            let destinationPath = this.getMalformedMainDialogPath(mainDialogId, status);
-            if (await this.pathExists(destinationPath)) {
-                destinationPath = path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, `${mainDialogId.selfId}__${(0, node_crypto_1.randomUUID)()}`);
-            }
-            await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
-            await fs.promises.rename(sourcePath, destinationPath);
-            quarantined = true;
-            log_1.log.warn(`Quarantined malformed dialog ${mainDialogId.selfId}`, undefined, {
-                status,
-                reason,
-                sourcePath,
-                destinationPath,
-                errorMessage: error.message,
-                dialogId: dialogId.valueOf(),
-                mainDialogId: mainDialogId.valueOf(),
-            });
-            dialogsQuarantinedBroadcaster?.({
-                type: 'dialogs_quarantined',
-                status: 'quarantining',
-                fromStatus: assertPersistableDialogStatus(status, 'DialogPersistence.quarantineMalformedDialog(fromStatus)'),
-                rootId: mainDialogId.selfId,
-                dialogId: dialogId.selfId,
-                reason,
-                timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            });
+        const activeQuarantine = quarantiningMainDialogs.get(quarantineKey);
+        if (activeQuarantine) {
+            return await activeQuarantine;
         }
-        finally {
+        const quarantinePromise = Promise.resolve().then(async () => {
+            let quarantined = false;
+            let writeBackCancelScopeKey = null;
             try {
-                await finalizeDialogQuarantineHook?.({
+                await prepareDialogQuarantineHook?.({
                     dialogId,
                     mainDialogId,
                     status,
                     reason,
                     error,
-                    quarantined,
+                });
+                writeBackCancelScopeKey = this.getMainDialogWriteBackCancelScopeKey(mainDialogId, status);
+                this.quarantinedMainDialogScopes.add(writeBackCancelScopeKey);
+                this.cancelMainDialogWriteBacks(mainDialogId, status);
+                const sourcePath = this.getMainDialogPath(mainDialogId, status);
+                if (!(await this.pathExists(sourcePath))) {
+                    return true;
+                }
+                let destinationPath = this.getMalformedMainDialogPath(mainDialogId, status);
+                if (await this.pathExists(destinationPath)) {
+                    destinationPath = path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, `${mainDialogId.selfId}__${(0, node_crypto_1.randomUUID)()}`);
+                }
+                await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
+                try {
+                    await this.renameWithRetry(sourcePath, destinationPath);
+                }
+                catch (renameError) {
+                    log_1.log.error('Failed to quarantine malformed dialog; dialog remains in its source status', renameError, {
+                        status,
+                        reason,
+                        sourcePath,
+                        destinationPath,
+                        errorMessage: error.message,
+                        dialogId: dialogId.valueOf(),
+                        mainDialogId: mainDialogId.valueOf(),
+                        renameErrorCode: getErrorCode(renameError),
+                    });
+                    return false;
+                }
+                quarantined = true;
+                log_1.log.warn(`Quarantined malformed dialog ${mainDialogId.selfId}`, undefined, {
+                    status,
+                    reason,
+                    sourcePath,
+                    destinationPath,
+                    errorMessage: error.message,
+                    dialogId: dialogId.valueOf(),
+                    mainDialogId: mainDialogId.valueOf(),
+                });
+                dialogsQuarantinedBroadcaster?.({
+                    type: 'dialogs_quarantined',
+                    status: 'quarantining',
+                    fromStatus: assertPersistableDialogStatus(status, 'DialogPersistence.quarantineMalformedDialog(fromStatus)'),
+                    rootId: mainDialogId.selfId,
+                    dialogId: dialogId.selfId,
+                    reason,
+                    timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
                 });
             }
             finally {
-                quarantiningMainDialogs.delete(quarantineKey);
+                try {
+                    if (!quarantined && writeBackCancelScopeKey) {
+                        this.quarantinedMainDialogScopes.delete(writeBackCancelScopeKey);
+                    }
+                    await finalizeDialogQuarantineHook?.({
+                        dialogId,
+                        mainDialogId,
+                        status,
+                        reason,
+                        error,
+                        quarantined,
+                    });
+                }
+                finally {
+                    const active = quarantiningMainDialogs.get(quarantineKey);
+                    if (active === quarantinePromise) {
+                        quarantiningMainDialogs.delete(quarantineKey);
+                    }
+                }
             }
-        }
+            return quarantined;
+        });
+        quarantiningMainDialogs.set(quarantineKey, quarantinePromise);
+        return await quarantinePromise;
     }
     static async quarantineMalformedRuntimeState(dialogId, status, reason, detail) {
-        await this.quarantineMalformedDialog(dialogId, status, reason, new Error(detail));
+        const quarantined = await this.quarantineMalformedDialog(dialogId, status, reason, new Error(detail));
+        if (!quarantined) {
+            throw new Error(`Failed to quarantine malformed runtime state ` +
+                `(rootId=${dialogId.rootId}, selfId=${dialogId.selfId}, status=${status}, reason=${reason}): ` +
+                detail);
+        }
     }
     static async rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, reason, error) {
         const persistenceError = (0, persistence_errors_1.findDomindsPersistenceFileError)(error);
         if (persistenceError) {
-            await this.quarantineMalformedDialog(dialogId, status, reason, persistenceError);
+            try {
+                await this.quarantineMalformedDialog(dialogId, status, reason, persistenceError);
+            }
+            catch (quarantineError) {
+                log_1.log.error('Failed to complete malformed dialog quarantine', quarantineError, {
+                    status,
+                    reason,
+                    dialogId: dialogId.valueOf(),
+                    mainDialogId: dialogId.rootId,
+                    persistenceErrorMessage: persistenceError.message,
+                    quarantineErrorCode: getErrorCode(quarantineError),
+                });
+            }
             throw persistenceError;
         }
         throw error;
@@ -5664,6 +5709,13 @@ class DialogPersistence {
                     }
                 }
                 catch (error) {
+                    if (getErrorCode(error) === 'ENOENT') {
+                        log_1.log.debug(`🔍 listDialogs: Directory disappeared while scanning ${dirPath}`, undefined, {
+                            status,
+                            dirPath,
+                        });
+                        return;
+                    }
                     // Directory enumeration failures are filesystem-level access/I/O problems, not evidence
                     // that a specific dialog record is malformed. If we cannot even read this directory,
                     // attempting to quarantine a child dialog via move/rename is unlikely to be reliable.
@@ -5708,6 +5760,13 @@ class DialogPersistence {
                 entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
             }
             catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    log_1.log.debug(`listMainDialogIds: Directory disappeared while scanning ${dirPath}`, undefined, {
+                        status,
+                        dirPath,
+                    });
+                    return;
+                }
                 log_1.log.warn(`listMainDialogIds: Error reading directory ${dirPath}:`, error);
                 return;
             }
@@ -5868,6 +5927,13 @@ class DialogPersistence {
                 entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
             }
             catch (err) {
+                if (getErrorCode(err) === 'ENOENT') {
+                    log_1.log.debug(`🔍 listAllDialogIds: Directory disappeared while scanning ${dirPath}`, undefined, {
+                        status,
+                        dirPath,
+                    });
+                    return;
+                }
                 // This is an environment/filesystem failure rather than confirmed dialog corruption. We log
                 // loudly and keep enumeration partial instead of fabricating a quarantine target that may
                 // not even be reachable through the same broken directory path.

package/dist/server/dominds-self-update.js

@@ -32,6 +32,8 @@ const PROXY_URL_ENV_KEYS = new Set([
     'npm_config_https_proxy',
 ]);
 const IDLE_RESTART_STATE = { kind: 'idle' };
+const PROCESS_START_ARGV = [...process.argv];
+const PROCESS_START_EXEC_ARGV = [...process.execArgv];
 const PROCESS_START_CWD = process.cwd();
 let runtimeConfig = null;
 let latestObservation = { kind: 'unknown' };
@@ -76,7 +78,7 @@ function compareVersions(a, b) {
 function detectRunKind(mode) {
     if (mode !== 'production')
         return 'disabled';
-    const scriptPath = (process.argv[1] ?? '').replace(/\\/g, '/');
+    const scriptPath = (PROCESS_START_ARGV[1] ?? '').replace(/\\/g, '/');
     if (scriptPath.includes('/_npx/') && scriptPath.includes('/node_modules/dominds/')) {
         return 'npx';
     }
@@ -111,7 +113,7 @@ async function getComparableRealPath(absPath) {
     }
 }
 function getCurrentProcessEntrypoint() {
-    const entrypoint = process.argv[1];
+    const entrypoint = PROCESS_START_ARGV[1];
     if (typeof entrypoint !== 'string' || entrypoint.trim() === '') {
         throw new Error('Cannot restart Dominds because the current process entrypoint is unavailable');
     }
@@ -119,10 +121,10 @@ function getCurrentProcessEntrypoint() {
 }
 function buildCurrentProcessRestartArgs() {
     getCurrentProcessEntrypoint();
-    return [...process.execArgv, ...process.argv.slice(1)];
+    return [...PROCESS_START_EXEC_ARGV, ...PROCESS_START_ARGV.slice(1)];
 }
 function buildCurrentDomindsCliArgs() {
-    return process.argv.slice(2);
+    return PROCESS_START_ARGV.slice(2);
 }
 function getNpxWorkspaceDirAbs() {
     const entrypoint = getCurrentProcessEntrypoint().replace(/\\/g, '/');
@@ -683,7 +685,7 @@ async function queryLatestVersion() {
     }
 }
 async function findRunningDomindsPackageRootAbs() {
-    const scriptPath = process.argv[1];
+    const scriptPath = PROCESS_START_ARGV[1];
     if (typeof scriptPath !== 'string' || scriptPath.trim() === '')
         return null;
     const scriptPathAbs = path_1.default.isAbsolute(scriptPath)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.25.16",
+  "version": "1.25.18",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {

package/webapp/dist/assets/{_basePickBy-bB-pfQPi.js → _basePickBy-DUivPKf7.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-CGrWBZre.js";
-import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-r4An5YoX.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-hcs024vD.js";
+import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-BOO_zFrI.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-bB-pfQPi.js.map
+//# sourceMappingURL=_basePickBy-DUivPKf7.js.map