dsh-expert-group 0.1.5 → 0.1.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.en.md +330 -0
- package/README.md +6 -18
- package/client-bundle.js +2701 -184
- package/client-expert-group-model.js +31 -4
- package/client-expert-group-sidebar.js +2611 -129
- package/client.js +10 -2
- package/host/expert-group-runtime.js +710 -33
- package/host/expert-group-snapshot.js +5 -1
- package/index.js +708 -66
- package/package.json +2 -1
- package/prompt-contracts.js +22 -15
package/client-bundle.js
CHANGED
|
@@ -116,18 +116,36 @@
|
|
|
116
116
|
}
|
|
117
117
|
|
|
118
118
|
/**
|
|
119
|
-
*
|
|
119
|
+
* 轻量(partial)快照下的中性运行状态:既不声明运行,也不声明已结束。
|
|
120
|
+
*
|
|
121
|
+
* 与 ready 的区别:ready 是「有证据表明当前没在运行」(圆点渲染成绿色 done),
|
|
122
|
+
* unknown 是「证据不足」——轻量快照跳过了冷读,此时既不能声明运行也不能声明结束,
|
|
123
|
+
* 圆点与活动文案必须保持中性。它不是协议状态词表的一员,只用于展示层。
|
|
124
|
+
*/
|
|
125
|
+
const UNKNOWN_RUNTIME_STATUS = "unknown";
|
|
126
|
+
|
|
127
|
+
/**
|
|
128
|
+
* 归一化代理运行状态:默认只有 running | ready;轻量快照下多一个中性值 unknown。
|
|
120
129
|
*
|
|
121
130
|
* 只用 activitySignalOf 的活动证据链:明确运行为 running,其余(inactive、缺失、
|
|
122
131
|
* 目录未命中且无其它运行证据)一律 ready。目录 activity 与 Host 旧信号冲突时,
|
|
123
132
|
* 以目录 activity 为准,不把真实 running 降级成 ready。
|
|
124
133
|
*
|
|
134
|
+
* partial 选项(Host 的轻量快照):证据链返回 null(完全没有任何活动证据,既不是
|
|
135
|
+
* running 也不是 inactive)时返回中性值 unknown,让圆点与活动文案保持中性;
|
|
136
|
+
* 只要存在任何证据(目录 activity/status、节点 running 布尔、协议 status)就仍按原规则渲染。
|
|
137
|
+
* 不传 options 时行为与旧实现逐字一致(旧 Host、测试与所有既有调用点不受影响)。
|
|
138
|
+
*
|
|
125
139
|
* @param {object} node - 快照节点(专家/根/fan-out 任务或分片)。
|
|
126
140
|
* @param {object} [entry] - sessions 快照里的官方目录项。
|
|
127
|
-
* @
|
|
141
|
+
* @param {{partial?: boolean}} [options] - 展示层选项;partial 为 true 时才可能出现中性值。
|
|
142
|
+
* @returns {"running"|"ready"|"unknown"}
|
|
128
143
|
*/
|
|
129
|
-
function runtimeStatusOf(node, entry) {
|
|
130
|
-
|
|
144
|
+
function runtimeStatusOf(node, entry, options) {
|
|
145
|
+
const signal = activitySignalOf(node, entry);
|
|
146
|
+
if (signal === "running") return "running";
|
|
147
|
+
if (isObject(options) && options.partial === true && signal === null) return UNKNOWN_RUNTIME_STATUS;
|
|
148
|
+
return "ready";
|
|
131
149
|
}
|
|
132
150
|
|
|
133
151
|
/** 只有精确命中词表的 mode 才能映射文案;未知/非法值返回 null(不猜)。 */
|
|
@@ -304,6 +322,13 @@
|
|
|
304
322
|
return [...expertChildren, ...fanoutChildren];
|
|
305
323
|
}
|
|
306
324
|
|
|
325
|
+
/**
|
|
326
|
+
* 快照归一。
|
|
327
|
+
*
|
|
328
|
+
* partial 是 Host 新增的快照级标记:true = **轻量快照**(Host 跳过了全部冷读,状态可能不完整),
|
|
329
|
+
* false/缺失 = 完整权威快照。客户端只把它当成「状态证据不完整」的信号,渲染规则见
|
|
330
|
+
* runtimeStatusOf 的 partial 选项;缺失时按完整快照处理(旧 Host 行为不变)。
|
|
331
|
+
*/
|
|
307
332
|
function normalizeExpertGroupSnapshot(raw) {
|
|
308
333
|
if (!isObject(raw) || raw.schemaVersion !== SCHEMA_VERSION) return null;
|
|
309
334
|
const sourceRoot = isObject(raw.root) ? raw.root : {};
|
|
@@ -324,6 +349,7 @@
|
|
|
324
349
|
sessionId: rootSessionId,
|
|
325
350
|
rootSessionId,
|
|
326
351
|
generatedAt: numberOrNull(raw.generatedAt),
|
|
352
|
+
partial: raw.partial === true,
|
|
327
353
|
root,
|
|
328
354
|
};
|
|
329
355
|
}
|
|
@@ -420,6 +446,7 @@
|
|
|
420
446
|
global[SYMBOL] = Object.freeze({
|
|
421
447
|
SCHEMA_VERSION,
|
|
422
448
|
RUNTIME_STATUSES,
|
|
449
|
+
UNKNOWN_RUNTIME_STATUS,
|
|
423
450
|
normalizeExpertGroupSnapshot,
|
|
424
451
|
normalizeStatus,
|
|
425
452
|
runtimeStatusOf,
|
|
@@ -438,14 +465,21 @@
|
|
|
438
465
|
const MODEL_SYMBOL = Symbol.for("dsh-expert-group/client-expert-group-model");
|
|
439
466
|
const MODEL = global[MODEL_SYMBOL] || {};
|
|
440
467
|
const modelApi = () => global[MODEL_SYMBOL] || MODEL;
|
|
441
|
-
/**
|
|
442
|
-
|
|
468
|
+
/**
|
|
469
|
+
* 右侧栏对外的代理运行状态:默认是 running | ready 两个规范值。
|
|
470
|
+
*
|
|
471
|
+
* unknown 是**轻量(partial)快照专用**的中性值(见 client-expert-group-model.js 的
|
|
472
|
+
* UNKNOWN_RUNTIME_STATUS):证据不足时不声明运行、也不声明结束。完整快照永远不会产生它,
|
|
473
|
+
* 因此正常渲染、无障碍标签与圆点语义都不受影响。
|
|
474
|
+
*/
|
|
475
|
+
const RUNTIME_STATUS_LABELS = Object.freeze({ running: "running", ready: "ready", unknown: "unknown" });
|
|
443
476
|
/**
|
|
444
477
|
* 规范运行状态到 primitives.StateDot 的语义映射:
|
|
445
|
-
* running 用 ongoing(DSH 原生 1 秒追逐动画),ready 用 done
|
|
478
|
+
* running 用 ongoing(DSH 原生 1 秒追逐动画),ready 用 done(绿色静态圆点),
|
|
479
|
+
* unknown 用 idle——官方词表里唯一「无进展信息」的中性态,既不是进行中也不是已完成。
|
|
446
480
|
* 插件不自造第二套动画,动画只由官方组件提供。
|
|
447
481
|
*/
|
|
448
|
-
const RUNTIME_STATE_DOT = Object.freeze({ running: "ongoing", ready: "done" });
|
|
482
|
+
const RUNTIME_STATE_DOT = Object.freeze({ running: "ongoing", ready: "done", unknown: "idle" });
|
|
449
483
|
// ACTIVE_STATUSES / RETRY_STATUSES 只服务于 fan-out 管理语义(取消/重试判定),不是展示状态词表。
|
|
450
484
|
const ACTIVE_STATUSES = new Set(["queued", "waiting", "running"]);
|
|
451
485
|
const RETRY_STATUSES = new Set(["failed", "timed_out", "interrupted"]);
|
|
@@ -590,6 +624,27 @@
|
|
|
590
624
|
const SIDEBAR_TAB_DISAPPEAR_CONFIRMATIONS = 2;
|
|
591
625
|
/** 打开后等待 active() 提交的最长时间;超时只释放待确认记录,不伪造 << 状态。 */
|
|
592
626
|
const SIDEBAR_TAB_OPEN_CONFIRMATION_TIMEOUT_MS = 15000;
|
|
627
|
+
/**
|
|
628
|
+
* 共享来源账本里「Auto 打开已经发出、tabId 始终没落地」的**占位条目**存活上限。
|
|
629
|
+
*
|
|
630
|
+
* 取值理由:与本地 opening 的等待窗口(SIDEBAR_TAB_OPEN_CONFIRMATION_TIMEOUT_MS,15 秒)对齐——
|
|
631
|
+
* 两者回答的是同一个问题「这次打开还要等多久才算没有落地证据」。窗口内保留占位:它承担「同一个资源
|
|
632
|
+
* 绝不并发第二次 openResource」的去重语义(autoOpenCandidate 的 origin.has(key))。窗口外释放占位,
|
|
633
|
+
* 让「资源仍 running 且地址上确实没有 tab」的形状能有一次有界重试——每次重试至少间隔一个窗口,
|
|
634
|
+
* 绝不自转(同一批微任务内还有 sidebarAutoFailedKeysRef 失败屏障兜底)。
|
|
635
|
+
*
|
|
636
|
+
* 为什么必须有这条 TTL:占位同时占着归属账本的容量槽位(SIDEBAR_AUTO_KEY_LIMIT = 128),而候选
|
|
637
|
+
* 选择又靠 origin.has(key) 跳过重试。宿主始终没落地该 tab 时,一批占位会把账本占满,Auto 从此
|
|
638
|
+
* 再也开不出任何新 tab——纯可用性故障,而且只有整页刷新(清掉内存账本)才能恢复。
|
|
639
|
+
*/
|
|
640
|
+
const SIDEBAR_AUTO_OPEN_PLACEHOLDER_TTL_MS = SIDEBAR_TAB_OPEN_CONFIRMATION_TIMEOUT_MS;
|
|
641
|
+
/**
|
|
642
|
+
* 别的 scope(别的 root / sidebar session)的占位回收阈值:留出 4 倍余量,避免打断另一个 surface
|
|
643
|
+
* 仍在进行中的打开动作;超过它还在的占位一律回收(占位本身不是归属证据,回收不会授权任何关闭,
|
|
644
|
+
* 而且别的 scope 的候选选择必须在发出 openResource 前重新核对它自己的 inventory,因此也不可能
|
|
645
|
+
* 因此开出重复 tab)。
|
|
646
|
+
*/
|
|
647
|
+
const SIDEBAR_AUTO_OPEN_PLACEHOLDER_FOREIGN_TTL_MS = 4 * SIDEBAR_AUTO_OPEN_PLACEHOLDER_TTL_MS;
|
|
593
648
|
/** 首次 split 的跨 inventory/DOM 提交 deadline,避免临时 50% 状态无限期占用右栏。 */
|
|
594
649
|
const SIDEBAR_SPLIT_TRANSACTION_TIMEOUT_MS = 15000;
|
|
595
650
|
/** RAF 被后台节流时的短 fallback;只负责放行一次 split 尝试,不改变事务提交 deadline。 */
|
|
@@ -635,6 +690,62 @@
|
|
|
635
690
|
* 保证长期运行的面板不会无界增长。
|
|
636
691
|
*/
|
|
637
692
|
const SIDEBAR_AUTO_KEY_LIMIT = 128;
|
|
693
|
+
/**
|
|
694
|
+
* 宿主 close() 请求的 watchdog 上限。
|
|
695
|
+
*
|
|
696
|
+
* 宿主 closeIn 在 actions / surface 缺失、tab 不存在或 canCloseTab=false 时会静默 no-op,也可能
|
|
697
|
+
* 返回一个永不 settle 的 Promise。没有上限,Auto 的 busy 闸门与 pending 锁就会被一次宿主调用永久
|
|
698
|
+
* 占住(后续候选再也推进不了)。10 秒 = 四次 2.5 秒轮询:足够正常宿主结算,也足够在真实 UI 上
|
|
699
|
+
* 表现为「这一轮让位、下一轮重试」。
|
|
700
|
+
*/
|
|
701
|
+
const SIDEBAR_TAB_CLOSE_WATCHDOG_MS = 10000;
|
|
702
|
+
/**
|
|
703
|
+
* close 请求 resolve 之后的验证窗口:resolve 只代表请求完成,绝不代表 tab 已经关闭。
|
|
704
|
+
*
|
|
705
|
+
* 验证只认 readSidebarOpenTabs() 的**精确 tabId** 结果,并沿用既有的
|
|
706
|
+
* SIDEBAR_TAB_DISAPPEAR_CONFIRMATIONS = 2 次连续缺失确认(2.5 秒轮询 ⇒ 正常验证窗口约 5 秒)。
|
|
707
|
+
* 10 秒是这条验证链的上限:超时后释放租约、保留 record / origin / attempt,由下一次同步决定重试。
|
|
708
|
+
*/
|
|
709
|
+
const SIDEBAR_TAB_CLOSE_VERIFY_TIMEOUT_MS = 10000;
|
|
710
|
+
/**
|
|
711
|
+
* watchdog 超时后的迟到结果隔离窗。
|
|
712
|
+
*
|
|
713
|
+
* 宿主 Promise 不可取消:超时之后它仍可能迟到 resolve / reject。隔离窗至少跨过一次 2.5 秒
|
|
714
|
+
* inventory 采样,因此这段时间里同一个 tab 绝不再发第二次 close,迟到结果也就没有机会与新的
|
|
715
|
+
* 一次关闭重叠——它只能作用于仍匹配的旧租约(见 requestSidebarTabClose 的收口)。
|
|
716
|
+
*
|
|
717
|
+
* **这个窗口覆盖不到的边界**(必须由别的证据补齐,绝不能被它假装覆盖):
|
|
718
|
+
* 1. 它是**固定长度**,只保证「窗口内不重叠」——宿主可能在窗口释放之后才落地一次不可取消的副作用;
|
|
719
|
+
* 2. 它不知道这个 tabId 此刻承载的是谁——宿主可以把已经释放的 tabId 复用给**另一个资源**。
|
|
720
|
+
* 因此「重试之前必须用地址证据证明这个 tabId 仍然是我们要关的那个资源」是独立于本窗口的硬闸门
|
|
721
|
+
* (见 sidebarTabPresenceInInventory 的 contentId 判据与 closeSidebarTabWithLease 的 preflight):
|
|
722
|
+
* 本窗口只负责把迟到结果的落点钉死在旧租约上,绝不承担「id 没有被复用」这个假设。
|
|
723
|
+
*/
|
|
724
|
+
const SIDEBAR_TAB_CLOSE_LATE_QUARANTINE_MS = 3000;
|
|
725
|
+
/**
|
|
726
|
+
* 自动关闭失败后的冷却慢车道:60 秒起,指数退避 60/120/240/480 秒,上限 15 分钟。
|
|
727
|
+
*
|
|
728
|
+
* 三次快速预算用尽(或「resolve 后 inventory 仍 present」累计三次)后**不再删除 origin**,而是
|
|
729
|
+
* 进入冷却:冷却期内同一个 key 零次 close 请求,origin / record 原样保留,到期后允许一次新的
|
|
730
|
+
* 真实 close(失败则退避到下一档)。
|
|
731
|
+
*/
|
|
732
|
+
const SIDEBAR_AUTO_CLOSE_COOLDOWN_BASE_MS = 60000;
|
|
733
|
+
const SIDEBAR_AUTO_CLOSE_COOLDOWN_MAX_MS = 900000;
|
|
734
|
+
|
|
735
|
+
/**
|
|
736
|
+
* 关闭租约的四种结算原因。
|
|
737
|
+
*
|
|
738
|
+
* 等待者(用户触发的手动单项与批量)绝不能只看一个布尔「成功/失败」:同一个 tabId 上的两次
|
|
739
|
+
* 关闭可能属于**不同的 key**(宿主把已经释放的 id 回收给了另一个资源),而「上一次结算是
|
|
740
|
+
* recycled」对没有地址证据的等待者什么都不能证明。因此结算必须携带原因,等待者用自己的期望
|
|
741
|
+
* 地址重新探针复核之后再决定下一步(见 closeSidebarTabWithLease 的等待分支)。
|
|
742
|
+
* 布尔写法保留兼容:true ⇒ "closed"、false ⇒ "failed"。
|
|
743
|
+
*/
|
|
744
|
+
const SIDEBAR_TAB_CLOSE_SETTLE_REASONS = new Set(["closed", "recycled", "failed", "timeout"]);
|
|
745
|
+
function closeSettleReason(outcome) {
|
|
746
|
+
if (SIDEBAR_TAB_CLOSE_SETTLE_REASONS.has(outcome) === true) return outcome;
|
|
747
|
+
return outcome === true ? "closed" : "failed";
|
|
748
|
+
}
|
|
638
749
|
|
|
639
750
|
function object(value) {
|
|
640
751
|
return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
|
|
@@ -868,6 +979,18 @@
|
|
|
868
979
|
+ String(rootSessionId) + SIDEBAR_TAB_KEY_SEPARATOR + String(resourceAddress);
|
|
869
980
|
}
|
|
870
981
|
|
|
982
|
+
/**
|
|
983
|
+
* 「同一个 tab 的关闭在途」锁的复合键:sessionId + rootSessionId + 宿主 tabId。
|
|
984
|
+
*
|
|
985
|
+
* 与 sidebarTabKey(按资源地址记账)刻意不同:同一个资源地址在别的 session / 别的 root 里对应的是
|
|
986
|
+
* 另一个右栏 tab,只有 tabId 才能证明「宿主正在处理同一个 tab」。关闭的副作用作用在 tabId 上,
|
|
987
|
+
* 因此重复关闭的判据也只能是 tabId。
|
|
988
|
+
*/
|
|
989
|
+
function sidebarTabCloseKey(sessionId, rootSessionId, tabId) {
|
|
990
|
+
return String(sessionId) + SIDEBAR_TAB_KEY_SEPARATOR
|
|
991
|
+
+ String(rootSessionId) + SIDEBAR_TAB_KEY_SEPARATOR + String(tabId);
|
|
992
|
+
}
|
|
993
|
+
|
|
871
994
|
function sessionEntries(value) {
|
|
872
995
|
if (value == null) return [];
|
|
873
996
|
if (Array.isArray(value)) {
|
|
@@ -1042,9 +1165,11 @@
|
|
|
1042
1165
|
* 规范运行状态(展示与图标唯一使用的状态)。
|
|
1043
1166
|
* 模型可用时由模型按官方源字段归一,模型缺失时才退回可证明的 running 布尔。
|
|
1044
1167
|
*/
|
|
1045
|
-
function runtimeStatusOf(node, entry) {
|
|
1168
|
+
function runtimeStatusOf(node, entry, options) {
|
|
1046
1169
|
const model = modelApi();
|
|
1047
|
-
if (typeof model.runtimeStatusOf === "function") return model.runtimeStatusOf(node, entry);
|
|
1170
|
+
if (typeof model.runtimeStatusOf === "function") return model.runtimeStatusOf(node, entry, options);
|
|
1171
|
+
// 模型缺失的降级路径:没有证据链可判,轻量快照下一律中性。
|
|
1172
|
+
if (options?.partial === true && object(node).running !== true) return "unknown";
|
|
1048
1173
|
return object(node).running === true ? "running" : "ready";
|
|
1049
1174
|
}
|
|
1050
1175
|
|
|
@@ -1312,6 +1437,9 @@
|
|
|
1312
1437
|
return left.schemaVersion === right.schemaVersion
|
|
1313
1438
|
&& left.sessionId === right.sessionId
|
|
1314
1439
|
&& left.rootSessionId === right.rootSessionId
|
|
1440
|
+
// partial 必须参与比较:任务树内容恰好一致时(轻量快照与完整快照投影结果相同),
|
|
1441
|
+
// 从 partial→完整 的升级仍要上屏,否则中性渲染会一直留在界面上。
|
|
1442
|
+
&& (left.partial === true) === (right.partial === true)
|
|
1315
1443
|
&& snapshotContentEquals(left.root, right.root);
|
|
1316
1444
|
}
|
|
1317
1445
|
|
|
@@ -1455,6 +1583,8 @@
|
|
|
1455
1583
|
".deg_expert_group_state_dot{display:inline-block;width:6px;height:6px;border-radius:50%;background:currentColor}",
|
|
1456
1584
|
".deg_expert_group_state_dot[data-state=running]{color:var(--dsw-static-deepseek-450,var(--dsw-alias-state-business-primary))}",
|
|
1457
1585
|
".deg_expert_group_state_dot[data-state=ready]{color:var(--dsw-alias-state-success-primary)}",
|
|
1586
|
+
// 轻量(partial)快照的中性圆点:用次要文字色,既不是「运行中」蓝也不是「已完成」绿。
|
|
1587
|
+
".deg_expert_group_state_dot[data-state=unknown]{color:var(--dsw-alias-label-tertiary,var(--dsw-alias-label-secondary))}",
|
|
1458
1588
|
// 固定 30px 批量控件紧跟标题文字;不占独立 grid 尾列,也不使用自动外边距推向行尾。
|
|
1459
1589
|
// 标题自身 min-width:0 + 单行省略,窄宽度下只收缩文字,箭头与批量控件保持固定占位。
|
|
1460
1590
|
".deg_expert_group_trailing{display:flex;flex:0 0 30px;align-items:center;justify-content:center;width:30px;height:20px;min-width:30px}",
|
|
@@ -2493,6 +2623,511 @@
|
|
|
2493
2623
|
};
|
|
2494
2624
|
}
|
|
2495
2625
|
|
|
2626
|
+
/* ----------------------------------------------------------------------------------------------- *
|
|
2627
|
+
* realm 级共享 Auto 账本(跨 bundle 重新执行/HMR)、持久归属标记(跨整页刷新)与有界诊断
|
|
2628
|
+
* ----------------------------------------------------------------------------------------------- */
|
|
2629
|
+
|
|
2630
|
+
/**
|
|
2631
|
+
* 本 realm 的共享 Auto 账本槽位。
|
|
2632
|
+
*
|
|
2633
|
+
* 症状与根因(现场证据):DSH 的 ClientModuleSystem 支持 HMR,插件客户端模块被失效后会在**同一个
|
|
2634
|
+
* realm 重新执行整份 bundle**(见 client-freshness.js 的 REGISTERED_LOADERS_KEY 说明)。这些账本
|
|
2635
|
+
* 原先建在 createExpertGroupPanel 的工厂闭包里,bundle 重新执行即全部归零:一个正在运行的子代理
|
|
2636
|
+
* 期间跑过构建(HMR)之后,它那个已经打开的 tab 在下一次收养时只能落到 manual 兜底——Auto 从此
|
|
2637
|
+
* 再也不会把它收回去(用户看到的正是「只有能跑构建的角色更容易残留」)。
|
|
2638
|
+
*
|
|
2639
|
+
* 因此账本必须挂在 realm 的 globalThis 上(与 client-freshness 同一手法、同一条注释风格):
|
|
2640
|
+
* 首次执行创建,之后每次 bundle 重新执行都复用同一批 Map。整页刷新或进程重启后 realm 是新的,
|
|
2641
|
+
* 账本自然为空——那条安全取舍由**持久归属标记**(见 SIDEBAR_AUTO_OWNERSHIP_KEY)承担。
|
|
2642
|
+
*
|
|
2643
|
+
* globalThis 不可用 / 被冻结 / 写入被拒时退回「每次执行各自 new Map」的旧行为,绝不抛错(同
|
|
2644
|
+
* client-freshness 的降级策略)。
|
|
2645
|
+
*/
|
|
2646
|
+
const SIDEBAR_SHARED_AUTO_LEDGER_KEY = Symbol.for("dsh-expert-group/sidebar#shared-auto-ledger");
|
|
2647
|
+
const SIDEBAR_SHARED_AUTO_LEDGER_VERSION = 1;
|
|
2648
|
+
/** 持久归属标记的版本化键(与 dsh-expert-group:rightbar-presented:v1 同命名风格)。 */
|
|
2649
|
+
const SIDEBAR_AUTO_OWNERSHIP_KEY = "dsh-expert-group:auto-ownership:v1";
|
|
2650
|
+
const SIDEBAR_AUTO_OWNERSHIP_LIMIT = 128;
|
|
2651
|
+
const SIDEBAR_AUTO_OWNERSHIP_TTL_MS = 7 * 24 * 60 * 60 * 1000;
|
|
2652
|
+
const SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO = "auto";
|
|
2653
|
+
const SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL = "manual";
|
|
2654
|
+
/** 归属标记的内存索引槽位(与 localStorage 同源 write-through;测试可重置)。 */
|
|
2655
|
+
const SIDEBAR_AUTO_OWNERSHIP_MEMORY_KEY = Symbol.for("dsh-expert-group/sidebar#auto-ownership-memory");
|
|
2656
|
+
/** 有界诊断环形缓冲:只记结论摘要,绝不记提示词 / 消息正文 / 令牌 / 凭据。 */
|
|
2657
|
+
const SIDEBAR_AUTO_DIAG_KEY = "dsh-expert-group:auto-diag:v1";
|
|
2658
|
+
const SIDEBAR_AUTO_DIAG_LIMIT = 60;
|
|
2659
|
+
const SIDEBAR_AUTO_DIAG_ENTRY_MAX_CHARS = 360;
|
|
2660
|
+
const SIDEBAR_AUTO_DIAG_TEXT_MAX_CHARS = 96;
|
|
2661
|
+
/** 账本里八份 Map 的字段名(顺序即诊断里的 sizes 顺序)。 */
|
|
2662
|
+
const SIDEBAR_SHARED_AUTO_LEDGER_FIELDS = [
|
|
2663
|
+
"origin", "suppressed", "closeAttempts", "closeAttemptOwners",
|
|
2664
|
+
"closeVerifications", "closeCooldowns", "tabMisses", "tabCloseInFlight",
|
|
2665
|
+
];
|
|
2666
|
+
|
|
2667
|
+
/** 安全取 realm 的 globalThis:不可用时给 null,调用方一律走降级分支。 */
|
|
2668
|
+
const sidebarRealmHost = () => {
|
|
2669
|
+
try {
|
|
2670
|
+
return typeof globalThis === "object" && globalThis !== null ? globalThis : null;
|
|
2671
|
+
} catch {
|
|
2672
|
+
return null;
|
|
2673
|
+
}
|
|
2674
|
+
};
|
|
2675
|
+
|
|
2676
|
+
/** 安全读 localStorage:缺失 / 被拒 / 抛错一律返回 null(调用方静默降级)。 */
|
|
2677
|
+
const sidebarLocalStorage = () => {
|
|
2678
|
+
try {
|
|
2679
|
+
const host = sidebarRealmHost();
|
|
2680
|
+
const storage = host === null ? null : host.localStorage;
|
|
2681
|
+
if (storage === null || storage === undefined) return null;
|
|
2682
|
+
if (typeof storage.getItem !== "function" || typeof storage.setItem !== "function") return null;
|
|
2683
|
+
return storage;
|
|
2684
|
+
} catch {
|
|
2685
|
+
return null;
|
|
2686
|
+
}
|
|
2687
|
+
};
|
|
2688
|
+
|
|
2689
|
+
/** 有界文本字段:非字符串按字符串化处理并截断,空值返回 undefined(不写这个字段)。 */
|
|
2690
|
+
const sidebarBoundedText = (value) => {
|
|
2691
|
+
if (value === null || value === undefined) return undefined;
|
|
2692
|
+
const text = typeof value === "string" ? value : String(value);
|
|
2693
|
+
if (text.length === 0) return undefined;
|
|
2694
|
+
return text.length > SIDEBAR_AUTO_DIAG_TEXT_MAX_CHARS ? text.slice(0, SIDEBAR_AUTO_DIAG_TEXT_MAX_CHARS) : text;
|
|
2695
|
+
};
|
|
2696
|
+
|
|
2697
|
+
/** 复合键摘要:只落 hash,绝不落 session / root / 地址原文。 */
|
|
2698
|
+
const sidebarAutoKeyDigest = (key) => {
|
|
2699
|
+
const source = typeof key === "string" ? key : String(key);
|
|
2700
|
+
let hash = 0x811c9dc5;
|
|
2701
|
+
for (let index = 0; index < source.length; index += 1) {
|
|
2702
|
+
hash ^= source.charCodeAt(index);
|
|
2703
|
+
hash = Math.imul(hash, 0x01000193) >>> 0;
|
|
2704
|
+
}
|
|
2705
|
+
return "k" + hash.toString(36);
|
|
2706
|
+
};
|
|
2707
|
+
|
|
2708
|
+
const sidebarAutoScopedKey = (sessionId, rootId, address) => String(sessionId) + "|" + String(rootId) + "|" + String(address);
|
|
2709
|
+
|
|
2710
|
+
/**
|
|
2711
|
+
* realm 共享 Auto 来源账本(sharedAutoLedger.origin)条目的唯一构造函数。
|
|
2712
|
+
*
|
|
2713
|
+
* 条目形状:{ sessionId, rootSessionId, address, tabId }。**tabId 是这条账本的全部证明力所在**:
|
|
2714
|
+
* 它必须是「写入这一刻,插件亲眼在宿主 inventory 里读到的那个 tab」。
|
|
2715
|
+
*
|
|
2716
|
+
* - 非 null:这条条目证明「这个 tab 是 Auto 亲手打开/替换并落地的那一个」。任何据此认定 auto 的
|
|
2717
|
+
* 位置都必须要求 entry.tabId 与当前观察到的 tabId **逐字相等**;只要求「有条目」是不够的
|
|
2718
|
+
* (缺陷 1:旧 tab 被用户/宿主移除而插件未观察到时,同 realm 的收养会把用户新开的同地址 tab
|
|
2719
|
+
* 当成 Auto 的旧 tab 认领,资源一空闲就把它关掉)。
|
|
2720
|
+
* - null:只表示「本次运行已经为这个资源发出过一次 Auto 打开、落地证据还没到」这条**去重记账**,
|
|
2721
|
+
* 它**不是**归属证据——任何收养 / 关闭判据都不许把它当作 auto。
|
|
2722
|
+
*
|
|
2723
|
+
* 只有插件亲眼观察到的那次 Auto 打开/替换落地(recordSidebarTab 从宿主 inventory 读到 tabId 的
|
|
2724
|
+
* 那一刻)才允许写入或刷新 tabId。宿主合法重 mint 新 id 而插件没有观察到时,这条绑定随之失配,
|
|
2725
|
+
* 收养一律退化成 manual——宁可漏收一次(tab 留在右栏交给用户手动处理),也绝不误关一个可能是
|
|
2726
|
+
* 用户自己刚打开的 tab。
|
|
2727
|
+
*/
|
|
2728
|
+
const sidebarAutoOriginEntry = (sessionId, rootId, address, tabId) => ({
|
|
2729
|
+
sessionId,
|
|
2730
|
+
rootSessionId: rootId,
|
|
2731
|
+
address,
|
|
2732
|
+
tabId: typeof tabId === "string" && tabId.length > 0 ? tabId : null,
|
|
2733
|
+
/**
|
|
2734
|
+
* 写入时刻:**只有占位**(tabId === null,「打开已发出、落地证据还没到」)用它判 TTL,
|
|
2735
|
+
* 见 SIDEBAR_AUTO_OPEN_PLACEHOLDER_TTL_MS 与 sweepAutoOpenPlaceholders。
|
|
2736
|
+
* 落地条目(tabId 非 null)不使用它:那条生命周期由既有收口路径负责(verified-closed /
|
|
2737
|
+
* inventory-absent / tab-recycled / resource-running),比 TTL 精确得多,绝不能被 TTL 顺手回收。
|
|
2738
|
+
*/
|
|
2739
|
+
writtenAt: Date.now(),
|
|
2740
|
+
});
|
|
2741
|
+
|
|
2742
|
+
/** 读一条来源账本条目绑定的 tabId:缺失 / 畸形一律 null(调用方必须按「不是我们的 tab」处理)。 */
|
|
2743
|
+
const sidebarAutoOriginTabIdOf = (entry) => {
|
|
2744
|
+
if (entry === null || entry === undefined || typeof entry !== "object") return null;
|
|
2745
|
+
return typeof entry.tabId === "string" && entry.tabId.length > 0 ? entry.tabId : null;
|
|
2746
|
+
};
|
|
2747
|
+
|
|
2748
|
+
/** 读一条来源账本条目的写入时刻:缺失 / 畸形一律 0(按「最旧」处理,优先回收)。 */
|
|
2749
|
+
const sidebarAutoOriginWrittenAtOf = (entry) => {
|
|
2750
|
+
if (entry === null || entry === undefined || typeof entry !== "object") return 0;
|
|
2751
|
+
const value = Number(entry.writtenAt);
|
|
2752
|
+
return Number.isFinite(value) ? value : 0;
|
|
2753
|
+
};
|
|
2754
|
+
|
|
2755
|
+
/**
|
|
2756
|
+
* 写一条诊断(环形、有界、失败静默)。
|
|
2757
|
+
*
|
|
2758
|
+
* 结构:{ t, kind, event?, action?, verdict?, reason?, key?, origin?, reused?, degraded?, sizes? },
|
|
2759
|
+
* key 一律是摘要(sidebarAutoKeyDigest),绝不含原文;单条 JSON 超过硬上限时先丢 sizes 再整体丢弃。
|
|
2760
|
+
*/
|
|
2761
|
+
const recordSidebarAutoDiag = (entry) => {
|
|
2762
|
+
try {
|
|
2763
|
+
const storage = sidebarLocalStorage();
|
|
2764
|
+
if (storage === null) return;
|
|
2765
|
+
const source = entry !== null && typeof entry === "object" ? entry : {};
|
|
2766
|
+
const normalized = { t: Date.now() };
|
|
2767
|
+
for (const field of ["kind", "event", "action", "verdict", "reason", "key", "origin"]) {
|
|
2768
|
+
const value = sidebarBoundedText(source[field]);
|
|
2769
|
+
if (value !== undefined) normalized[field] = value;
|
|
2770
|
+
}
|
|
2771
|
+
if (source.reused === true) normalized.reused = true;
|
|
2772
|
+
if (source.degraded === true) normalized.degraded = true;
|
|
2773
|
+
if (source.sizes !== null && typeof source.sizes === "object") {
|
|
2774
|
+
const sizes = {};
|
|
2775
|
+
for (const name of SIDEBAR_SHARED_AUTO_LEDGER_FIELDS) {
|
|
2776
|
+
const value = Number(source.sizes[name]);
|
|
2777
|
+
if (Number.isFinite(value) === true) sizes[name] = Math.max(0, Math.trunc(value));
|
|
2778
|
+
}
|
|
2779
|
+
normalized.sizes = sizes;
|
|
2780
|
+
}
|
|
2781
|
+
let serialized = JSON.stringify(normalized);
|
|
2782
|
+
if (serialized.length > SIDEBAR_AUTO_DIAG_ENTRY_MAX_CHARS) {
|
|
2783
|
+
delete normalized.sizes;
|
|
2784
|
+
serialized = JSON.stringify(normalized);
|
|
2785
|
+
}
|
|
2786
|
+
if (serialized.length > SIDEBAR_AUTO_DIAG_ENTRY_MAX_CHARS) return;
|
|
2787
|
+
let list = [];
|
|
2788
|
+
const raw = storage.getItem(SIDEBAR_AUTO_DIAG_KEY);
|
|
2789
|
+
if (typeof raw === "string" && raw.length > 0) {
|
|
2790
|
+
const parsed = JSON.parse(raw);
|
|
2791
|
+
if (Array.isArray(parsed) === true) list = parsed.slice(-SIDEBAR_AUTO_DIAG_LIMIT);
|
|
2792
|
+
}
|
|
2793
|
+
list.push(JSON.parse(serialized));
|
|
2794
|
+
storage.setItem(SIDEBAR_AUTO_DIAG_KEY, JSON.stringify(list.slice(-SIDEBAR_AUTO_DIAG_LIMIT)));
|
|
2795
|
+
} catch {
|
|
2796
|
+
/* 诊断只服务排查:任何失败都静默,绝不阻断功能。 */
|
|
2797
|
+
}
|
|
2798
|
+
};
|
|
2799
|
+
|
|
2800
|
+
/** 新建一份共享 Auto 账本(八份 Map + 必要元数据)。 */
|
|
2801
|
+
const createSidebarSharedAutoLedger = () => {
|
|
2802
|
+
const ledger = { version: SIDEBAR_SHARED_AUTO_LEDGER_VERSION, createdAt: Date.now() };
|
|
2803
|
+
for (const field of SIDEBAR_SHARED_AUTO_LEDGER_FIELDS) ledger[field] = new Map();
|
|
2804
|
+
return ledger;
|
|
2805
|
+
};
|
|
2806
|
+
|
|
2807
|
+
/**
|
|
2808
|
+
* 鸭子类型校验:只认「版本一致 + 八份 Map 都在」的账本,避免跨 realm / 旧格式的脏值被复用。
|
|
2809
|
+
* 不用 instanceof:测试替身与 vm realm 里的 Map 不共享构造函数。
|
|
2810
|
+
*/
|
|
2811
|
+
const isSidebarSharedAutoLedger = (value) => {
|
|
2812
|
+
if (value === null || typeof value !== "object") return false;
|
|
2813
|
+
if (value.version !== SIDEBAR_SHARED_AUTO_LEDGER_VERSION) return false;
|
|
2814
|
+
for (const field of SIDEBAR_SHARED_AUTO_LEDGER_FIELDS) {
|
|
2815
|
+
const map = value[field];
|
|
2816
|
+
if (map === null || typeof map !== "object" || typeof map.get !== "function" || typeof map.set !== "function") return false;
|
|
2817
|
+
}
|
|
2818
|
+
return true;
|
|
2819
|
+
};
|
|
2820
|
+
|
|
2821
|
+
/** 各 Map 规模的只读快照(诊断用;缺失字段按 0 计)。 */
|
|
2822
|
+
const sidebarSharedAutoLedgerSizes = (ledger) => {
|
|
2823
|
+
const sizes = {};
|
|
2824
|
+
for (const field of SIDEBAR_SHARED_AUTO_LEDGER_FIELDS) {
|
|
2825
|
+
const map = ledger === null || ledger === undefined ? null : ledger[field];
|
|
2826
|
+
sizes[field] = map !== null && typeof map === "object" && Number.isFinite(Number(map.size)) ? Number(map.size) : 0;
|
|
2827
|
+
}
|
|
2828
|
+
return sizes;
|
|
2829
|
+
};
|
|
2830
|
+
|
|
2831
|
+
const sidebarSharedAutoLedgerTotal = (ledger) => {
|
|
2832
|
+
const sizes = sidebarSharedAutoLedgerSizes(ledger);
|
|
2833
|
+
let total = 0;
|
|
2834
|
+
for (const field of SIDEBAR_SHARED_AUTO_LEDGER_FIELDS) total += sizes[field];
|
|
2835
|
+
return total;
|
|
2836
|
+
};
|
|
2837
|
+
|
|
2838
|
+
/**
|
|
2839
|
+
* 取本 realm 的共享 Auto 账本:命中即复用(reused=true),否则新建并写回 realm 槽位。
|
|
2840
|
+
*
|
|
2841
|
+
* 写回失败(globalThis 被冻结 / 受限)时只返回这一份新账本,绝不抛错:行为退回「每次执行各自
|
|
2842
|
+
* new Map」的旧语义,功能可用性不受影响。
|
|
2843
|
+
*/
|
|
2844
|
+
const resolveSidebarSharedAutoLedger = () => {
|
|
2845
|
+
const host = sidebarRealmHost();
|
|
2846
|
+
let existing = null;
|
|
2847
|
+
if (host !== null) {
|
|
2848
|
+
try { existing = host[SIDEBAR_SHARED_AUTO_LEDGER_KEY]; } catch { existing = null; }
|
|
2849
|
+
}
|
|
2850
|
+
if (isSidebarSharedAutoLedger(existing) === true) {
|
|
2851
|
+
return { ledger: existing, reused: true, degraded: false };
|
|
2852
|
+
}
|
|
2853
|
+
const created = createSidebarSharedAutoLedger();
|
|
2854
|
+
let degraded = host === null;
|
|
2855
|
+
if (host !== null) {
|
|
2856
|
+
try {
|
|
2857
|
+
Object.defineProperty(host, SIDEBAR_SHARED_AUTO_LEDGER_KEY, { value: created, configurable: true, writable: true });
|
|
2858
|
+
} catch {
|
|
2859
|
+
degraded = true;
|
|
2860
|
+
}
|
|
2861
|
+
}
|
|
2862
|
+
return { ledger: created, reused: false, degraded };
|
|
2863
|
+
};
|
|
2864
|
+
|
|
2865
|
+
/**
|
|
2866
|
+
* 归属标记的内存索引(懒加载 + write-through):命中 realm 槽位即复用,否则新建并写回。
|
|
2867
|
+
* 槽位不可用时返回 null——此时所有读写直接走 localStorage(仍然正确,只是每次都要解析)。
|
|
2868
|
+
*/
|
|
2869
|
+
const sidebarOwnershipMemory = () => {
|
|
2870
|
+
const host = sidebarRealmHost();
|
|
2871
|
+
if (host === null) return null;
|
|
2872
|
+
try {
|
|
2873
|
+
const existing = host[SIDEBAR_AUTO_OWNERSHIP_MEMORY_KEY];
|
|
2874
|
+
if (existing !== null && typeof existing === "object" && existing.entries instanceof Map) return existing;
|
|
2875
|
+
} catch { return null; }
|
|
2876
|
+
try {
|
|
2877
|
+
const created = { entries: new Map(), loaded: false };
|
|
2878
|
+
Object.defineProperty(host, SIDEBAR_AUTO_OWNERSHIP_MEMORY_KEY, { value: created, configurable: true, writable: true });
|
|
2879
|
+
return created;
|
|
2880
|
+
} catch {
|
|
2881
|
+
return null;
|
|
2882
|
+
}
|
|
2883
|
+
};
|
|
2884
|
+
|
|
2885
|
+
/**
|
|
2886
|
+
* 把持久条目数组整理成 Map:只做两件「数据卫生」的事——丢掉 TTL 过期条目、同一 key 去重
|
|
2887
|
+
* (manual 优先)。
|
|
2888
|
+
*
|
|
2889
|
+
* **这里刻意不做任何按上限的 LRU 淘汰**(缺陷 2):条目描述的 owner 在载入这一刻完全可能仍然
|
|
2890
|
+
* 有效(宿主里那个 tab 还开着,只是插件这一帧还没有 inventory 证据),LRU 淘汰它们等于永久丢掉
|
|
2891
|
+
* 一批仍然打开的 Auto owner——它们再也不会被自动收回,刷新也不能恢复。容量改由**写入路径**
|
|
2892
|
+
* 分账 fail-closed 控制:新增 auto 条目在满额时被拒绝,manual 条目照常写入(见
|
|
2893
|
+
* writeSidebarAutoOwnership / sidebarOwnershipAcceptsNewAuto)。
|
|
2894
|
+
*/
|
|
2895
|
+
const normalizeSidebarOwnershipEntries = (raw, now) => {
|
|
2896
|
+
const entries = new Map();
|
|
2897
|
+
if (Array.isArray(raw) !== true) return entries;
|
|
2898
|
+
for (const item of raw) {
|
|
2899
|
+
if (item === null || typeof item !== "object") continue;
|
|
2900
|
+
const key = typeof item.key === "string" ? item.key : null;
|
|
2901
|
+
if (key === null) continue;
|
|
2902
|
+
const updatedAt = Number(item.updatedAt);
|
|
2903
|
+
if (Number.isFinite(updatedAt) !== true || now - updatedAt > SIDEBAR_AUTO_OWNERSHIP_TTL_MS) continue;
|
|
2904
|
+
const origin = item.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL
|
|
2905
|
+
? SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL
|
|
2906
|
+
: SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO;
|
|
2907
|
+
const previous = entries.get(key);
|
|
2908
|
+
if (previous !== undefined && previous.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL) continue;
|
|
2909
|
+
/**
|
|
2910
|
+
* tabId 是「写下这条归属的那一刻,宿主 inventory 里这个地址的 tab id」(缺省表示这次写入没有
|
|
2911
|
+
* 可证明的 tab)。只有 **auto** 条目在收养时会按它比对(见 recordSidebarTab 的 tabId 绑定闸门):
|
|
2912
|
+
* 宿主重新 mint 了新 id 就说明这条条目描述的那个 tab 已经不存在,此时宁可退化成 manual
|
|
2913
|
+
* (漏收一次、留给用户手动处理),也绝不让 Auto 去关一个可能是用户自己刚打开的 tab。
|
|
2914
|
+
*/
|
|
2915
|
+
entries.delete(key);
|
|
2916
|
+
entries.set(key, {
|
|
2917
|
+
key,
|
|
2918
|
+
origin,
|
|
2919
|
+
updatedAt,
|
|
2920
|
+
reason: sidebarBoundedText(item.reason),
|
|
2921
|
+
tabId: sidebarBoundedText(item.tabId),
|
|
2922
|
+
});
|
|
2923
|
+
}
|
|
2924
|
+
return entries;
|
|
2925
|
+
};
|
|
2926
|
+
|
|
2927
|
+
/** 读取(必要时从 localStorage 懒加载)归属索引;两处都不可用时返回空的临时索引。 */
|
|
2928
|
+
const sidebarOwnershipEntries = () => {
|
|
2929
|
+
const memory = sidebarOwnershipMemory();
|
|
2930
|
+
if (memory === null) {
|
|
2931
|
+
const storage = sidebarLocalStorage();
|
|
2932
|
+
if (storage === null) return new Map();
|
|
2933
|
+
try {
|
|
2934
|
+
const raw = storage.getItem(SIDEBAR_AUTO_OWNERSHIP_KEY);
|
|
2935
|
+
return normalizeSidebarOwnershipEntries(raw === null || raw.length === 0 ? [] : JSON.parse(raw), Date.now());
|
|
2936
|
+
} catch {
|
|
2937
|
+
return new Map();
|
|
2938
|
+
}
|
|
2939
|
+
}
|
|
2940
|
+
if (memory.loaded !== true) {
|
|
2941
|
+
memory.loaded = true;
|
|
2942
|
+
const storage = sidebarLocalStorage();
|
|
2943
|
+
if (storage !== null) {
|
|
2944
|
+
try {
|
|
2945
|
+
const raw = storage.getItem(SIDEBAR_AUTO_OWNERSHIP_KEY);
|
|
2946
|
+
memory.entries = normalizeSidebarOwnershipEntries(raw === null || raw.length === 0 ? [] : JSON.parse(raw), Date.now());
|
|
2947
|
+
} catch {
|
|
2948
|
+
memory.entries = new Map();
|
|
2949
|
+
}
|
|
2950
|
+
}
|
|
2951
|
+
}
|
|
2952
|
+
return memory.entries;
|
|
2953
|
+
};
|
|
2954
|
+
|
|
2955
|
+
/** 把索引写回 localStorage(失败 / 不可用一律静默:内存仍然一致,只是不持久)。 */
|
|
2956
|
+
const persistSidebarOwnership = (entries) => {
|
|
2957
|
+
const storage = sidebarLocalStorage();
|
|
2958
|
+
if (storage === null) return false;
|
|
2959
|
+
try {
|
|
2960
|
+
const list = [];
|
|
2961
|
+
for (const entry of entries.values()) {
|
|
2962
|
+
const item = { key: entry.key, origin: entry.origin, updatedAt: entry.updatedAt };
|
|
2963
|
+
if (entry.reason !== undefined) item.reason = entry.reason;
|
|
2964
|
+
// tabId 必须随条目一起持久化:整页刷新之后它是唯一能证明「这条 auto 归属描述的是哪个 tab」的证据。
|
|
2965
|
+
if (entry.tabId !== undefined) item.tabId = entry.tabId;
|
|
2966
|
+
list.push(item);
|
|
2967
|
+
}
|
|
2968
|
+
storage.setItem(SIDEBAR_AUTO_OWNERSHIP_KEY, JSON.stringify(list));
|
|
2969
|
+
return true;
|
|
2970
|
+
} catch {
|
|
2971
|
+
return false;
|
|
2972
|
+
}
|
|
2973
|
+
};
|
|
2974
|
+
|
|
2975
|
+
/**
|
|
2976
|
+
* 读一个地址的持久归属:返回 { origin, tabId },没有标记时返回 null。
|
|
2977
|
+
*
|
|
2978
|
+
* - origin 命中 manual 一律 manual(安全侧),命中 auto 才 auto;
|
|
2979
|
+
* - tabId 是写入那一刻宿主 inventory 里这个地址的 tab id(没有可证明的 tab 时为 null);
|
|
2980
|
+
* 只有 auto 条目会被调用方按它比对,manual 条目只按 origin 判定。
|
|
2981
|
+
*
|
|
2982
|
+
* 读取本身绝不修改任何状态,失败一律当作「没有标记」(调用方按 manual 兜底)。
|
|
2983
|
+
* options.quiet === true 时连诊断也不写:调用点可能是每轮同步都会跑的判据(自动打开候选、
|
|
2984
|
+
* 空闲资源的抑制清除扫描),它们的结论由各自的决策 / 删除诊断承担,不该把有界诊断环挤满。
|
|
2985
|
+
*/
|
|
2986
|
+
const readSidebarAutoOwnershipEntry = (sessionId, rootId, address, options) => {
|
|
2987
|
+
try {
|
|
2988
|
+
const key = sidebarAutoScopedKey(sessionId, rootId, address);
|
|
2989
|
+
const entry = sidebarOwnershipEntries().get(key);
|
|
2990
|
+
const origin = entry === undefined
|
|
2991
|
+
? null
|
|
2992
|
+
: (entry.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL ? SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL : SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO);
|
|
2993
|
+
if (options === null || options === undefined || options.quiet !== true) {
|
|
2994
|
+
recordSidebarAutoDiag({ kind: "ownership", event: "hit", origin, key: sidebarAutoKeyDigest(key) });
|
|
2995
|
+
}
|
|
2996
|
+
if (entry === undefined) return null;
|
|
2997
|
+
return {
|
|
2998
|
+
origin,
|
|
2999
|
+
tabId: typeof entry.tabId === "string" && entry.tabId.length > 0 ? entry.tabId : null,
|
|
3000
|
+
};
|
|
3001
|
+
} catch {
|
|
3002
|
+
return null;
|
|
3003
|
+
}
|
|
3004
|
+
};
|
|
3005
|
+
|
|
3006
|
+
/** 持久表里的 auto 条目数(容量只对 auto 计账:manual 是用户意图,恒优先、从不被容量拒绝)。 */
|
|
3007
|
+
const sidebarOwnershipAutoCount = (entries) => {
|
|
3008
|
+
let count = 0;
|
|
3009
|
+
for (const entry of entries.values()) {
|
|
3010
|
+
if (entry.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO) count += 1;
|
|
3011
|
+
}
|
|
3012
|
+
return count;
|
|
3013
|
+
};
|
|
3014
|
+
|
|
3015
|
+
/**
|
|
3016
|
+
* 持久表是否还容得下这个地址的一条 **auto** 归属(fail-closed 容量判据,缺陷 2)。
|
|
3017
|
+
*
|
|
3018
|
+
* 判据只有一条:写入之后 auto 条目数不得超过 SIDEBAR_AUTO_OWNERSHIP_LIMIT。**绝不为了腾位而
|
|
3019
|
+
* 淘汰任何已有条目**——持久表里的 auto 条目描述的 owner 在本帧完全可能仍然有效(宿主里那个 tab
|
|
3020
|
+
* 还开着),LRU(或任何「看起来更旧」的排序)淘汰它同样会让那个 tab 永久失去 Auto 归属,刷新
|
|
3021
|
+
* 也不能恢复。
|
|
3022
|
+
*
|
|
3023
|
+
* manual 条目不参与这里的容量判定:它表达用户意图,写入 / 改写一律照常(手动恒优先)。因此本
|
|
3024
|
+
* 函数回答的是「新增/改写一条 auto 条目能不能被保留」,而不是「表里总共有多少条」。
|
|
3025
|
+
*
|
|
3026
|
+
* 读取失败(localStorage 不可用 / 抛错)按「容得下」处理:内存账本仍然守着同一份容量,持久层
|
|
3027
|
+
* 只是「刷新之后的记忆」,读不到它不该让自动打开整体失效(与既有的静默降级一致)。
|
|
3028
|
+
*/
|
|
3029
|
+
const sidebarOwnershipAcceptsNewAuto = (sessionId, rootId, address) => {
|
|
3030
|
+
try {
|
|
3031
|
+
const entries = sidebarOwnershipEntries();
|
|
3032
|
+
const key = sidebarAutoScopedKey(sessionId, rootId, address);
|
|
3033
|
+
const existing = entries.get(key);
|
|
3034
|
+
const existingIsAuto = existing !== undefined && existing.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO;
|
|
3035
|
+
const nextAutoCount = sidebarOwnershipAutoCount(entries) - (existingIsAuto ? 1 : 0) + 1;
|
|
3036
|
+
return nextAutoCount <= SIDEBAR_AUTO_OWNERSHIP_LIMIT;
|
|
3037
|
+
} catch {
|
|
3038
|
+
return true;
|
|
3039
|
+
}
|
|
3040
|
+
};
|
|
3041
|
+
|
|
3042
|
+
/**
|
|
3043
|
+
* 写入归属标记(内存与 localStorage 同一处收口)并记一条诊断;返回是否真的写进去了。
|
|
3044
|
+
*
|
|
3045
|
+
* tabId 只在**调用方真的读到了宿主 inventory 里这个地址的 tab** 时才传(当前唯一的 auto 调用点
|
|
3046
|
+
* 是 recordSidebarTab):它把这条归属绑定到具体的 tab 上,刷新之后的收养必须靠它证明「还是同一个
|
|
3047
|
+
* tab」(见 recordSidebarTab 的 tabId 绑定闸门)。manual 条目不需要它,传 undefined 即可。
|
|
3048
|
+
*
|
|
3049
|
+
* 容量 fail-closed(缺陷 2):会挤掉仍有效 owner 的新增 / 改写(即写入之后 auto 条目数超过上限)
|
|
3050
|
+
* **一律拒绝**,并留下一条 reject/capacity 诊断。manual 写入从不被容量拒绝——但同样绝不为了腾位
|
|
3051
|
+
* 去淘汰任何已有条目,因此持久表最多是「上限条 auto + 用户自己产生的 manual 条目」。
|
|
3052
|
+
* 到达上限是可用性代价而不是错误:那个资源不自动打开,用户仍然可以手动打开(手动打开照常写
|
|
3053
|
+
* manual 归属,见 handleSidebarAction 的入口写入)。
|
|
3054
|
+
*/
|
|
3055
|
+
const writeSidebarAutoOwnership = (sessionId, rootId, address, origin, reason, tabId) => {
|
|
3056
|
+
try {
|
|
3057
|
+
const normalizedOrigin = origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL
|
|
3058
|
+
? SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL
|
|
3059
|
+
: SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO;
|
|
3060
|
+
const entries = sidebarOwnershipEntries();
|
|
3061
|
+
const key = sidebarAutoScopedKey(sessionId, rootId, address);
|
|
3062
|
+
if (normalizedOrigin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO
|
|
3063
|
+
&& sidebarOwnershipAcceptsNewAuto(sessionId, rootId, address) !== true) {
|
|
3064
|
+
recordSidebarAutoDiag({ kind: "ownership", event: "reject", origin: normalizedOrigin, reason: "capacity", key: sidebarAutoKeyDigest(key) });
|
|
3065
|
+
return false;
|
|
3066
|
+
}
|
|
3067
|
+
entries.delete(key);
|
|
3068
|
+
entries.set(key, {
|
|
3069
|
+
key,
|
|
3070
|
+
origin: normalizedOrigin,
|
|
3071
|
+
updatedAt: Date.now(),
|
|
3072
|
+
reason: sidebarBoundedText(reason),
|
|
3073
|
+
tabId: sidebarBoundedText(tabId),
|
|
3074
|
+
});
|
|
3075
|
+
persistSidebarOwnership(entries);
|
|
3076
|
+
recordSidebarAutoDiag({ kind: "ownership", event: "write", origin: normalizedOrigin, reason, key: sidebarAutoKeyDigest(key) });
|
|
3077
|
+
return true;
|
|
3078
|
+
} catch {
|
|
3079
|
+
/* 归属标记只影响「刷新之后还认不认」,任何失败都静默。 */
|
|
3080
|
+
return false;
|
|
3081
|
+
}
|
|
3082
|
+
};
|
|
3083
|
+
|
|
3084
|
+
/**
|
|
3085
|
+
* 删除归属标记(与写入同源:内存删掉后立刻落盘)。
|
|
3086
|
+
*
|
|
3087
|
+
* 默认**拒绝**删除 manual 条目:manual 是用户的手动意图(手动关闭 / 手动打开),而调用这条删除的
|
|
3088
|
+
* 路径全是 Auto 自己的收口(verified-close / inventory-absent / tab-recycled / resource-running)。
|
|
3089
|
+
* 让 Auto 的收口顺手删掉用户的抑制,就等于「刷新之后用户的关闭又被撤销」——正是 P1-B 要堵的洞。
|
|
3090
|
+
* 因此这里只回答「Auto 自己的归属是否已经不需要了」,manual 条目一律保留并留一条 keep 诊断。
|
|
3091
|
+
*
|
|
3092
|
+
* options.manual === true 是唯一的例外:只有「观察到资源已经明确空闲(ready)」那条专用清点路径
|
|
3093
|
+
* 才允许清除 manual(见 clearManualSuppressionOfIdleResources),语义是「这一轮运行已经结束,
|
|
3094
|
+
* 用户当时的关闭意图不再需要跨运行保留」。
|
|
3095
|
+
*/
|
|
3096
|
+
const deleteSidebarAutoOwnership = (sessionId, rootId, address, reason, options) => {
|
|
3097
|
+
try {
|
|
3098
|
+
const entries = sidebarOwnershipEntries();
|
|
3099
|
+
const key = sidebarAutoScopedKey(sessionId, rootId, address);
|
|
3100
|
+
const entry = entries.get(key);
|
|
3101
|
+
if (entry === undefined) {
|
|
3102
|
+
recordSidebarAutoDiag({ kind: "ownership", event: "delete-miss", reason, key: sidebarAutoKeyDigest(key) });
|
|
3103
|
+
return false;
|
|
3104
|
+
}
|
|
3105
|
+
if (entry.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL
|
|
3106
|
+
&& (options === null || options === undefined || options.manual !== true)) {
|
|
3107
|
+
recordSidebarAutoDiag({ kind: "ownership", event: "keep", origin: SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, reason, key: sidebarAutoKeyDigest(key) });
|
|
3108
|
+
return false;
|
|
3109
|
+
}
|
|
3110
|
+
entries.delete(key);
|
|
3111
|
+
persistSidebarOwnership(entries);
|
|
3112
|
+
recordSidebarAutoDiag({ kind: "ownership", event: "delete", reason, key: sidebarAutoKeyDigest(key) });
|
|
3113
|
+
return true;
|
|
3114
|
+
} catch {
|
|
3115
|
+
return false;
|
|
3116
|
+
}
|
|
3117
|
+
};
|
|
3118
|
+
|
|
3119
|
+
/** 记录一次自动打开/自动关闭决策(候选 + 结算),失败原因只留截断后的一行。 */
|
|
3120
|
+
const recordSidebarAutoDecision = (event, candidate, verdict, reason) => {
|
|
3121
|
+
recordSidebarAutoDiag({
|
|
3122
|
+
kind: "decision",
|
|
3123
|
+
event,
|
|
3124
|
+
action: candidate === null || candidate === undefined ? undefined : candidate.kind,
|
|
3125
|
+
verdict,
|
|
3126
|
+
reason,
|
|
3127
|
+
key: candidate === null || candidate === undefined ? undefined : sidebarAutoKeyDigest(candidate.key),
|
|
3128
|
+
});
|
|
3129
|
+
};
|
|
3130
|
+
|
|
2496
3131
|
function createExpertGroupPanel(deps) {
|
|
2497
3132
|
const config = object(deps);
|
|
2498
3133
|
const react = config.react;
|
|
@@ -2580,6 +3215,151 @@
|
|
|
2580
3215
|
return { rootSessionId, snapshot: cached, loading: cached === null, error: null };
|
|
2581
3216
|
};
|
|
2582
3217
|
|
|
3218
|
+
/**
|
|
3219
|
+
* 跨 Panel 实例共享的 Auto 账本(同一插件 install 内共享;重装插件或重启进程即随之消失)。
|
|
3220
|
+
*
|
|
3221
|
+
* 症状与根因:真实 DSH 的 keyed session surface 会卸载旧 Panel 实例、再用同一个已安装组件挂载
|
|
3222
|
+
* 新实例,而宿主右栏的 tab 与它自己那份 inventory 原样保留。这三份账本原先都建在 Panel 内的
|
|
3223
|
+
* useRef 上,卸载即丢失,因此新实例在 syncSidebarTabRecords() 的收养路径里只能把宿主里已经
|
|
3224
|
+
* 存在的 tab 记成 manual 来源(recordSidebarTab 的兜底),Auto 随后主动放弃关闭它——用户看到的
|
|
3225
|
+
* 就是「子代理已经空闲,Auto 开出来的那个 tab 却永远留在右栏」。
|
|
3226
|
+
*
|
|
3227
|
+
* 只共享回答「这个 tab 是不是 Auto 亲手打开、还归不归 Auto 管」所必需的集合:
|
|
3228
|
+
* - origin:Auto 亲手发出过打开动作的资源(键与打开记录同构);它同时是「绝不重复打开」的记账;
|
|
3229
|
+
* - suppressed:用户手动关闭过的资源,Auto 不得立刻重开;
|
|
3230
|
+
* - closeAttempts:自动关闭的有界重试计数(重挂载不得白送或重置预算);
|
|
3231
|
+
* - closeAttemptOwners:每条 closeAttempts 预算**当前所有者**的不可复用令牌(见下方说明)。
|
|
3232
|
+
*
|
|
3233
|
+
* 重试预算必须带所有者身份:预支与回滚分别发生在「候选选择」和「动作在副作用之前被撤销」两个
|
|
3234
|
+
* 时刻,中间可能跨越一次面板重挂载或同一个实例的 A→B→A 回代。预算本身按 key 共享,因此旧代次
|
|
3235
|
+
* 的迟到回滚若只按 key 写回 attemptsBefore,就会删掉/覆盖新代次已经预支的那一笔预算——同一个
|
|
3236
|
+
* key 的实际 close 次数随之突破 3 次上限。owner 账本把「这笔预算现在是谁的」也放进同一层共享
|
|
3237
|
+
* 状态,回滚只认对象身份,旧令牌一律 fail-safe。
|
|
3238
|
+
*
|
|
3239
|
+
* 其余状态一律留在 Panel 实例内:在途动作与预留(reservation)、Auto 代次(epoch)、失败屏障、
|
|
3240
|
+
* busy 闸门、tab 打开记录(records/openings)、手动意图都属于「当前这一帧 surface 的在途状态」,
|
|
3241
|
+
* 跨实例共享只会让旧实例的在途状态污染新实例。键始终是(sidebar session + rootSessionId +
|
|
3242
|
+
* 资源地址)复合键,因此共享也不会让不同 root / 不同 session 互相影响。
|
|
3243
|
+
*
|
|
3244
|
+
* 生命周期(本轮修复):这八份 Map 不只是「同一 install 内共享」,而是**本 realm 内共享**——
|
|
3245
|
+
* bundle 被 HMR 重新执行之后仍复用同一批 Map(见 resolveSidebarSharedAutoLedger)。否则一次
|
|
3246
|
+
* 构建(fixer 角色最容易触发)就会把「这个 tab 是 Auto 亲手打开的」全部抹掉,tab 随即被收养成
|
|
3247
|
+
* manual 并永久留在右栏。跨整页刷新/进程重启的归属由持久标记层负责(SIDEBAR_AUTO_OWNERSHIP_KEY)。
|
|
3248
|
+
*/
|
|
3249
|
+
const sharedAutoLedgerState = resolveSidebarSharedAutoLedger();
|
|
3250
|
+
const sharedAutoLedger = sharedAutoLedgerState.ledger;
|
|
3251
|
+
recordSidebarAutoDiag({
|
|
3252
|
+
kind: "install",
|
|
3253
|
+
reused: sharedAutoLedgerState.reused,
|
|
3254
|
+
degraded: sharedAutoLedgerState.degraded,
|
|
3255
|
+
sizes: sidebarSharedAutoLedgerSizes(sharedAutoLedger),
|
|
3256
|
+
});
|
|
3257
|
+
if (sharedAutoLedgerState.reused === true && sharedAutoLedgerState.degraded !== true
|
|
3258
|
+
&& sidebarSharedAutoLedgerTotal(sharedAutoLedger) > 0) {
|
|
3259
|
+
// 只在「复用了一份非空账本」时提示一行:用户开着 DevTools 就能确认 HMR 之后归属没有丢。
|
|
3260
|
+
try {
|
|
3261
|
+
console.info("[dsh-expert-group] 本 realm 已有共享 Auto 账本:本次装载复用既有的归属 / 预算 / 确认计数(bundle 重新执行或 HMR)");
|
|
3262
|
+
} catch { /* 控制台不可用不影响功能。 */ }
|
|
3263
|
+
}
|
|
3264
|
+
/**
|
|
3265
|
+
* realm 共享的 Auto 来源账本:key → { sessionId, rootSessionId, address, tabId }。
|
|
3266
|
+
*
|
|
3267
|
+
* tabId 是「Auto 打开/替换落地那一刻,插件亲眼在宿主 inventory 里读到的那个 tab」,它让这份
|
|
3268
|
+
* 跨 bundle 重新执行(HMR)/ 跨 Panel 实例的账本不再只是一句「我们打开过」——所有据此认定
|
|
3269
|
+
* auto 的位置都必须比对 tabId(见 sidebarAutoOriginEntry / sidebarAutoOriginTabIdOf)。
|
|
3270
|
+
*/
|
|
3271
|
+
const sharedSidebarAutoOrigin = sharedAutoLedger.origin;
|
|
3272
|
+
const sharedSidebarAutoSuppressed = sharedAutoLedger.suppressed;
|
|
3273
|
+
const sharedSidebarAutoCloseAttempts = sharedAutoLedger.closeAttempts;
|
|
3274
|
+
/**
|
|
3275
|
+
* 跨 Panel 实例共享的「这条自动关闭重试预算归谁」账本:key → 本次预支预算的**不可复用**令牌。
|
|
3276
|
+
*
|
|
3277
|
+
* 键与 closeAttempts 完全同构,取值是候选选择那一刻新建的对象(对象身份即所有权),因此任何
|
|
3278
|
+
* 旧代次手里的令牌都不可能与后来者的令牌相等。写入与删除与 closeAttempts 同步进行,并沿用同一
|
|
3279
|
+
* 个 trimAutoKeyMap/128 上限,绝不引入第二份无界 Map。
|
|
3280
|
+
*/
|
|
3281
|
+
const sharedSidebarAutoCloseAttemptOwners = sharedAutoLedger.closeAttemptOwners;
|
|
3282
|
+
/**
|
|
3283
|
+
* 跨 Panel 实例共享的「close 请求已经发出、等待 inventory 验证」状态:key → 验证记录
|
|
3284
|
+
* { sessionId, rootSessionId, tabId, address, attemptToken, manual, misses, deadline, lease }。
|
|
3285
|
+
*
|
|
3286
|
+
* 关闭请求 resolve 之后绝不能立刻收口:记录只在**连续两次可读 inventory 都读不到这个精确 tabId**
|
|
3287
|
+
* 时才算 verified-closed。验证链因此必须与来源账本同层共享——重挂载后的新实例继续采样、继续收口,
|
|
3288
|
+
* 而不是把「请求完成」当成「已经关闭」。租约同时被这条记录持有,下一轮同步绝不会重复 close。
|
|
3289
|
+
*/
|
|
3290
|
+
const sharedSidebarAutoCloseVerifications = sharedAutoLedger.closeVerifications;
|
|
3291
|
+
/**
|
|
3292
|
+
* 跨 Panel 实例共享的自动关闭失败冷却:key → { step, until }。
|
|
3293
|
+
*
|
|
3294
|
+
* 与重试计数同层共享:scope remount 或同一个实例 A→B→A 绝不能绕过失败上限(否则频繁重挂载就等于
|
|
3295
|
+
* 无限重试)。generation token 只负责阻止旧动作越权,不改变这份预算的生命周期。
|
|
3296
|
+
*/
|
|
3297
|
+
const sharedSidebarAutoCloseCooldowns = sharedAutoLedger.closeCooldowns;
|
|
3298
|
+
/**
|
|
3299
|
+
* 跨 Panel 实例共享的 Auto 候选采样计数:key → { sessionId, rootSessionId, tabId, misses }。
|
|
3300
|
+
*
|
|
3301
|
+
* 症状与根因:候选选择阶段的在场判据原先只采**一次**样。宿主 inventory 只要在这一帧短暂缺项
|
|
3302
|
+
* (布局换桶、面板重挂载、宿主提交窗口的中间态都是正常抖动),单次 absent 就会立刻删掉这个 key
|
|
3303
|
+
* 的 record / 来源 / 预算——tab 明明还在宿主里,却永久失去 Auto 归属,资源结束后再也不会被
|
|
3304
|
+
* 自动收回(用户看到的正是「偶尔漏收」)。记录同步器(record.misses)与关闭验证链
|
|
3305
|
+
* (verification.misses)都要求 SIDEBAR_TAB_DISAPPEAR_CONFIRMATIONS 次**连续**缺失,候选选择
|
|
3306
|
+
* 必须与它们同一条确认语义,否则同一份 inventory 在两处被解释成两种强度。
|
|
3307
|
+
*
|
|
3308
|
+
* - 生命周期:第一次 absent/recycled 采样时写入;任一 present 采样立刻清零(与既有语义一致);
|
|
3309
|
+
* 这个 key 的 Auto 关闭记账整体收口时(clearAutoCloseAttempt,覆盖预算 / owner / 冷却的
|
|
3310
|
+
* 所有入口)一并删除,因此绝不跨代残留;
|
|
3311
|
+
* - 计数只对**同一个 tabId** 有效:record 换成宿主新分配的 tabId 时旧计数自动作废;
|
|
3312
|
+
* - 限容:**纯 LRU**(按最近一次采样时间排序)+ SIDEBAR_AUTO_KEY_LIMIT,绝不新增无界 Map;
|
|
3313
|
+
* 绝不用当前实例的局部 record / 在途状态判定别的 scope 的共享条目(见 trimSharedSidebarAutoTabMisses)。
|
|
3314
|
+
*/
|
|
3315
|
+
const sharedSidebarAutoTabMisses = sharedAutoLedger.tabMisses;
|
|
3316
|
+
/**
|
|
3317
|
+
* sharedSidebarAutoTabMisses 的限容淘汰:**纯 LRU**——按「最近一次采样」排序,淘汰最久没被采样的条目。
|
|
3318
|
+
*
|
|
3319
|
+
* 为什么这条 Map 绝不能用 trimAutoKeyMap(map, true) 那套「活动感知」淘汰:
|
|
3320
|
+
* 1. 生命周期不匹配。这份计数必须**跨 Panel 实例、跨 root / sidebar session 共享**(确认序列要在
|
|
3321
|
+
* 重挂载之后继续推进),而活动判定 sidebarAutoCloseKeyIsActive 读的是**当前这个实例**的局部
|
|
3322
|
+
* 在途状态(pending / opening / reservation / verification / cooldown)与**当前 scope** 的
|
|
3323
|
+
* record。别的 scope 的条目在当前实例里天然「不活动」,于是它们会在别的 scope 的一次普通采样
|
|
3324
|
+
* 写入时被当成历史条目淘汰——正是本插件要修的「偶尔漏收」:目标 key 的确认计数被打回 1,永远
|
|
3325
|
+
* 到不了 SIDEBAR_TAB_DISAPPEAR_CONFIRMATIONS,record / origin 保留但那个 tab 再也不自动收回。
|
|
3326
|
+
* 2. 采样计数本来就与在途状态无关:它只回答「这个 tabId 连续几次被**可读采样**判为不在场」。
|
|
3327
|
+
* 跨 scope 的条目同样需要完整数满两次,因此可淘汰性只能由「最后一次采样有多旧」决定,绝不能由
|
|
3328
|
+
* 当前帧的 record / 在途状态决定。
|
|
3329
|
+
*
|
|
3330
|
+
* 为什么 128 上限够用:确认只需 2 次采样,而**每次采样都会把这个 key 重新插到队尾**
|
|
3331
|
+
* (见 sampleAutoTabMisses),所以一个正在确认中的 key 只有在「它两次采样之间又插入了 128 次其它
|
|
3332
|
+
* 采样」时才会被挤掉;每个 surface 每轮至多推进自己的一条采样,真实轮询周期远小于这个量级。
|
|
3333
|
+
* 上限本身继续防止复合键(session + root + 资源地址)随长生命周期无界增长。
|
|
3334
|
+
*/
|
|
3335
|
+
const trimSharedSidebarAutoTabMisses = () => {
|
|
3336
|
+
while (sharedSidebarAutoTabMisses.size > SIDEBAR_AUTO_KEY_LIMIT) {
|
|
3337
|
+
const oldest = sharedSidebarAutoTabMisses.keys().next();
|
|
3338
|
+
if (oldest.done === true) break;
|
|
3339
|
+
sharedSidebarAutoTabMisses.delete(oldest.value);
|
|
3340
|
+
}
|
|
3341
|
+
};
|
|
3342
|
+
/**
|
|
3343
|
+
* 跨 Panel 实例共享的「同一个 tab 上已经有一次关闭在途」租约:key =(sidebar session + root + tabId)
|
|
3344
|
+
* → 租约对象(身份 + 结算信号)。
|
|
3345
|
+
*
|
|
3346
|
+
* 症状与根因:宿主右栏的 close() 可能是异步的(返回 Promise,结算后才真的移除 tab)。旧 Panel 实例
|
|
3347
|
+
* 发出这次关闭后就被卸载了,但那次调用的续体仍在运行;而它的 pending 锁与 busy 闸门都是**实例级**
|
|
3348
|
+
* 的,新实例一概看不见——宿主 inventory 里这个 tab 还在,新实例收养它之后会为同一个 tabId 再发一次
|
|
3349
|
+
* close。宿主若非幂等(或复用了 tabId),用户就会看到重复副作用(关掉别人的 tab / 抛错)。
|
|
3350
|
+
*
|
|
3351
|
+
* 因此这把锁必须与来源账本同层共享:身份是(当前 sidebar session + root + tabId),Auto 单 tab 关闭、
|
|
3352
|
+
* 手动单 tab 关闭与批量关闭三个入口共用它;只在真正调用宿主 close 的那一小段持有,并在 finally 归还。
|
|
3353
|
+
* 锁只回答「这个 tab 现在有人在关吗」,不携带任何 Panel 实例状态。
|
|
3354
|
+
*
|
|
3355
|
+
* 值不是「无结果的 token」而是一份**可结算的租约**:它额外携带那一次 close 的真实结果(成功 / 失败)
|
|
3356
|
+
* 与一个等待信号。竞争方(用户触发的手动单项与批量)必须等到结算再决定下一步——上次成功就当作这个
|
|
3357
|
+
* tab 已经被关掉、绝不再 close;上次失败才允许用当前 inventory 复核同一个 tabId 后做一次有限重试。
|
|
3358
|
+
* 少了这层结果信号,等待者只能看到「锁空了」:要么对已经关掉的 tab 重复 close,要么把一次失败的
|
|
3359
|
+
* 竞争当成「有人处理了」而丢掉用户的关闭意图。
|
|
3360
|
+
*/
|
|
3361
|
+
const sharedSidebarTabCloseInFlight = sharedAutoLedger.tabCloseInFlight;
|
|
3362
|
+
|
|
2583
3363
|
function Panel(props) {
|
|
2584
3364
|
const ctx = props?.ctx || config.ctx;
|
|
2585
3365
|
let tabInfo = null;
|
|
@@ -2659,10 +3439,52 @@
|
|
|
2659
3439
|
currentRootRef.current = rootSessionId;
|
|
2660
3440
|
const currentSidebarSessionRef = typeof react.useRef === "function" ? react.useRef(sidebarSessionId) : { current: sidebarSessionId };
|
|
2661
3441
|
currentSidebarSessionRef.current = sidebarSessionId;
|
|
2662
|
-
|
|
2663
|
-
|
|
2664
|
-
|
|
2665
|
-
|
|
3442
|
+
/**
|
|
3443
|
+
* surface 身份令牌:给每一条「跨 await 的异步动作」用的**不可复用**身份。
|
|
3444
|
+
*
|
|
3445
|
+
* 症状与根因:异步动作(自动打开/关闭、批量关闭、等待竞争租约)在 await 之后只用
|
|
3446
|
+
* mountedRef + currentRootRef + currentSidebarSessionRef 复核「当前 surface」。这三条判据
|
|
3447
|
+
* 比较的是**当前字符串值**,于是有一条真实交错会漏过去:同一个 Panel 实例快速
|
|
3448
|
+
* root/sidebar session A→B→A 之后,旧闭包捕获的字符串会与当前值**重新相等**——旧动作由此
|
|
3449
|
+
* 把自己的迟到收尾当成当前 surface 的收尾继续执行,删掉「A 里已经换成新 tabId 的 record /
|
|
3450
|
+
* Auto 来源」,并用旧快照推进同步。字符串判据挡得住「切走了没回来」,挡不住「切走又切回」。
|
|
3451
|
+
*
|
|
3452
|
+
* 因此每个 Panel 实例在挂载时生成一份唯一身份,并在 sidebarSessionId / rootSessionId 每一次
|
|
3453
|
+
* 变化时换成**新对象**(A→B→A 两次都换):异步动作启动时捕获自己那一份,await 之后只回答
|
|
3454
|
+
* 「还是不是我出发时那一份」。令牌必须比较对象身份,绝不能只比较当前字符串值。
|
|
3455
|
+
*
|
|
3456
|
+
* 生成时机:首次渲染(挂载)与「root/sidebar session 与上一帧不同」的那一帧。同一组值下的
|
|
3457
|
+
* 普通重渲染(轮询、通知、展开状态变化)与 StrictMode 的双渲染都不会换令牌(hook 槽位不变),
|
|
3458
|
+
* 因此正在执行的异步动作不会被误判成 stale;组件重挂载则必然换(新实例 = 新 ref 槽位)。
|
|
3459
|
+
*/
|
|
3460
|
+
const surfaceTokenScopeRef = typeof react.useRef === "function" ? react.useRef(null) : { current: null };
|
|
3461
|
+
const surfaceTokenRef = typeof react.useRef === "function" ? react.useRef(null) : { current: null };
|
|
3462
|
+
const surfaceTokenScope = surfaceTokenScopeRef.current;
|
|
3463
|
+
if (surfaceTokenScope === null
|
|
3464
|
+
|| surfaceTokenScope.rootSessionId !== rootSessionId
|
|
3465
|
+
|| surfaceTokenScope.sidebarSessionId !== sidebarSessionId) {
|
|
3466
|
+
surfaceTokenScopeRef.current = { rootSessionId, sidebarSessionId };
|
|
3467
|
+
surfaceTokenRef.current = { rootSessionId, sidebarSessionId };
|
|
3468
|
+
}
|
|
3469
|
+
/** 本帧闭包捕获的 surface 身份:所有异步动作在启动时捕获它,await 之后只与这一份比较。 */
|
|
3470
|
+
const surfaceToken = surfaceTokenRef.current;
|
|
3471
|
+
/**
|
|
3472
|
+
* 异步动作的 surface 闸门:mounted / root / sidebar session 三条既有判据**同时**成立,
|
|
3473
|
+
* 并且令牌仍然是出发时那一份,才允许继续。
|
|
3474
|
+
*
|
|
3475
|
+
* 两组判据缺一不可:字符串判据负责「切走了、没回来」与「别的 root 的同地址记录」,令牌负责
|
|
3476
|
+
* 「切走了又切回同一组值」(A→B→A)与「重挂载后的旧闭包」。await 之后、旧闭包调用
|
|
3477
|
+
* syncSidebarTabs() 之前、以及会改共享 Auto 账本 / 记录 / 手动抑制的迟到收尾分支,都必须先过
|
|
3478
|
+
* 这一道闸门。
|
|
3479
|
+
*/
|
|
3480
|
+
const sidebarSurfaceStillCurrent = () => mountedRef.current === true
|
|
3481
|
+
&& currentRootRef.current === rootSessionId
|
|
3482
|
+
&& currentSidebarSessionRef.current === sidebarSessionId
|
|
3483
|
+
&& surfaceTokenRef.current === surfaceToken;
|
|
3484
|
+
const refreshStateRef = typeof react.useRef === "function"
|
|
3485
|
+
? react.useRef({ rootSessionId: null, inFlight: null, pending: false })
|
|
3486
|
+
: { current: { rootSessionId: null, inFlight: null, pending: false } };
|
|
3487
|
+
const refresh = () => {
|
|
2666
3488
|
const refreshState = refreshStateRef.current;
|
|
2667
3489
|
// 同一组件实例切换 root 时,立即放弃旧请求;旧 Promise 的 finally 通过对象身份检查,
|
|
2668
3490
|
// 不会清理或触发新 root 的请求。
|
|
@@ -2811,10 +3633,30 @@
|
|
|
2811
3633
|
* (手动意图始终优先)。
|
|
2812
3634
|
* 两个集合都按当前快照与上限清理(见 syncAutoSidebarTabs 的清理阶段)。
|
|
2813
3635
|
*/
|
|
2814
|
-
|
|
2815
|
-
|
|
2816
|
-
|
|
2817
|
-
const
|
|
3636
|
+
// 这几个集合指向 createExpertGroupPanel 闭包里的共享账本:重挂载后的新实例靠它认领旧实例开出的
|
|
3637
|
+
// tab(见 sharedSidebarAutoOrigin 的说明)。ref 只是持有者,读写结构逐字不变。
|
|
3638
|
+
const sidebarAutoOriginRef = typeof react.useRef === "function" ? react.useRef(sharedSidebarAutoOrigin) : { current: sharedSidebarAutoOrigin };
|
|
3639
|
+
const sidebarAutoSuppressedRef = typeof react.useRef === "function" ? react.useRef(sharedSidebarAutoSuppressed) : { current: sharedSidebarAutoSuppressed };
|
|
3640
|
+
/** 自动关闭的重试记账:key → 已尝试次数(成功或资源重新变成运行中时清空);跨重挂载保留。 */
|
|
3641
|
+
const sidebarAutoCloseAttemptsRef = typeof react.useRef === "function" ? react.useRef(sharedSidebarAutoCloseAttempts) : { current: sharedSidebarAutoCloseAttempts };
|
|
3642
|
+
/**
|
|
3643
|
+
* 自动关闭重试预算的所有者账本:key → 本次预支预算的不可复用令牌;与重试计数同层共享。
|
|
3644
|
+
*
|
|
3645
|
+
* 只有「当前 owner 就是自己出发时那一份令牌」的动作才允许回滚这次预支(见 releaseAutoCloseAttempt),
|
|
3646
|
+
* 因此旧代次在副作用之前被撤销时绝不可能删掉/覆盖新代次已经预支的预算。
|
|
3647
|
+
*/
|
|
3648
|
+
const sidebarAutoCloseAttemptOwnersRef = typeof react.useRef === "function" ? react.useRef(sharedSidebarAutoCloseAttemptOwners) : { current: sharedSidebarAutoCloseAttemptOwners };
|
|
3649
|
+
/** 关闭请求的验证记录(跨重挂载保留:验证由后续任意一次同步按精确 inventory 完成)。 */
|
|
3650
|
+
const sidebarAutoCloseVerificationsRef = typeof react.useRef === "function" ? react.useRef(sharedSidebarAutoCloseVerifications) : { current: sharedSidebarAutoCloseVerifications };
|
|
3651
|
+
/** 自动关闭失败冷却账本(跨重挂载保留:remount 绝不能绕过失败上限)。 */
|
|
3652
|
+
const sidebarAutoCloseCooldownsRef = typeof react.useRef === "function" ? react.useRef(sharedSidebarAutoCloseCooldowns) : { current: sharedSidebarAutoCloseCooldowns };
|
|
3653
|
+
/**
|
|
3654
|
+
* Auto 候选采样到的「这个 tab 连续不在场」计数(跨重挂载保留,见 sharedSidebarAutoTabMisses)。
|
|
3655
|
+
*
|
|
3656
|
+
* 与来源 / 抑制 / 预算同层共享:一次重挂载绝不能把「已经确认缺失一次」重置成「还没采样过」,
|
|
3657
|
+
* 否则同一条确认语义会被 remount 反复打断(那正是「单次缺失即收口」的另一种写法)。
|
|
3658
|
+
*/
|
|
3659
|
+
const sidebarAutoTabMissesRef = typeof react.useRef === "function" ? react.useRef(sharedSidebarAutoTabMisses) : { current: sharedSidebarAutoTabMisses };
|
|
2818
3660
|
/**
|
|
2819
3661
|
* 自动打开的**预留**(reservation):key → { sessionId, rootSessionId, address, epoch }。
|
|
2820
3662
|
*
|
|
@@ -3128,6 +3970,19 @@
|
|
|
3128
3970
|
};
|
|
3129
3971
|
const sidebarOpenTabsAvailable = readSidebarOpenTabs() !== null;
|
|
3130
3972
|
const snapshot = viewState.snapshot;
|
|
3973
|
+
/**
|
|
3974
|
+
* 轻量(partial)快照标记:Host 首屏返回 partial:true 表示它跳过了全部冷读,
|
|
3975
|
+
* 状态与任务名可能不完整。渲染层据此把「没有任何活动证据」的圆点与活动文案保持中性;
|
|
3976
|
+
* 完整快照(partial:false/缺失)与旧宿主一律走既有渲染路径,逐字不变。
|
|
3977
|
+
*/
|
|
3978
|
+
const partialSnapshot = snapshot?.partial === true;
|
|
3979
|
+
/**
|
|
3980
|
+
* 容器(空闲分组)在轻量快照下使用的中性运行状态:取值与模型导出的
|
|
3981
|
+
* UNKNOWN_RUNTIME_STATUS 同源,模型缺失时按同名字面量兜底,避免两处各存一份词表。
|
|
3982
|
+
*/
|
|
3983
|
+
const neutralRuntimeStatus = typeof model.UNKNOWN_RUNTIME_STATUS === "string" && model.UNKNOWN_RUNTIME_STATUS.length > 0
|
|
3984
|
+
? model.UNKNOWN_RUNTIME_STATUS
|
|
3985
|
+
: "unknown";
|
|
3131
3986
|
const sidebarSnapshotSyncRef = typeof react.useRef === "function"
|
|
3132
3987
|
? react.useRef({ rootSessionId, sidebarSessionId, snapshot })
|
|
3133
3988
|
: { current: { rootSessionId, sidebarSessionId, snapshot } };
|
|
@@ -3544,15 +4399,63 @@
|
|
|
3544
4399
|
/** 当前快照的 root 直接子节点(快照缺失时为空数组)。 */
|
|
3545
4400
|
const sidebarRootChildren = () => (Array.isArray(snapshot?.root?.children) ? snapshot.root.children : []);
|
|
3546
4401
|
|
|
4402
|
+
/**
|
|
4403
|
+
* 空闲证据规则(空闲分组与空闲批量关闭候选的**唯一**判定入口)。
|
|
4404
|
+
*
|
|
4405
|
+
* 只有 runtimeStatusOfNode(...) === "ready"(**有证据**表明当前未运行)才算空闲:
|
|
4406
|
+
* - 轻量快照(partial:true)下「没有任何活动证据」的节点被归一为中性值 unknown,
|
|
4407
|
+
* 它既不是 running 也不是 ready,因此既不得进入空闲分组、也不得成为空闲批量关闭候选——
|
|
4408
|
+
* 否则用户会依据轻量快照关掉实际仍在运行、只是首屏读不到状态的会话;
|
|
4409
|
+
* - 完整快照(partial:false)到达后不会再出现 unknown,规则自动回到既有行为,不留永久性差异;
|
|
4410
|
+
* - running 与 unknown 一样被排除,保守方向不变。
|
|
4411
|
+
*
|
|
4412
|
+
* partial 证据规则通过 options 一路传到模型的活动证据链,与行内圆点、第三行文案同源;
|
|
4413
|
+
* 这里只读当前渲染的 partialSnapshot,切换 root 或快照换代都会随闭包一起更新。
|
|
4414
|
+
*/
|
|
4415
|
+
const sidebarNodeIsIdleReady = (node, parentId, childId) =>
|
|
4416
|
+
runtimeStatusOfNode(node, parentId, childId, { partial: partialSnapshot }) === "ready";
|
|
4417
|
+
|
|
4418
|
+
/**
|
|
4419
|
+
* 空闲分组的**成员**判定(显示从宽)。
|
|
4420
|
+
*
|
|
4421
|
+
* 在严格判据之外,额外接受轻量快照下「没有任何活动证据」的 unknown 节点:它们与 ready
|
|
4422
|
+
* 一样被收纳进分组,只是圆点与文案保持中性(见 renderExpert / renderIdleGroup)。
|
|
4423
|
+
* 这样同一份数据在 partial:true 与 partial:false 下分组**成员集合与顺序完全一致**,
|
|
4424
|
+
* 消除「同一节点在两条路径之间来回跳位」的用户可见缺陷。
|
|
4425
|
+
*
|
|
4426
|
+
* 只放宽**显示**:任何会真的操作宿主资源的路径(批量关闭候选、manual 抑制清理)都必须继续
|
|
4427
|
+
* 使用严格的 sidebarNodeIsIdleReady,不得改用本函数。
|
|
4428
|
+
*/
|
|
4429
|
+
const sidebarNodeIsIdleMembership = (node, parentId, childId) => {
|
|
4430
|
+
const status = runtimeStatusOfNode(node, parentId, childId, { partial: partialSnapshot });
|
|
4431
|
+
if (status === "ready") return true;
|
|
4432
|
+
// unknown 只可能来自 partial 快照(完整快照的证据链不会返回它):此时纳入分组显示。
|
|
4433
|
+
return partialSnapshot === true && status === neutralRuntimeStatus;
|
|
4434
|
+
};
|
|
4435
|
+
|
|
3547
4436
|
/**
|
|
3548
4437
|
* 空闲分组收纳 ready 直接专家和已结算的 fan-out 父任务。
|
|
3549
|
-
* 父任务必须命中 manager
|
|
4438
|
+
* 父任务必须命中 manager 终态,不能仅凭子会话暂时未运行或未知状态提前移动(manager 的聚合
|
|
4439
|
+
* 状态本身就是真实证据,不是「没有证据」,因此不受 partial 影响)。
|
|
4440
|
+
*
|
|
4441
|
+
* 直接专家走 sidebarNodeIsIdleMembership:**显示从宽**——轻量快照下没有活动证据的专家
|
|
4442
|
+
* (unknown)也纳入分组,使它在 partial / full 下的组内相对位置完全一致。
|
|
4443
|
+
*
|
|
4444
|
+
* 为什么显示要放宽:排序键是 createdAt,而轻量快照没有冷读、拿不到专家会话的创建时间
|
|
4445
|
+
* (真实 child_models 记录里也没有该字段),因此同一批节点在 partial 与 full 下的排序结果
|
|
4446
|
+
* 本来就可能不同;若再让「是否进组」也随证据变化,同一次 partial↔full 切换会**同时**改变
|
|
4447
|
+
* 分组归属与组内下标,用户在空闲列表里看到的就是「某个 fan-out 分组每隔 2.5 秒来回跳」。
|
|
4448
|
+
* 让成员集合在两条路径下一致,位置变化就只剩「锚点补齐前的一次性收敛」,不再是反复跳动。
|
|
4449
|
+
*
|
|
4450
|
+
* 操作安全性不变:unknown 节点**仍然不参与**任何批量/清理动作——空闲批量关闭候选
|
|
4451
|
+
* (idleSidebarResourceAddresses)与 manual 抑制清理(clearManualSuppressionOfIdleResources)
|
|
4452
|
+
* 都继续用严格的 sidebarNodeIsIdleReady 判定,绝不放宽。
|
|
3550
4453
|
*/
|
|
3551
4454
|
const sidebarIdleChildren = () => sidebarRootChildren()
|
|
3552
4455
|
.filter((node) => {
|
|
3553
4456
|
if (node.kind === "fanout") return FANOUT_SETTLED_STATUSES.has(statusOf(node));
|
|
3554
4457
|
return node.kind === "expert"
|
|
3555
|
-
&&
|
|
4458
|
+
&& sidebarNodeIsIdleMembership(node, rootSessionId, text(node.sessionId, null));
|
|
3556
4459
|
});
|
|
3557
4460
|
|
|
3558
4461
|
/**
|
|
@@ -3566,8 +4469,14 @@
|
|
|
3566
4469
|
};
|
|
3567
4470
|
|
|
3568
4471
|
/**
|
|
3569
|
-
*
|
|
3570
|
-
*
|
|
4472
|
+
* 空闲分组的资源地址集合(空闲批量关闭的**唯一**候选来源)。
|
|
4473
|
+
*
|
|
4474
|
+
* 注意这里与分组**成员**判定是两条不同严格度的规则(修复 B 的「显示从宽、操作从严」):
|
|
4475
|
+
* 分组成员用 sidebarNodeIsIdleMembership(unknown 也进组显示),而候选在这里用严格的
|
|
4476
|
+
* sidebarNodeIsIdleReady 再复核一次——轻量快照下没有活动证据(unknown)的节点虽然现在会
|
|
4477
|
+
* 出现在分组里,但绝不会成为可关闭的目标。两道关口的差异是**有意**的:
|
|
4478
|
+
* 位置稳定性优先,操作安全性不变(一次误关会毁掉用户正在运行的会话,代价远高于一次跳位)。
|
|
4479
|
+
* fan-out 父任务代表其最新 attempt 的分片会话,只收录当前未运行(ready)的会话地址。
|
|
3571
4480
|
*/
|
|
3572
4481
|
const idleSidebarResourceAddresses = (nodes) => {
|
|
3573
4482
|
const addresses = new Set();
|
|
@@ -3577,7 +4486,9 @@
|
|
|
3577
4486
|
for (const shard of Array.isArray(source.shards) ? source.shards : []) {
|
|
3578
4487
|
const shardSource = object(shard);
|
|
3579
4488
|
const shardChildId = text(shardSource.childId, null);
|
|
3580
|
-
|
|
4489
|
+
// childId 缺失(Host 在轻量快照里清空了无法证明归属的 child)与 unknown 状态一样,
|
|
4490
|
+
// 都不能进候选:没有精确地址就没有可关闭的目标,没有证据就不能判定它已空闲。
|
|
4491
|
+
if (shardChildId === null || sidebarNodeIsIdleReady(shardSource, rootSessionId, shardChildId) !== true) continue;
|
|
3581
4492
|
const shardAddress = subagentChatAddress(subagentAddressOfChild(shardChildId, rootSessionId, {
|
|
3582
4493
|
...shardSource,
|
|
3583
4494
|
kind: "expert",
|
|
@@ -3588,6 +4499,9 @@
|
|
|
3588
4499
|
}
|
|
3589
4500
|
const childId = text(source.sessionId, text(source.childId, null));
|
|
3590
4501
|
if (childId === null) continue;
|
|
4502
|
+
// 防御式复核:实参与 idleChildren 的成员判定逐字相同,因此对既有成员的结果完全不变;
|
|
4503
|
+
// 即使调用方以后传进来一份非 idleChildren 的列表,unknown/running 也绝不会漏成候选。
|
|
4504
|
+
if (sidebarNodeIsIdleReady(source, rootSessionId, text(source.sessionId, null)) !== true) continue;
|
|
3591
4505
|
const address = subagentChatAddress(subagentAddressOfChild(childId, rootSessionId, source));
|
|
3592
4506
|
if (address !== null) addresses.add(address);
|
|
3593
4507
|
}
|
|
@@ -3604,6 +4518,12 @@
|
|
|
3604
4518
|
* - contentId 精确等于集合中的地址:同一个 kind 下也可能是另一个子代理的地址。
|
|
3605
4519
|
*
|
|
3606
4520
|
* 结果按 tabId 去重:宿主 inventory 理论上可能有重复记录,重复 tabId 只能关一次。
|
|
4521
|
+
*
|
|
4522
|
+
* 候选携带 { tabId, address } **两个字段**,而不是只带 tabId:候选集合是点击那一刻的渲染
|
|
4523
|
+
* 快照,而真正调用 close() 之前可能已经跨过若干次 await(前一个候选的 close、宿主的提交)。
|
|
4524
|
+
* 宿主可以把一个已经释放的 tabId 回收给**另一个资源**——只按 tabId 执行就等于盲关别人的 tab。
|
|
4525
|
+
* 地址与 tabId 一起进候选,执行时才能用同一个地址做「这个 id 此刻仍然是我们要关的那个资源」
|
|
4526
|
+
* 的复核(见 handleSidebarBatchClose 与 sidebarTabPresenceInInventory 的 contentId 判据)。
|
|
3607
4527
|
*/
|
|
3608
4528
|
const sidebarBatchCandidates = (addresses, inventory) => {
|
|
3609
4529
|
const seen = new Set();
|
|
@@ -3621,7 +4541,7 @@
|
|
|
3621
4541
|
if (contentId === null || addresses.has(contentId) !== true) continue;
|
|
3622
4542
|
if (seen.has(tabId) === true) continue;
|
|
3623
4543
|
seen.add(tabId);
|
|
3624
|
-
candidates.push(tabId);
|
|
4544
|
+
candidates.push({ tabId, address: contentId });
|
|
3625
4545
|
} catch { continue; }
|
|
3626
4546
|
}
|
|
3627
4547
|
return candidates;
|
|
@@ -3654,9 +4574,17 @@
|
|
|
3654
4574
|
/**
|
|
3655
4575
|
* 两行批量状态的合并签名:只在候选集合真的变化时触发一次重渲染(空闲轮询绝不空转重渲染)。
|
|
3656
4576
|
* 两行必须一起进签名——只跟踪主代理行会让空闲分组的手动开/关 tab 迟迟不被反映。
|
|
4577
|
+
*
|
|
4578
|
+
* 候选是 { tabId, address }:签名必须把**两个字段**都编码进去。只取 tabId 会让「同一个 id 换了
|
|
4579
|
+
* 资源地址」这种真实变化被当成没变化(按钮计数不变,但该关的目标已经变了);直接 join 对象则退化
|
|
4580
|
+
* 成 "[object Object]"——两种都会让签名失去意义。分隔符用 NUL,与复合键同一个约定。
|
|
3657
4581
|
*/
|
|
3658
4582
|
const sidebarBatchSignatureOf = (runningState, idleState) => {
|
|
3659
|
-
const part = (state) => (state.kind === "close"
|
|
4583
|
+
const part = (state) => (state.kind === "close"
|
|
4584
|
+
? "close:" + state.candidates
|
|
4585
|
+
.map((candidate) => candidate.tabId + SIDEBAR_TAB_KEY_SEPARATOR + candidate.address)
|
|
4586
|
+
.join(",")
|
|
4587
|
+
: state.kind);
|
|
3660
4588
|
return part(runningState) + "|" + part(idleState);
|
|
3661
4589
|
};
|
|
3662
4590
|
|
|
@@ -3726,15 +4654,39 @@
|
|
|
3726
4654
|
* 再被后续同步当成「还没确认的打开」而重建关闭记录(用户明明已经收回了这个 tab)。因此这里
|
|
3727
4655
|
* 一并删除该 key 的 opening 记录;意图缺失时它是一次幂等空操作。
|
|
3728
4656
|
*/
|
|
3729
|
-
const cancelPendingSidebarSplit = (reason) => {
|
|
4657
|
+
const cancelPendingSidebarSplit = (reason, expectedIntentToken) => {
|
|
3730
4658
|
const intent = sidebarSplitIntentRef.current;
|
|
3731
4659
|
if (intent === null) return;
|
|
4660
|
+
/**
|
|
4661
|
+
* 可选的令牌闸门:显式传入令牌的调用方(关闭收口)必须与当前意图的**不可复用令牌**逐对象
|
|
4662
|
+
* 相等才允许取消;不传令牌的调用方(卸载、超时、动作被撤销、打开失败)保持既有语义——它们
|
|
4663
|
+
* 手里的意图就是它们此刻正在处理的那一份。null 是**有效**的期望值:它只可能来自「出发时根本
|
|
4664
|
+
* 没有意图」,此刻槽位里的任何意图都必然是后来者,一律不取消。
|
|
4665
|
+
*/
|
|
4666
|
+
if (expectedIntentToken !== undefined && intent.token !== expectedIntentToken) return;
|
|
3732
4667
|
sidebarSplitIntentRef.current = null;
|
|
3733
4668
|
// 意图里带着 key,收口范围因此精确到这一次点击,绝不误伤别的行的在途记录。
|
|
3734
4669
|
sidebarTabOpeningRef.current.delete(intent.key);
|
|
3735
4670
|
if (cancelSidebarSplit === null) return;
|
|
3736
4671
|
try { cancelSidebarSplit.call(config, intent.token, { reason }); } catch { /* 收口失败不能阻断面板同步。 */ }
|
|
3737
4672
|
};
|
|
4673
|
+
/**
|
|
4674
|
+
* 关闭收口专用的 split 事务取消:只有当前意图**仍然是这次关闭出发时看到的那一份**才允许取消。
|
|
4675
|
+
*
|
|
4676
|
+
* 特征判据必须是比较意图的**不可复用令牌**(每次 beginSidebarSplit 新建的对象身份),而不是
|
|
4677
|
+
* 只比 key:split 意图槽位在一个实例里只有一份,同一个 key 上的新一次打开会把它整份替换掉,
|
|
4678
|
+
* 旧 close 的迟到收口(尤其 verified-recycled)若按 key 取消,取消的就是新 generation 的
|
|
4679
|
+
* split/open 事务——右栏从临时 50% 掉回、新 pane 的打开失去归属,而那次打开与这次关闭毫无关系。
|
|
4680
|
+
*
|
|
4681
|
+
* 令牌为 null(出发时根本没有意图)时一律不取消:它只可能属于后来者。
|
|
4682
|
+
*/
|
|
4683
|
+
const cancelPendingSidebarSplitOfClose = (key, splitIntentToken) => {
|
|
4684
|
+
const intent = sidebarSplitIntentRef.current;
|
|
4685
|
+
if (intent === null || intent.key !== key) return;
|
|
4686
|
+
if (splitIntentToken === null || splitIntentToken === undefined) return;
|
|
4687
|
+
if (intent.token !== splitIntentToken) return;
|
|
4688
|
+
cancelPendingSidebarSplit("close", splitIntentToken);
|
|
4689
|
+
};
|
|
3738
4690
|
|
|
3739
4691
|
/**
|
|
3740
4692
|
* 只有 inventory 与 DOM 同时证明目标资源位于本次返回的 pane,才结束临时扩栏事务。
|
|
@@ -3783,8 +4735,26 @@
|
|
|
3783
4735
|
const openings = sidebarTabOpeningRef.current;
|
|
3784
4736
|
const now = Date.now();
|
|
3785
4737
|
const openingResolved = [];
|
|
3786
|
-
|
|
4738
|
+
/**
|
|
4739
|
+
* 初始收养的判据是「当前(sidebar session + root)还没有任何打开记录」,而不是全局
|
|
4740
|
+
* records.size:同一个 Panel 实例会按新的 props.scope 切换到另一个 root,前一个 root
|
|
4741
|
+
* 遗留的记录绝不能让当前 root 跳过这一步——否则宿主里已经存在的 tab 永远收不到记录,
|
|
4742
|
+
* Auto 也就再也认不出自己打开过的 tab(箭头停在 >>,资源结束后也不会自动关闭)。
|
|
4743
|
+
*
|
|
4744
|
+
* 记录键始终是(sidebar session + root + 地址)复合键,因此按 scope 收养不会覆盖或
|
|
4745
|
+
* 误伤别的 root 的记录。tabId 一律当场从当前 openTabs inventory 现读(见 recordSidebarTab),
|
|
4746
|
+
* 绝不跨重挂载缓存 tabId:宿主的 tabId 只由它自己那份 inventory 证明。
|
|
4747
|
+
*/
|
|
4748
|
+
let scopedRecordExists = false;
|
|
4749
|
+
for (const record of records.values()) {
|
|
4750
|
+
if (record.sessionId === sidebarSessionId && record.rootSessionId === rootSessionId) {
|
|
4751
|
+
scopedRecordExists = true;
|
|
4752
|
+
break;
|
|
4753
|
+
}
|
|
4754
|
+
}
|
|
4755
|
+
if (scopedRecordExists !== true) {
|
|
3787
4756
|
for (const resourceAddress of knownSidebarResourceAddresses()) {
|
|
4757
|
+
if (sidebarAdoptionEvidenceAvailable(resourceAddress) !== true) continue;
|
|
3788
4758
|
const key = sidebarTabKey(sidebarSessionId, rootSessionId, resourceAddress);
|
|
3789
4759
|
if (recordSidebarTab(key, resourceAddress)) openings.delete(key);
|
|
3790
4760
|
}
|
|
@@ -3863,14 +4833,37 @@
|
|
|
3863
4833
|
const inventory = readSidebarOpenTabs();
|
|
3864
4834
|
if (inventory === null) return { readable: false, tabId: null };
|
|
3865
4835
|
for (const entry of inventory) {
|
|
3866
|
-
|
|
3867
|
-
|
|
3868
|
-
|
|
3869
|
-
|
|
3870
|
-
|
|
4836
|
+
/**
|
|
4837
|
+
* 单条畸形条目(属性 getter 抛错)只跳过它自己:它既证明不了资源已打开,也不代表整份
|
|
4838
|
+
* inventory 不可读,因此绝不让它把异常抛到同步链路上、也绝不因此改变 readable 的语义。
|
|
4839
|
+
*/
|
|
4840
|
+
try {
|
|
4841
|
+
const candidate = object(entry);
|
|
4842
|
+
if (text(candidate.sessionId, null) !== sidebarSessionId) continue;
|
|
4843
|
+
if (text(candidate.kind, null) !== SUBAGENT_CHAT_KIND) continue;
|
|
4844
|
+
if (text(candidate.contentId, null) !== resourceAddress) continue;
|
|
4845
|
+
return { readable: true, tabId: text(candidate.tabId, null) };
|
|
4846
|
+
} catch { continue; }
|
|
3871
4847
|
}
|
|
3872
4848
|
return { readable: true, tabId: null };
|
|
3873
4849
|
};
|
|
4850
|
+
/**
|
|
4851
|
+
* 收养路径(面板重挂载 / 切换 root 后从宿主重建记录)的证据门槛。
|
|
4852
|
+
*
|
|
4853
|
+
* 收养没有「本次动作」这一上下文,而 recordSidebarTab 的 active() 兜底读面**不带 session**:
|
|
4854
|
+
* 同一个 root 的 child surface 是独立右栏,它自己的 active tab 不能证明当前 session 已经打开
|
|
4855
|
+
* 了这个资源。若在 inventory 可读时也接受兜底,新 Session 就会借用旧 Session 的 tabId(<< 指向
|
|
4856
|
+
* 别人的 tab,点击会关闭别的栏里的会话)。
|
|
4857
|
+
*
|
|
4858
|
+
* 因此:inventory 可读 ⇒ 必须由**当前 session** 的条目证明;只有 inventory 不可读(旧宿主 /
|
|
4859
|
+
* 读取抛错)才沿用 active() 这一唯一证据——那条路径的既有契约是「外部已存在的 tab 记为手动
|
|
4860
|
+
* 来源,Auto 既不接管也不关闭」(见 recordSidebarTab 与 Auto 的相关用例)。
|
|
4861
|
+
*/
|
|
4862
|
+
const sidebarAdoptionEvidenceAvailable = (resourceAddress) => {
|
|
4863
|
+
const state = sidebarResourceTabStateOf(resourceAddress);
|
|
4864
|
+
if (state.readable !== true) return true;
|
|
4865
|
+
return state.tabId !== null;
|
|
4866
|
+
};
|
|
3874
4867
|
/**
|
|
3875
4868
|
* active() 是否已经是这个资源(kind 与 contentId 同时匹配)。
|
|
3876
4869
|
*
|
|
@@ -3920,9 +4913,23 @@
|
|
|
3920
4913
|
// 只处理当前 surface 的记账:别的 session/root 的键在当前快照里无法判定,绝不越权操作。
|
|
3921
4914
|
if (entry.sessionId !== sidebarSessionId || entry.rootSessionId !== rootSessionId) continue;
|
|
3922
4915
|
if (running.has(entry.address) === true) {
|
|
3923
|
-
//
|
|
3924
|
-
|
|
4916
|
+
// 资源重新变成运行中:它已经开着就保持开着,重试预算、owner 身份与失败冷却一并清零。
|
|
4917
|
+
// **绝不**丢弃仍在验证中的关闭:那条链属于「已经发出的一次关闭」,它的收口(删记录、
|
|
4918
|
+
// 撤销来源 / 登记抑制)与重试预算无关;丢掉它会让 record 与箭头永久停在 <<。
|
|
4919
|
+
/**
|
|
4920
|
+
* 归属标记同源清理:只有在「这个 key 上确实有过一次关闭在途/预算消耗」时才清——那才是
|
|
4921
|
+
* 「资源又跑起来了,旧归属已经过期」的形状;普通的运行中 Auto tab(刚打开、没有任何关闭
|
|
4922
|
+
* 记账)绝不能被顺手清掉,否则一次刷新就会把它降级成 manual,正是本插件要修的漏收。
|
|
4923
|
+
* 清掉之后,下一次自动打开会重新打点(见 recordSidebarTab 的 auto-open 写入)。
|
|
4924
|
+
*/
|
|
4925
|
+
if (attempts.has(key) === true
|
|
4926
|
+
|| sidebarAutoCloseCooldownsRef.current.has(key) === true
|
|
4927
|
+
|| sidebarAutoCloseVerificationsRef.current.has(key) === true) {
|
|
4928
|
+
deleteSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, "resource-running");
|
|
4929
|
+
}
|
|
4930
|
+
clearAutoCloseBudget(key);
|
|
3925
4931
|
continue;
|
|
4932
|
+
|
|
3926
4933
|
}
|
|
3927
4934
|
const record = records.get(key);
|
|
3928
4935
|
const scopedRecord = record !== undefined
|
|
@@ -3936,19 +4943,94 @@
|
|
|
3936
4943
|
if (opening !== undefined && opening.sessionId === sidebarSessionId && opening.rootSessionId === rootSessionId) continue;
|
|
3937
4944
|
if (sidebarTabPendingRef.current.has(key) === true) continue;
|
|
3938
4945
|
origin.delete(key);
|
|
3939
|
-
|
|
4946
|
+
clearAutoCloseAttempt(key);
|
|
3940
4947
|
continue;
|
|
3941
4948
|
}
|
|
3942
4949
|
if (scopedRecord.origin !== SIDEBAR_TAB_ORIGIN_AUTO) {
|
|
3943
4950
|
// 记录已经被手动接管(用户手动打开或外部 tab):手动优先,撤销自动来源,绝不关闭它。
|
|
3944
4951
|
origin.delete(key);
|
|
3945
|
-
|
|
4952
|
+
clearAutoCloseAttempt(key);
|
|
4953
|
+
continue;
|
|
4954
|
+
}
|
|
4955
|
+
/**
|
|
4956
|
+
* 来源账本 ⇄ 记录 的 tabId 绑定闸门(与收养路径同一条判据,缺陷 1 的第二个消费点)。
|
|
4957
|
+
*
|
|
4958
|
+
* 这本账本是 realm 共享的,条目里的 tabId 是「Auto 打开/替换落地那一刻亲眼看到的 tab」。
|
|
4959
|
+
* 条目与记录指向同一个 tab 时它才证明这条关闭候选仍是我们自己开出来的那个 tab;一旦两者
|
|
4960
|
+
* 对不上(宿主重 mint 了新 id、而插件没有观察到那次替换),账本那条已经不能代表任何还在
|
|
4961
|
+
* 我们手里的 tab —— 按安全侧撤销这条自动来源,绝不按它关闭。
|
|
4962
|
+
*
|
|
4963
|
+
* 条目 tabId 为 null(这次自动打开已经发出、落地证据还没到)不触发本闸门:那种条目本身
|
|
4964
|
+
* 就不是归属证据,真正的判据在下一条(scopedRecord 的 tabId)与关闭 preflight 上。
|
|
4965
|
+
*/
|
|
4966
|
+
const boundAutoTabId = sidebarAutoOriginTabIdOf(entry);
|
|
4967
|
+
if (boundAutoTabId !== null && boundAutoTabId !== scopedRecord.tabId) {
|
|
4968
|
+
origin.delete(key);
|
|
4969
|
+
clearAutoCloseAttempt(key);
|
|
4970
|
+
continue;
|
|
4971
|
+
}
|
|
4972
|
+
/**
|
|
4973
|
+
* 同一个 tab 上已经有一次关闭在途(典型:旧 Panel 实例的 close Promise 还没结算,当前实例
|
|
4974
|
+
* 刚刚从宿主 inventory 收养了它):这一轮直接让位,绝不排队第二次关闭。
|
|
4975
|
+
*
|
|
4976
|
+
* 这里既不推进重试计数、也不撤销来源——那次关闭的成败由发起它的链路按成功路径结算;当前
|
|
4977
|
+
* 轮次只是「有人在关,别插手」。真正的执行点还会再确认一次(候选选择与执行之间隔着一次
|
|
4978
|
+
* 微任务跳转与一次可能的组件重挂载,见 handleSidebarAction)。
|
|
4979
|
+
*/
|
|
4980
|
+
if (sidebarTabCloseInFlight(scopedRecord.tabId) === true) continue;
|
|
4981
|
+
/**
|
|
4982
|
+
* 宿主的公开 inventory 明确读到这个 tabId 不在(absent),或已经被回收给**另一个资源**
|
|
4983
|
+
* (recycled:条目暴露的 contentId 与本 key 的资源地址不一致)——两者都必须先过
|
|
4984
|
+
* 「连续两次可读采样」的确认闸门,才允许收口这个 key 的归属:
|
|
4985
|
+
*
|
|
4986
|
+
* 单次缺项**不构成**「tab 已经不在」的证据。宿主 inventory 在这类时机短暂缺项是正常抖动
|
|
4987
|
+
* (布局换桶、面板重挂载、提交窗口的中间态),而单次 absent 就删掉 record / 来源 / 预算等于
|
|
4988
|
+
* 让一个仍然开着的 tab 永久脱离 Auto(正是用户报的「偶尔漏收」);单次 recycled 更是把一次
|
|
4989
|
+
* 读取抖动升格成「旧 tab 已消失」,会顺手清掉冷却与预算。记录同步器与关闭验证链都要求
|
|
4990
|
+
* SIDEBAR_TAB_DISAPPEAR_CONFIRMATIONS 次连续缺失,候选选择必须与它们同一条强度。
|
|
4991
|
+
*
|
|
4992
|
+
* 计数语义(见 sharedSidebarAutoTabMisses):
|
|
4993
|
+
* - present:计数清零,照旧继续走关闭路径;
|
|
4994
|
+
* - absent / recycled:累加连续计数,未达确认次数时**保留** record / 来源 / 预算 / 冷却,
|
|
4995
|
+
* 本轮既不关闭也不收口(下一轮可读采样继续确认);
|
|
4996
|
+
* - unreadable(旧宿主只有 active()):既不证明存在也不证明不存在,绝不推进计数——保持既有
|
|
4997
|
+
* 语义,仍按已确认记录发起关闭,由 closeSidebarTabWithLease 的 preflight fail-closed。
|
|
4998
|
+
*
|
|
4999
|
+
* 确认收口时两种证据的收口范围与旧实现逐字一致:absent 清预算(保留冷却),recycled 连冷却
|
|
5000
|
+
* 一起清(这个 key 的 tab 已经不存在,一条永远等不到自己 tab 的冷却只会白白屏蔽真实关闭)。
|
|
5001
|
+
* 别的 key 的记录不在本次收口范围内:每个 key 只按自己的地址与自己的 record 结算。
|
|
5002
|
+
*/
|
|
5003
|
+
const recordPresence = sidebarTabPresenceInInventory(scopedRecord.tabId, entry.address);
|
|
5004
|
+
const recordMissing = recordPresence === "absent" || recordPresence === "recycled";
|
|
5005
|
+
if (recordMissing === true) {
|
|
5006
|
+
// 还没到连续两次的确认次数:本轮保留 record / 来源 / 预算 / 冷却,既不关闭也不收口。
|
|
5007
|
+
if (sampleAutoTabMisses(key, scopedRecord.tabId, true) < SIDEBAR_TAB_DISAPPEAR_CONFIRMATIONS) continue;
|
|
5008
|
+
} else if (recordPresence === "present") {
|
|
5009
|
+
// 任一正向证据清零,与记录同步器「正向证据清零」逐字同源。
|
|
5010
|
+
sampleAutoTabMisses(key, scopedRecord.tabId, false);
|
|
5011
|
+
}
|
|
5012
|
+
// 落到这里的其余情况只有 unreadable:既不推进计数也不清零——读不到既不证明存在也不证明不存在,
|
|
5013
|
+
// 与关闭验证链同一条语义,随后仍按已确认记录走关闭路径(preflight 会 fail-closed)。
|
|
5014
|
+
if (recordPresence === "absent") {
|
|
5015
|
+
records.delete(key);
|
|
5016
|
+
origin.delete(key);
|
|
5017
|
+
clearAutoCloseAttempt(key);
|
|
5018
|
+
deleteSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, "inventory-absent");
|
|
5019
|
+
bump((value) => value + 1);
|
|
5020
|
+
continue;
|
|
5021
|
+
}
|
|
5022
|
+
if (recordPresence === "recycled") {
|
|
5023
|
+
records.delete(key);
|
|
5024
|
+
origin.delete(key);
|
|
5025
|
+
clearAutoCloseBudget(key);
|
|
5026
|
+
deleteSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, "tab-recycled");
|
|
5027
|
+
bump((value) => value + 1);
|
|
3946
5028
|
continue;
|
|
3947
5029
|
}
|
|
3948
5030
|
if (closeSidebarResource === null) {
|
|
3949
5031
|
// 宿主没有公开 close(旧宿主):撤销记账,绝不退化成别的关闭方式。
|
|
3950
5032
|
origin.delete(key);
|
|
3951
|
-
|
|
5033
|
+
clearAutoCloseAttempt(key);
|
|
3952
5034
|
continue;
|
|
3953
5035
|
}
|
|
3954
5036
|
if (sidebarTabPendingRef.current.has(key) === true) continue;
|
|
@@ -3956,74 +5038,773 @@
|
|
|
3956
5038
|
if (sidebarAutoFailedKeysRef.current.has(key) === true) continue;
|
|
3957
5039
|
// 用户刚刚在这个 key 上表达过手动意图:交给手动链路结算,Auto 本轮让位(手动恒优先)。
|
|
3958
5040
|
if (sidebarManualIntentOf(key) !== undefined) continue;
|
|
5041
|
+
// 上一次关闭请求还在验证中(租约被验证链持有):这一轮让位,绝不为同一个 key 再发一次 close。
|
|
5042
|
+
if (sidebarAutoCloseVerificationsRef.current.has(key) === true) continue;
|
|
5043
|
+
// 冷却慢车道:冷却期内零次 close 请求,origin / record 一律保留(绝不删除归属)。
|
|
5044
|
+
if (autoCloseCooldownActive(key) === true) continue;
|
|
5045
|
+
// 冷却到期:清空快速预算,允许一次新的真实 close(失败后再退避到下一档)。
|
|
5046
|
+
releaseExpiredAutoCloseCooldown(key);
|
|
3959
5047
|
const used = attempts.get(key) ?? 0;
|
|
3960
5048
|
if (used >= SIDEBAR_AUTO_CLOSE_MAX_ATTEMPTS) {
|
|
3961
|
-
//
|
|
3962
|
-
|
|
3963
|
-
|
|
5049
|
+
// 快速预算用尽:**保留 origin 与 record**,改为进入冷却慢车道(60 秒起指数退避)。
|
|
5050
|
+
// 绝不删除归属——删除就等于让一个仍然打开的 tab 永久脱离 Auto(「偶尔漏收」的症状)。
|
|
5051
|
+
enterAutoCloseCooldown(key);
|
|
3964
5052
|
continue;
|
|
3965
5053
|
}
|
|
3966
|
-
attempts.set(key, used + 1);
|
|
3967
|
-
// attemptsBefore 让「动作在真正调用 close 之前被撤销」的路径能精确回退这一次尝试计数,
|
|
3968
|
-
// 否则一次被取消的自动关闭就会白烧掉一次有界重试预算。
|
|
3969
|
-
return { key, address: entry.address, kind: "close", attemptsBefore: used };
|
|
3970
|
-
}
|
|
3971
|
-
return null;
|
|
3972
|
-
};
|
|
3973
|
-
const autoOpenCandidate = (running) => {
|
|
3974
|
-
// 能力降级 fail-closed:close()/落地证据/左箭头任一缺失时绝不自动打开(见 sidebarAutoOpenCapable)。
|
|
3975
|
-
if (sidebarAutoOpenCapable() !== true) return null;
|
|
3976
|
-
const origin = sidebarAutoOriginRef.current;
|
|
3977
|
-
const suppressed = sidebarAutoSuppressedRef.current;
|
|
3978
|
-
const reservations = sidebarAutoReservationRef.current;
|
|
3979
|
-
const records = sidebarTabRecordsRef.current;
|
|
3980
|
-
const openings = sidebarTabOpeningRef.current;
|
|
3981
|
-
for (const address of running) {
|
|
3982
|
-
const key = sidebarTabKey(sidebarSessionId, rootSessionId, address);
|
|
3983
|
-
// 本次级联里已经为它尝试过并失败:绝不在同一批微任务里重试(见 sidebarAutoFailedKeysRef)。
|
|
3984
|
-
if (sidebarAutoFailedKeysRef.current.has(key) === true) continue;
|
|
3985
|
-
// 用户手动关闭过:绝不立刻重开(抑制只由用户手动重新打开清除)。
|
|
3986
|
-
if (suppressed.has(key) === true) continue;
|
|
3987
|
-
// 本次运行已经为它成功发出过打开动作:绝不重复打开(与失败无关,失败会撤销预留)。
|
|
3988
|
-
if (origin.has(key) === true) continue;
|
|
3989
|
-
// 已经有一个候选为它预留:同一资源绝不并发两个动作。
|
|
3990
|
-
if (reservations.has(key) === true) continue;
|
|
3991
|
-
if (sidebarTabPendingRef.current.has(key) === true) continue;
|
|
3992
|
-
// 用户在同一个 key 上有未结算的手动意图:让手动链路先结算,Auto 本轮跳过。
|
|
3993
|
-
if (sidebarManualIntentOf(key) !== undefined) continue;
|
|
3994
|
-
const record = records.get(key);
|
|
3995
|
-
if (record !== undefined && record.sessionId === sidebarSessionId && record.rootSessionId === rootSessionId) continue;
|
|
3996
|
-
const opening = openings.get(key);
|
|
3997
|
-
if (opening !== undefined && opening.sessionId === sidebarSessionId && opening.rootSessionId === rootSessionId) continue;
|
|
3998
5054
|
/**
|
|
3999
|
-
*
|
|
4000
|
-
*
|
|
4001
|
-
*
|
|
4002
|
-
|
|
5055
|
+
* 每次候选都创建一份**不可复用**的身份令牌(对象身份,而不是可重复的计数或字符串),并
|
|
5056
|
+
* 登记进共享 owner 账本:这条预算现在归这一次动作。只有令牌仍然匹配的动作才允许回滚它,
|
|
5057
|
+
* 因此旧代次在副作用之前被撤销时绝不可能删掉/覆盖新代次已经预支的那一笔预算。
|
|
5058
|
+
*/
|
|
5059
|
+
const attemptToken = { key, attemptsBefore: used };
|
|
5060
|
+
attempts.set(key, used + 1);
|
|
5061
|
+
sidebarAutoCloseAttemptOwnersRef.current.set(key, attemptToken);
|
|
5062
|
+
// 与来源 / 抑制两个集合同一把安全阀:复合键跨 root 保留,计数绝不能随长生命周期无界增长。
|
|
5063
|
+
// owner 账本与它同序写入,因此用同一个上限、同一套淘汰规则(绝不新增无界 Map)。
|
|
5064
|
+
trimAutoKeyMap(attempts, true);
|
|
5065
|
+
trimAutoKeyMap(sidebarAutoCloseAttemptOwnersRef.current, true);
|
|
5066
|
+
// attemptsBefore 让「动作在真正调用 close 之前被撤销」的路径能精确回退这一次尝试计数,
|
|
5067
|
+
// 否则一次被取消的自动关闭就会白烧掉一次有界重试预算;attemptToken 是回滚的**所有权凭据**,
|
|
5068
|
+
// 必须随 autoContext 一路带到每个可能回滚的分支(见 handleSidebarAction)。
|
|
5069
|
+
return { key, address: entry.address, kind: "close", attemptsBefore: used, attemptToken };
|
|
5070
|
+
}
|
|
5071
|
+
return null;
|
|
5072
|
+
};
|
|
5073
|
+
const autoOpenCandidate = (running) => {
|
|
5074
|
+
// 能力降级 fail-closed:close()/落地证据/左箭头任一缺失时绝不自动打开(见 sidebarAutoOpenCapable)。
|
|
5075
|
+
if (sidebarAutoOpenCapable() !== true) return null;
|
|
5076
|
+
const origin = sidebarAutoOriginRef.current;
|
|
5077
|
+
const suppressed = sidebarAutoSuppressedRef.current;
|
|
5078
|
+
const reservations = sidebarAutoReservationRef.current;
|
|
5079
|
+
const records = sidebarTabRecordsRef.current;
|
|
5080
|
+
const openings = sidebarTabOpeningRef.current;
|
|
5081
|
+
for (const address of running) {
|
|
5082
|
+
const key = sidebarTabKey(sidebarSessionId, rootSessionId, address);
|
|
5083
|
+
// 本次级联里已经为它尝试过并失败:绝不在同一批微任务里重试(见 sidebarAutoFailedKeysRef)。
|
|
5084
|
+
if (sidebarAutoFailedKeysRef.current.has(key) === true) continue;
|
|
5085
|
+
// 用户手动关闭过:绝不立刻重开(抑制只由用户手动重新打开,或资源明确空闲后的清点清除)。
|
|
5086
|
+
if (suppressed.has(key) === true) continue;
|
|
5087
|
+
/**
|
|
5088
|
+
* 持久 manual 抑制(跨整页刷新):内存里的 suppressed 在刷新之后是空的,但用户的关闭意图
|
|
5089
|
+
* 落在持久条目上(见 SIDEBAR_AUTO_OWNERSHIP_KEY)——manual 恒优先,这里必须与内存抑制同强度
|
|
5090
|
+
* 地跳过这个地址。少了这一步,「资源仍在运行 + 用户已手动关闭该 tab + 刷新」会被 Auto
|
|
5091
|
+
* 重新打开(P1-B)。
|
|
5092
|
+
*
|
|
5093
|
+
* 抑制的清除时机**只**由资源状态决定:观察到这个地址明确空闲(ready)时清除(见
|
|
5094
|
+
* clearManualSuppressionOfIdleResources)。因此刷新时正在运行、用户已关闭的 tab 不会被重开,
|
|
5095
|
+
* 而子代理真正结束之后标记消失,下一次运行仍能正常自动打开。
|
|
5096
|
+
*
|
|
5097
|
+
* 读面走 quiet 通道:这条判据每轮同步都会执行,结论由下面那条决策诊断承担。
|
|
5098
|
+
*/
|
|
5099
|
+
const persistedForOpen = readSidebarAutoOwnershipEntry(sidebarSessionId, rootSessionId, address, { quiet: true });
|
|
5100
|
+
if (persistedForOpen !== null && persistedForOpen.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL) {
|
|
5101
|
+
recordSidebarAutoDecision("open", { key, kind: "open" }, "skip", "persisted-manual");
|
|
5102
|
+
continue;
|
|
5103
|
+
}
|
|
5104
|
+
// 本次运行已经为它成功发出过打开动作:绝不重复打开(与失败无关,失败会撤销预留)。
|
|
5105
|
+
if (origin.has(key) === true) continue;
|
|
5106
|
+
/**
|
|
5107
|
+
* 容量 fail-closed:内存账本或持久表装不下这条新 owner 时**不打开**(记 owner-capacity
|
|
5108
|
+
* 诊断)。绝不为了腾位淘汰别的 scope 仍然有效的 owner——到达上限是可用性代价而不是错误:
|
|
5109
|
+
* 用户仍然可以手动打开这个资源(手动打开照常写 manual 归属)。
|
|
5110
|
+
*/
|
|
5111
|
+
if (autoSidebarOwnershipHasCapacity(key, address) !== true) {
|
|
5112
|
+
recordSidebarAutoDecision("open", { key, kind: "open" }, "skip", "owner-capacity");
|
|
5113
|
+
continue;
|
|
5114
|
+
}
|
|
5115
|
+
// 已经有一个候选为它预留:同一资源绝不并发两个动作。
|
|
5116
|
+
if (reservations.has(key) === true) continue;
|
|
5117
|
+
if (sidebarTabPendingRef.current.has(key) === true) continue;
|
|
5118
|
+
// 用户在同一个 key 上有未结算的手动意图:让手动链路先结算,Auto 本轮跳过。
|
|
5119
|
+
if (sidebarManualIntentOf(key) !== undefined) continue;
|
|
5120
|
+
const record = records.get(key);
|
|
5121
|
+
if (record !== undefined && record.sessionId === sidebarSessionId && record.rootSessionId === rootSessionId) continue;
|
|
5122
|
+
const opening = openings.get(key);
|
|
5123
|
+
if (opening !== undefined && opening.sessionId === sidebarSessionId && opening.rootSessionId === rootSessionId) continue;
|
|
5124
|
+
/**
|
|
5125
|
+
* 存在性检查必须「先可读、再确认没有」:
|
|
5126
|
+
* - inventory 不可读时无法证明资源没打开,fail-closed 跳过这个候选(宁可不动,也不开出重复页);
|
|
5127
|
+
* - inventory 可读但没有该地址、而 active() 已经是它(提交延迟 / 别的 pane):同样视为已经存在
|
|
5128
|
+
* 的手动/未知来源,不重复打开,也不写 auto 来源。
|
|
5129
|
+
*/
|
|
5130
|
+
const state = sidebarResourceTabStateOf(address);
|
|
5131
|
+
if (state.readable !== true) continue;
|
|
5132
|
+
if (state.tabId !== null) continue;
|
|
5133
|
+
if (sidebarActiveResourceMatches(address) === true) continue;
|
|
5134
|
+
/**
|
|
5135
|
+
* 先写**预留**再发动作:任何重入(observer/轮询/尾随同步)都不会为同一个资源再选一次。
|
|
5136
|
+
* 预留只是候选去重,绝不等于「Auto 已经打开」——只有 openResource 真的成功发出后才会
|
|
5137
|
+
* 升级成来源标记;失败路径在 handleSidebarAction 的 finally 里撤销它,使后续同步可以重试。
|
|
5138
|
+
*/
|
|
5139
|
+
const epoch = sidebarAutoEpochRef.current;
|
|
5140
|
+
reservations.set(key, { sessionId: sidebarSessionId, rootSessionId, address, epoch });
|
|
5141
|
+
trimAutoKeyMap(reservations);
|
|
5142
|
+
return { key, address, kind: "open", epoch };
|
|
5143
|
+
}
|
|
5144
|
+
return null;
|
|
5145
|
+
};
|
|
5146
|
+
/**
|
|
5147
|
+
* 上限淘汰(复合键跨 root 保留时的安全阀,见 SIDEBAR_AUTO_KEY_LIMIT)。
|
|
5148
|
+
*
|
|
5149
|
+
* activeAware = true 时优先淘汰「没有当前 record / 没有在途动作 / 没有验证 / 没有冷却」的历史条目;
|
|
5150
|
+
* 若 128 项全是活动条目,则**什么都不淘汰**(fail-closed)。false 保持既有语义(按插入顺序丢最旧)。
|
|
5151
|
+
*
|
|
5152
|
+
* 注意(缺陷 2):这里调用 sidebarAutoCloseKeyIsActive 判「活动」,而它读的是**当前这个 Panel
|
|
5153
|
+
* 实例**的在途状态与**当前 scope**的 record。因此这套淘汰只允许用在「条目重新出现时会自行重建」
|
|
5154
|
+
* 的记账上(重试预算 / owner 令牌 / 冷却 / 抑制)。**归属账本不复用它**:那种判据会把别的
|
|
5155
|
+
* root 仍然有效的 Auto owner 判成 inactive 淘汰掉(内存),那个 tab 从此永久脱离 Auto——
|
|
5156
|
+
* 归属容量改由 autoOpenCandidate 在发出 openResource 之前 fail-closed 拒绝(不淘汰任何人),
|
|
5157
|
+
* 见 autoSidebarOwnershipHasCapacity。
|
|
5158
|
+
*/
|
|
5159
|
+
const trimAutoKeyMap = (map, activeAware) => {
|
|
5160
|
+
while (map.size > SIDEBAR_AUTO_KEY_LIMIT) {
|
|
5161
|
+
let victim = null;
|
|
5162
|
+
for (const candidate of map.keys()) {
|
|
5163
|
+
if (activeAware !== true || sidebarAutoCloseKeyIsActive(candidate) !== true) {
|
|
5164
|
+
victim = candidate;
|
|
5165
|
+
break;
|
|
5166
|
+
}
|
|
5167
|
+
}
|
|
5168
|
+
if (victim === null) break;
|
|
5169
|
+
map.delete(victim);
|
|
5170
|
+
}
|
|
5171
|
+
};
|
|
5172
|
+
/**
|
|
5173
|
+
* 这个 key 现在是否还有「活动的 Auto 关闭记账」。
|
|
5174
|
+
*
|
|
5175
|
+
* 判据(任一成立即活动):仍在途的打开记录 / 预留 / pending 动作 / 关闭验证 / 失败冷却 / 当前 scope
|
|
5176
|
+
* 下仍有精确 record。限容淘汰与「快照缺项」清理都必须给这些 key 让位——它们仍然可能被精确关闭。
|
|
5177
|
+
*/
|
|
5178
|
+
const sidebarAutoCloseKeyIsActive = (key) => {
|
|
5179
|
+
if (sidebarTabPendingRef.current.has(key) === true) return true;
|
|
5180
|
+
if (sidebarTabOpeningRef.current.has(key) === true) return true;
|
|
5181
|
+
if (sidebarAutoReservationRef.current.has(key) === true) return true;
|
|
5182
|
+
if (sidebarAutoCloseVerificationsRef.current.has(key) === true) return true;
|
|
5183
|
+
if (sidebarAutoCloseCooldownsRef.current.has(key) === true) return true;
|
|
5184
|
+
const record = sidebarTabRecordsRef.current.get(key);
|
|
5185
|
+
return record !== undefined
|
|
5186
|
+
&& record.sessionId === sidebarSessionId
|
|
5187
|
+
&& record.rootSessionId === rootSessionId;
|
|
5188
|
+
};
|
|
5189
|
+
/** 清空一个 key 的失败冷却与重试预算(verified-closed / 手动接管 / 资源重新运行共用)。 */
|
|
5190
|
+
const clearAutoCloseBudget = (key) => {
|
|
5191
|
+
clearAutoCloseAttempt(key);
|
|
5192
|
+
sidebarAutoCloseCooldownsRef.current.delete(key);
|
|
5193
|
+
};
|
|
5194
|
+
/** 进入冷却慢车道:60 秒起指数退避、上限 15 分钟;origin / record 一律保留。 */
|
|
5195
|
+
const enterAutoCloseCooldown = (key) => {
|
|
5196
|
+
const cooldowns = sidebarAutoCloseCooldownsRef.current;
|
|
5197
|
+
const previous = cooldowns.get(key);
|
|
5198
|
+
const step = previous === undefined ? 0 : Math.min(previous.step + 1, 4);
|
|
5199
|
+
const delay = Math.min(SIDEBAR_AUTO_CLOSE_COOLDOWN_BASE_MS * (2 ** step), SIDEBAR_AUTO_CLOSE_COOLDOWN_MAX_MS);
|
|
5200
|
+
cooldowns.set(key, { step, until: Date.now() + delay });
|
|
5201
|
+
trimAutoKeyMap(cooldowns, true);
|
|
5202
|
+
};
|
|
5203
|
+
/** 冷却是否仍在生效:生效期内同一个 key 零次 close 请求。 */
|
|
5204
|
+
const autoCloseCooldownActive = (key) => {
|
|
5205
|
+
const entry = sidebarAutoCloseCooldownsRef.current.get(key);
|
|
5206
|
+
return entry !== undefined && entry.until > Date.now();
|
|
5207
|
+
};
|
|
5208
|
+
/** 冷却到期:清空快速预算,让这个 key 重新进入快速车道(失败后由 enterAutoCloseCooldown 退避到下一档)。 */
|
|
5209
|
+
const releaseExpiredAutoCloseCooldown = (key) => {
|
|
5210
|
+
const cooldowns = sidebarAutoCloseCooldownsRef.current;
|
|
5211
|
+
const entry = cooldowns.get(key);
|
|
5212
|
+
if (entry === undefined || entry.until > Date.now()) return;
|
|
5213
|
+
clearAutoCloseAttempt(key);
|
|
5214
|
+
};
|
|
5215
|
+
/**
|
|
5216
|
+
* 新 owner 能不能被**内存账本 + 持久表**同时保留(fail-closed 容量判据,缺陷 2)。
|
|
5217
|
+
*
|
|
5218
|
+
* 判据刻意与当前面板的局部状态无关:内存账本只回答「还装得下吗」(size < 上限),持久表由
|
|
5219
|
+
* sidebarOwnershipAcceptsNewAuto 回答(写入之后 auto 条目数不越过上限)。**绝不**再看
|
|
5220
|
+
* 「这个 key 在别的 scope 里是否活动」来决定谁可以被淘汰:
|
|
5221
|
+
*
|
|
5222
|
+
* - 旧实现在这里扫描整本 origin,用 sidebarAutoCloseKeyIsActive(它读的是**当前这个实例**的
|
|
5223
|
+
* pending / opening / reservation / verification / cooldown 与**当前 scope**的 record)挑一个
|
|
5224
|
+
* 「不活动」的条目当可淘汰对象。别的 root / sidebar session 的条目在当前实例里天然「不活动」,
|
|
5225
|
+
* 于是 B scope 打开 128 个资源就能把 A scope 仍然有效的 owner 判成 inactive 淘汰掉——A 那个
|
|
5226
|
+
* tab 从此永久脱离 Auto(自动关闭只遍历这本账本,刷新也不能恢复)。
|
|
5227
|
+
* - 换成纯 LRU 同样不安全:淘汰依据只是「更旧」,而被淘汰的条目完全可能仍然对应一个打开的 tab。
|
|
5228
|
+
*
|
|
5229
|
+
* 因此到达上限时唯一的动作是**不开**(记录 owner-capacity 诊断,见 autoOpenCandidate):
|
|
5230
|
+
* 不打开只是可用性代价(用户仍可手动打开,手动打开照常写 manual 归属),而误淘汰是永久漏收。
|
|
5231
|
+
* owner 释放(verified-closed / inventory-absent / tab-recycled / 资源重新运行等既有收口)之后,
|
|
5232
|
+
* 新的自动打开自动恢复正常。
|
|
5233
|
+
*/
|
|
5234
|
+
const autoSidebarOwnershipHasCapacity = (key, address) => {
|
|
5235
|
+
const origin = sidebarAutoOriginRef.current;
|
|
5236
|
+
if (origin.has(key) !== true && origin.size >= SIDEBAR_AUTO_KEY_LIMIT) return false;
|
|
5237
|
+
return sidebarOwnershipAcceptsNewAuto(sidebarSessionId, rootSessionId, address);
|
|
5238
|
+
};
|
|
5239
|
+
/**
|
|
5240
|
+
* 无条件收口一个 key 的共享自动关闭记账(重试预算 + owner 身份)。
|
|
5241
|
+
*
|
|
5242
|
+
* 只用于「这个 key 的预算整体不再需要」的路径:资源重新变成运行中、记录消失或被手动接管、
|
|
5243
|
+
* inventory 已证明 tab 不在、宿主没有公开 close、有界重试用尽、成功关闭后的收口与清理阶段。
|
|
5244
|
+
* 预算与 owner 必须同生共死:只删预算而留下 owner,会让旧令牌在**下一次**预支之后仍被误判成
|
|
5245
|
+
* 所有者;只删 owner 而留下预算,则旧令牌只能 fail-safe 地放弃回滚(白烧一次预算,但有界性
|
|
5246
|
+
* 不受影响)。两者一起删,语义最直白。
|
|
5247
|
+
*/
|
|
5248
|
+
const clearAutoCloseAttempt = (key) => {
|
|
5249
|
+
sidebarAutoCloseAttemptsRef.current.delete(key);
|
|
5250
|
+
sidebarAutoCloseAttemptOwnersRef.current.delete(key);
|
|
5251
|
+
// 候选采样计数与这条预算同生共死:预算整体不再需要时,采样序列也一并作废,绝不跨代残留。
|
|
5252
|
+
sidebarAutoTabMissesRef.current.delete(key);
|
|
5253
|
+
};
|
|
5254
|
+
/**
|
|
5255
|
+
* 候选选择阶段的「这个 tab 连续不在场」计数(见 sharedSidebarAutoTabMisses)。
|
|
5256
|
+
*
|
|
5257
|
+
* 只有计数记录里的 tabId 与当前 record 的 tabId 一致时才有效:宿主为同一个 key 重新分配了
|
|
5258
|
+
* tabId(旧 tab 消失、同一个资源换成新 tab)之后,旧计数绝不能计入新一代的确认。
|
|
5259
|
+
*/
|
|
5260
|
+
const autoTabMissesOf = (key, tabId) => {
|
|
5261
|
+
const entry = sidebarAutoTabMissesRef.current.get(key);
|
|
5262
|
+
if (entry === undefined || entry.tabId !== tabId) return 0;
|
|
5263
|
+
return Number.isFinite(entry.misses) ? entry.misses : 0;
|
|
5264
|
+
};
|
|
5265
|
+
/**
|
|
5266
|
+
* 记一次候选采样结果,返回这个 tabId 的连续不在场次数。
|
|
5267
|
+
*
|
|
5268
|
+
* present(missing !== true)一律清零,与记录同步器「任一正向证据清零」逐字同源;absent 与
|
|
5269
|
+
* recycled 共用同一条连续计数(两者都独立证明「这个 tabId 已经不再承载我们的资源」)。
|
|
5270
|
+
* unreadable 的采样绝不走到这里——读不到既不证明存在也不证明不存在,绝不推进计数。
|
|
5271
|
+
*/
|
|
5272
|
+
const sampleAutoTabMisses = (key, tabId, missing) => {
|
|
5273
|
+
const map = sidebarAutoTabMissesRef.current;
|
|
5274
|
+
// 先读旧计数(只有同一个 tabId 才有效),再摘掉旧条目:两步都不能省(见下面的 LRU 说明)。
|
|
5275
|
+
const previousMisses = autoTabMissesOf(key, tabId);
|
|
5276
|
+
map.delete(key);
|
|
5277
|
+
// present:清零就是「条目保持删除状态」,与记录同步器「任一正向证据清零」逐字同源。
|
|
5278
|
+
if (missing !== true) return 0;
|
|
5279
|
+
const misses = previousMisses + 1;
|
|
5280
|
+
map.set(key, { sessionId: sidebarSessionId, rootSessionId, tabId, misses });
|
|
5281
|
+
/**
|
|
5282
|
+
* 次序即 LRU:Map 对已存在的键 set 不会改变插入位置,因此上面先 delete 再 set,让这次采样把这
|
|
5283
|
+
* 个 key 刷到队尾;淘汰也只按「最后一次采样有多旧」进行(见 trimSharedSidebarAutoTabMisses)。
|
|
5284
|
+
* 与其它 Auto 账本同一个 SIDEBAR_AUTO_KEY_LIMIT 上限:候选采样计数绝不成为第二个无界 Map。
|
|
5285
|
+
*/
|
|
5286
|
+
trimSharedSidebarAutoTabMisses();
|
|
5287
|
+
return misses;
|
|
5288
|
+
};
|
|
5289
|
+
/**
|
|
5290
|
+
* 一次「已经真的关掉」的结算后的预算收口(成功关闭 / 已证明 tab 消失)。
|
|
5291
|
+
*
|
|
5292
|
+
* - 手动动作(autoContext === null):手动恒优先,直接清空这个 key 的预算与 owner;
|
|
5293
|
+
* - 自动关闭动作:只有 owner 仍是本次动作的令牌时才清空。旧代次的迟到结算绝不碰后来者的预算——
|
|
5294
|
+
* 它可能已经在同一个 key 上重新预支了一笔,清零就等于把 3 次上限又还给它;
|
|
5295
|
+
* - 自动打开动作(没有 close 令牌,却因为期间出现了记录而走到关闭):只要这个 key 上已经存在
|
|
5296
|
+
* 任何更新的 owner,就同样不清零——令牌不属于本次动作,那笔预算就与它无关。
|
|
5297
|
+
*/
|
|
5298
|
+
const settleAutoCloseAttempt = (key, context) => {
|
|
5299
|
+
if (context !== null && context !== undefined) {
|
|
5300
|
+
const owners = sidebarAutoCloseAttemptOwnersRef.current;
|
|
5301
|
+
if (context.kind === "close") {
|
|
5302
|
+
if (owners.get(key) !== context.attemptToken) return;
|
|
5303
|
+
} else if (owners.has(key) === true) {
|
|
5304
|
+
return;
|
|
5305
|
+
}
|
|
5306
|
+
}
|
|
5307
|
+
clearAutoCloseAttempt(key);
|
|
5308
|
+
};
|
|
5309
|
+
/**
|
|
5310
|
+
* 当前 surface 下某个宿主 tabId 的关闭锁身份(见 sharedSidebarTabCloseInFlight)。
|
|
5311
|
+
*
|
|
5312
|
+
* session / root 都取**当前渲染**的值:旧实例的迟到收尾用它自己那一轮的 surface 身份归还锁,
|
|
5313
|
+
* 因此绝不会误删新实例(或别的 root / session)持有的那一把。
|
|
5314
|
+
*/
|
|
5315
|
+
const sidebarTabCloseKeyOf = (tabId) => sidebarTabCloseKey(sidebarSessionId, rootSessionId, tabId);
|
|
5316
|
+
/** 当前 surface 下一个 tabId 的在途关闭租约(没有在途关闭时返回 null)。 */
|
|
5317
|
+
const sidebarTabCloseLeaseOf = (tabId) => sharedSidebarTabCloseInFlight.get(sidebarTabCloseKeyOf(tabId)) ?? null;
|
|
5318
|
+
/**
|
|
5319
|
+
* 这个 tab 当前是否有一次关闭在途。
|
|
5320
|
+
*
|
|
5321
|
+
* 只读探测,供候选选择阶段提前让位:不为一个已经在关的 tab 预支一次有界重试预算,也不把它
|
|
5322
|
+
* 记成「尝试失败」(真正的执行点还会在调用宿主 close 之前再确认一次,见 handleSidebarAction)。
|
|
5323
|
+
*/
|
|
5324
|
+
const sidebarTabCloseInFlight = (tabId) => sidebarTabCloseLeaseOf(tabId) !== null;
|
|
5325
|
+
/**
|
|
5326
|
+
* 取得一个 tab 的关闭权(fail-closed):已经有一次关闭在途时返回 null,调用方按各自的并发语义
|
|
5327
|
+
* 决定「等待它结算」还是「直接让位」。
|
|
5328
|
+
*
|
|
5329
|
+
* 租约不是无结果的 token,而是一份**可结算的信号**:token.ok 记录那一次关闭的**验证结果**
|
|
5330
|
+
* (true = inventory 连续两次读不到这个精确 tabId,verified-closed;false = 失败 / 超时 / 未验证),
|
|
5331
|
+
* token.wait() 让竞争者等到结算再决定下一步——上次已验证关闭就不必再 close,上次未验证才用当前
|
|
5332
|
+
* inventory 证明同一个 tabId 仍在之后做一次有限重试。宿主 Promise 的 resolve 绝不直接置 ok=true:
|
|
5333
|
+
* 它只把租约推进到 verifying,真正的结算由验证链或 watchdog 完成。
|
|
5334
|
+
*
|
|
5335
|
+
* 返回的 release 只在「Map 里仍然是本次 token」时才删除,因此旧实例的迟到收尾绝不会删掉新实例
|
|
5336
|
+
* (或后来者)持有的锁;release 只归还这一个身份,不触碰任何 Panel 状态(绝不改另一个实例的
|
|
5337
|
+
* pending / records / 来源账本)。调用方必须把它放进 finally:同步 throw、Promise reject、组件
|
|
5338
|
+
* 卸载后迟到的续体都走同一条归还路径,锁绝不留到下一次动作。
|
|
5339
|
+
*/
|
|
5340
|
+
const acquireSidebarTabClose = (tabId) => {
|
|
5341
|
+
const key = sidebarTabCloseKeyOf(tabId);
|
|
5342
|
+
if (sharedSidebarTabCloseInFlight.has(key) === true) return null;
|
|
5343
|
+
let settleWaiters = null;
|
|
5344
|
+
const settled = new Promise((resolve) => { settleWaiters = resolve; });
|
|
5345
|
+
const token = {
|
|
5346
|
+
key,
|
|
5347
|
+
/**
|
|
5348
|
+
* 结算原因:null = 尚未结算;"closed" = 这次 close 已被 inventory 验证为关闭(或缺席);
|
|
5349
|
+
* "recycled" = 这次 close 的依据是「这个 tabId 已被宿主回收给另一个资源」(旧 tab 已消失,
|
|
5350
|
+
* close 一次都没有发出);"failed" = 失败 / 未验证 / 让位;"timeout" = watchdog 或验证窗口超时。
|
|
5351
|
+
* 宿主 Promise 的 resolve **绝不**直接把结果置成 "closed"(resolve 只代表请求完成)。
|
|
5352
|
+
*/
|
|
5353
|
+
result: null,
|
|
5354
|
+
/**
|
|
5355
|
+
* 结算结果的布尔投影(仅 "closed" 为 true),保留给「只关心关没关」的读取点。
|
|
5356
|
+
*
|
|
5357
|
+
* 竞争方**不得**只看它:跨 key 交错时(A 的「旧 tab 已消失」与 T 自己的关闭落在同一个
|
|
5358
|
+
* tabId 上)布尔值分不清「谁证明的、凭什么证明的」。等待者必须读 result,并用自己的
|
|
5359
|
+
* 期望地址重新探针复核之后再决定(见 closeSidebarTabWithLease 的等待分支)。
|
|
5360
|
+
*/
|
|
5361
|
+
ok: null,
|
|
5362
|
+
settled: false,
|
|
5363
|
+
/** 租约状态:in-flight(请求已发出)→ verifying(等待 inventory 验证)/ quarantined(超时隔离窗)。 */
|
|
5364
|
+
state: "in-flight",
|
|
5365
|
+
/** 验证窗口或迟到隔离窗的截止时间(虚拟时间;0 = 未设置)。 */
|
|
5366
|
+
holdUntil: 0,
|
|
5367
|
+
/** 等待这次关闭结算(永不 reject:结果通过 token.result / token.ok 读取)。 */
|
|
5368
|
+
wait: () => settled,
|
|
5369
|
+
/** 结算入口的同一份实现(同步链路需要从 map 里归还隔离窗到期的租约,见 verifyPendingSidebarCloses)。 */
|
|
5370
|
+
release: null,
|
|
5371
|
+
};
|
|
5372
|
+
sharedSidebarTabCloseInFlight.set(key, token);
|
|
5373
|
+
let released = false;
|
|
5374
|
+
/**
|
|
5375
|
+
* 结算并归还租约。outcome 是**原因**(四值,见 SIDEBAR_TAB_CLOSE_SETTLE_REASONS),布尔写法保留
|
|
5376
|
+
* 兼容:true ⇒ "closed"、false ⇒ "failed"。先写结果再唤醒等待者(等待者读到的一定是这次关闭的
|
|
5377
|
+
* 原因,而不是「锁空了」),最后只在 Map 里仍然是自己这个 token 时才删除——旧实例的迟到收尾
|
|
5378
|
+
* 绝不移除后来者的租约。
|
|
5379
|
+
*/
|
|
5380
|
+
const release = (outcome) => {
|
|
5381
|
+
if (released === true) return;
|
|
5382
|
+
released = true;
|
|
5383
|
+
const reason = closeSettleReason(outcome);
|
|
5384
|
+
token.result = reason;
|
|
5385
|
+
token.ok = reason === "closed";
|
|
5386
|
+
token.settled = true;
|
|
5387
|
+
const resolve = settleWaiters;
|
|
5388
|
+
settleWaiters = null;
|
|
5389
|
+
if (resolve !== null) resolve(reason);
|
|
5390
|
+
if (sharedSidebarTabCloseInFlight.get(key) === token) sharedSidebarTabCloseInFlight.delete(key);
|
|
5391
|
+
};
|
|
5392
|
+
token.release = release;
|
|
5393
|
+
return {
|
|
5394
|
+
token,
|
|
5395
|
+
/** 保留租约到 holdUntil:期间候选选择一律让位(绝不重复 close),迟到结果也没有机会重叠。 */
|
|
5396
|
+
hold(state, holdUntil) {
|
|
5397
|
+
if (released === true) return;
|
|
5398
|
+
token.state = state;
|
|
5399
|
+
token.holdUntil = holdUntil;
|
|
5400
|
+
},
|
|
5401
|
+
/**
|
|
5402
|
+
* 结算并归还:先写结果再唤醒等待者(等待者读到的一定是这次关闭的结果,而不是「锁空了」),
|
|
5403
|
+
* 最后只在 Map 里仍然是自己这个 token 时才删除——旧实例的迟到收尾绝不移除后来者的租约。
|
|
5404
|
+
* ok 只有在 inventory 验证为关闭(verified-closed)时才为 true。
|
|
5405
|
+
*/
|
|
5406
|
+
release,
|
|
5407
|
+
};
|
|
5408
|
+
};
|
|
5409
|
+
/**
|
|
5410
|
+
* 当前 inventory 里这个**精确 tabId** 的在场证据(必须属于当前 sidebar session,且仍是本插件的
|
|
5411
|
+
* 子代理会话 kind)。四态返回,因为「读不到」「确认没有」与「这个 id 已经换了资源」必须分开:
|
|
5412
|
+
* - "present":命中同一个 (session, kind, tabId),且条目若暴露了资源地址就与期望地址逐字一致
|
|
5413
|
+
* → 可以安全地再发一次 close;
|
|
5414
|
+
* - "absent":这个 tab 已经离开宿主,绝不再 close(用户的关闭意图已经达成);
|
|
5415
|
+
* - "recycled":tabId 还在,但它此刻承载的是**另一个资源**的地址——旧 tab 已经消失、宿主把这个
|
|
5416
|
+
* id 回收给了别的资源。绝不对这个 id 发 close(那会关掉别人的 tab),只按「旧 tab 已消失」
|
|
5417
|
+
* 收口自己这个 key 的记账;
|
|
5418
|
+
* - "unreadable":证明不了任何事 → fail-closed,绝不按 active tab 猜一个 id 去关。
|
|
5419
|
+
*
|
|
5420
|
+
* expectedAddress 是可选的第二个判据(调用方拿得到这个 key 的资源地址时才传):
|
|
5421
|
+
* 地址判据**只在条目真的暴露了可读的非空 contentId 时才生效**——条目缺 contentId、值为空串或
|
|
5422
|
+
* 类型不可读(getter 抛错被跳过)都**不构成任何 mismatch 证据**,一律退回 present(这是本轮
|
|
5423
|
+
* 刻意的 fail-open 取舍,必须保留)。绝不能用可能系统性缺失的字段推断「id 被复用」,那会退化成
|
|
5424
|
+
* 永远不关闭:只要宿主某一版 inventory 结构性缺 contentId,本插件的每一次关闭都会在 preflight
|
|
5425
|
+
* 被判定成 recycled,一个 tab 也关不掉(用户可见的**永久漏收**),比下面的残余风险更糟。
|
|
5426
|
+
*
|
|
5427
|
+
* **残余风险(本轮已知、未消除)**:contentId 缺失 ⇒ 无法区分「这个 tabId 仍是我们的 tab」与
|
|
5428
|
+
* 「这个 tabId 已被宿主回收给另一个资源」。在这种宿主上,一次基于 tabId 的关闭请求理论上可能
|
|
5429
|
+
* 落到复用了这个 id 的新 tab 上。风险边界由三件事共同限制,缺一不可:
|
|
5430
|
+
* 1. 命中条件仍要求 (当前 sidebar session + kind=subagentchat + 精确 tabId) 三条同时成立,
|
|
5431
|
+
* 别的 surface、别的 kind 的同名 id 一律不会被命中;
|
|
5432
|
+
* 2. 关闭入口仍受「会话 + root + tabId」租约与迟到隔离窗约束(同一时刻只有一个在途请求),
|
|
5433
|
+
* 不会并发重复发请求;
|
|
5434
|
+
* 3. 只有具备可关闭 tabId 的 Auto 归属、用户手动点击或批量候选才会走到这里,绝不主动扫描
|
|
5435
|
+
* inventory 去关闭任何 tab。
|
|
5436
|
+
* 一旦宿主提供了 contentId,判据立刻恢复为地址逐字比较(同一个函数、同一条记录)。
|
|
5437
|
+
*
|
|
5438
|
+
* 地址判据与 recordSidebarTab / sidebarBatchCandidates 逐条同源:一条 record 能存在,本身就要
|
|
5439
|
+
* 求当时的 inventory 条目(或 active())的 contentId 与 key 的资源地址逐字相等;而传给宿主
|
|
5440
|
+
* openResource() 的也正是同一个地址字符串。因此「现在这一条的 contentId 变了」恰好就是
|
|
5441
|
+
* 「这个 tabId 已经不是我们的资源」的精确证据(见 closeSidebarTabWithLease 的 preflight)。
|
|
5442
|
+
*/
|
|
5443
|
+
const sidebarTabPresenceInInventory = (tabId, expectedAddress = null) => {
|
|
5444
|
+
const inventory = readSidebarOpenTabs();
|
|
5445
|
+
if (inventory === null) return "unreadable";
|
|
5446
|
+
const expected = text(expectedAddress, null);
|
|
5447
|
+
for (const entry of inventory) {
|
|
5448
|
+
// 单条畸形记录只跳过它自己:它既不证明存在,也不代表整份 inventory 不可读。
|
|
5449
|
+
try {
|
|
5450
|
+
const candidate = object(entry);
|
|
5451
|
+
if (text(candidate.sessionId, null) !== sidebarSessionId) continue;
|
|
5452
|
+
if (text(candidate.kind, null) !== SUBAGENT_CHAT_KIND) continue;
|
|
5453
|
+
if (text(candidate.tabId, null) !== tabId) continue;
|
|
5454
|
+
// 没有期望地址,或这一条没有暴露可读地址:无法证伪 → 保持既有的 present 语义。
|
|
5455
|
+
if (expected === null) return "present";
|
|
5456
|
+
const contentId = text(candidate.contentId, null);
|
|
5457
|
+
// fail-open(刻意保留):条目没有可读的 contentId 时无法证伪,只能按 present 处理,
|
|
5458
|
+
// 否则在「inventory 结构性缺 contentId」的宿主上永远关不掉任何 tab。残余风险见上方说明。
|
|
5459
|
+
if (contentId === null) return "present";
|
|
5460
|
+
return contentId === expected ? "present" : "recycled";
|
|
5461
|
+
} catch { continue; }
|
|
5462
|
+
}
|
|
5463
|
+
return "absent";
|
|
5464
|
+
};
|
|
5465
|
+
/**
|
|
5466
|
+
* 发出一次宿主 close 请求,并用 watchdog 封顶。返回 "resolved" | "rejected" | "timeout"。
|
|
5467
|
+
*
|
|
5468
|
+
* 宿主 Promise 不可取消:超时之后它仍可能迟到 resolve / reject。这里用一次性的 settled 闸门把
|
|
5469
|
+
* 迟到结果彻底隔离——它既不释放租约、也不清理任何归属,只让这一次调用安静地结束;同一个 tab 在
|
|
5470
|
+
* 隔离窗(SIDEBAR_TAB_CLOSE_LATE_QUARANTINE_MS)内绝不会再收到第二次 close。
|
|
5471
|
+
*/
|
|
5472
|
+
const requestSidebarTabClose = (tabId) => new Promise((resolve) => {
|
|
5473
|
+
let settled = false;
|
|
5474
|
+
let timer = null;
|
|
5475
|
+
const finish = (outcome) => {
|
|
5476
|
+
if (settled === true) return;
|
|
5477
|
+
settled = true;
|
|
5478
|
+
if (timer !== null) {
|
|
5479
|
+
try { globalThis.clearTimeout?.(timer); } catch { /* 清理失败不影响结果。 */ }
|
|
5480
|
+
}
|
|
5481
|
+
resolve(outcome);
|
|
5482
|
+
};
|
|
5483
|
+
try {
|
|
5484
|
+
timer = typeof globalThis.setTimeout === "function"
|
|
5485
|
+
? globalThis.setTimeout(() => finish("timeout"), SIDEBAR_TAB_CLOSE_WATCHDOG_MS)
|
|
5486
|
+
: null;
|
|
5487
|
+
} catch { timer = null; }
|
|
5488
|
+
let result = null;
|
|
5489
|
+
try {
|
|
5490
|
+
// close() 可同步抛错;结算前不能删掉来源,否则失败 tab 会被当成手动 tab 而永不重试。
|
|
5491
|
+
result = closeSidebarResource.call(sidebarRight, tabId);
|
|
5492
|
+
} catch {
|
|
5493
|
+
finish("rejected");
|
|
5494
|
+
return;
|
|
5495
|
+
}
|
|
5496
|
+
Promise.resolve(result).then(() => finish("resolved"), () => finish("rejected"));
|
|
5497
|
+
});
|
|
5498
|
+
/**
|
|
5499
|
+
* 等待一个竞争租约结算,最多等 timeoutMs;超时返回 false(绝不无限 await)。
|
|
5500
|
+
*
|
|
5501
|
+
* 手动单项与批量关闭共用这条等待:宿主的 Promise 可能永不 settle,没有上限就会把用户的点击
|
|
5502
|
+
* 永久挂在一次与它无关的宿主调用上。
|
|
5503
|
+
*/
|
|
5504
|
+
const waitForSidebarCloseLease = (leaseToken, timeoutMs) => new Promise((resolve) => {
|
|
5505
|
+
let done = false;
|
|
5506
|
+
let timer = null;
|
|
5507
|
+
const finish = (value) => {
|
|
5508
|
+
if (done === true) return;
|
|
5509
|
+
done = true;
|
|
5510
|
+
if (timer !== null) {
|
|
5511
|
+
try { globalThis.clearTimeout?.(timer); } catch { /* 同上。 */ }
|
|
5512
|
+
}
|
|
5513
|
+
resolve(value);
|
|
5514
|
+
};
|
|
5515
|
+
try {
|
|
5516
|
+
timer = typeof globalThis.setTimeout === "function" ? globalThis.setTimeout(() => finish(false), timeoutMs) : null;
|
|
5517
|
+
} catch { timer = null; }
|
|
5518
|
+
Promise.resolve(leaseToken.wait()).then(() => finish(true), () => finish(true));
|
|
5519
|
+
});
|
|
5520
|
+
/**
|
|
5521
|
+
* 登记一条「close 请求已经发出、等待 inventory 验证」记录,并让租约保持在验证窗口里。
|
|
5522
|
+
*
|
|
5523
|
+
* 记录随来源账本同层共享:重挂载后的新实例继续采样、继续收口;租约被它持有,因此下一轮同步
|
|
5524
|
+
* 绝不会为同一个 tab 再发第二次 close。attemptToken 与 manual 决定验证成功后如何收口预算与来源。
|
|
5525
|
+
*/
|
|
5526
|
+
const beginSidebarCloseVerification = (lease, tabId, verify) => {
|
|
5527
|
+
const entry = {
|
|
5528
|
+
sessionId: sidebarSessionId,
|
|
5529
|
+
rootSessionId,
|
|
5530
|
+
tabId,
|
|
5531
|
+
address: verify?.address ?? null,
|
|
5532
|
+
attemptToken: verify?.attemptToken ?? null,
|
|
5533
|
+
manual: verify?.manual === true,
|
|
5534
|
+
/**
|
|
5535
|
+
* 这次关闭出发时看到的 split 意图身份(不可复用令牌,见 sidebarSplitIntentRef)。
|
|
5536
|
+
*
|
|
5537
|
+
* 收口时只有当前意图**仍然是这一份**才允许取消它:这次关闭可能在验证窗口里跨越一次
|
|
5538
|
+
* 面板重挂载或用户/Auto 的新一次打开,按 key 无条件取消会把同 key 新 generation 的
|
|
5539
|
+
* split/open 事务一起掐掉(右栏从临时 50% 掉回、新 pane 的打开失去归属)。
|
|
5540
|
+
*/
|
|
5541
|
+
splitIntentToken: verify?.splitIntentToken ?? null,
|
|
5542
|
+
misses: 0,
|
|
5543
|
+
deadline: Date.now() + SIDEBAR_TAB_CLOSE_VERIFY_TIMEOUT_MS,
|
|
5544
|
+
lease,
|
|
5545
|
+
};
|
|
5546
|
+
sidebarAutoCloseVerificationsRef.current.set(verify.key, entry);
|
|
5547
|
+
trimAutoKeyMap(sidebarAutoCloseVerificationsRef.current, true);
|
|
5548
|
+
lease.hold("verifying", entry.deadline);
|
|
5549
|
+
return entry;
|
|
5550
|
+
};
|
|
5551
|
+
/**
|
|
5552
|
+
* verified-closed / verified-recycled 的唯一收口点:删除 record、按令牌结算 attempt、撤销
|
|
5553
|
+
* origin(手动则登记抑制)、清掉冷却与验证记录,最后归还租约并**带上原因**(见 reason 参数)。
|
|
5554
|
+
*
|
|
5555
|
+
* 两种证据走同一条收口:连续两次读不到这个**精确 tabId**,或连续两次读到这个 id 已经被另一个
|
|
5556
|
+
* 资源复用(地址不一致)——后者说明旧 tab 已经消失、这个 id 不再属于我们,同样不能再关。
|
|
5557
|
+
* 但两者的**租约结算原因必须不同**("closed" vs "recycled"):等待者可能是另一个 key 的关闭,
|
|
5558
|
+
* 它只能用自己的地址证据复核,绝不能把「这个 id 被别人回收了」当成「我那个 tab 已经关掉」。
|
|
5559
|
+
*
|
|
5560
|
+
* 记录只在它的 tabId 与本次验证完全一致时才删除:旧代次的验证绝不能删掉新 tabId 的 record。
|
|
5561
|
+
*/
|
|
5562
|
+
const finishVerifiedSidebarClose = (key, entry, reason) => {
|
|
5563
|
+
const records = sidebarTabRecordsRef.current;
|
|
5564
|
+
const record = records.get(key);
|
|
5565
|
+
const scopedRecord = record !== undefined
|
|
5566
|
+
&& record.sessionId === sidebarSessionId
|
|
5567
|
+
&& record.rootSessionId === rootSessionId
|
|
5568
|
+
? record
|
|
5569
|
+
: undefined;
|
|
5570
|
+
/**
|
|
5571
|
+
* (key, tabId, attemptToken) 一致性闸门:这次验证只对「它自己关闭的那个 tabId」有收口权。
|
|
5572
|
+
* 宿主换过 tabId 时(旧 tab 消失、同一个资源换成新 tab),旧验证只能归还自己的租约并清理
|
|
5573
|
+
* 自己那一笔令牌对应的预算,绝不删除新 generation 的 record / origin / 冷却。
|
|
5574
|
+
*/
|
|
5575
|
+
const sameTab = scopedRecord !== undefined && scopedRecord.tabId === entry.tabId;
|
|
5576
|
+
/**
|
|
5577
|
+
* 分栏事务的收口只认**这次关闭出发时看到的那一份意图**(不可复用令牌逐对象相等):
|
|
5578
|
+
* record 可能已被记录同步层删掉,但这次关闭确实发生了,事务必须收口,否则右栏会一直停在
|
|
5579
|
+
* 临时 50%。反过来,意图已经被新 generation 取代时(用户/Auto 重新打开同一个资源)绝不取消
|
|
5580
|
+
* 它——旧 close 的迟到收口取消一个新事务,会让右栏从 50% 掉回、新 pane 的打开失去归属。
|
|
5581
|
+
*/
|
|
5582
|
+
cancelPendingSidebarSplitOfClose(key, entry.splitIntentToken);
|
|
5583
|
+
if (sameTab === true) {
|
|
5584
|
+
records.delete(key);
|
|
5585
|
+
if (entry.attemptToken === null || entry.attemptToken === undefined) clearAutoCloseAttempt(key);
|
|
5586
|
+
else settleAutoCloseAttempt(key, { kind: "close", attemptToken: entry.attemptToken });
|
|
5587
|
+
sidebarAutoCloseCooldownsRef.current.delete(key);
|
|
5588
|
+
sidebarAutoOriginRef.current.delete(key);
|
|
5589
|
+
if (entry.manual === true && entry.address !== null && entry.address !== undefined) {
|
|
5590
|
+
sidebarAutoSuppressedRef.current.set(key, { sessionId: sidebarSessionId, rootSessionId, address: entry.address });
|
|
5591
|
+
trimAutoKeyMap(sidebarAutoSuppressedRef.current);
|
|
5592
|
+
// 手动关闭:抑制语义同步落到持久归属标记上(刷新之后同样绝不再当 auto)。
|
|
5593
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-close");
|
|
5594
|
+
} else if (entry.address !== null && entry.address !== undefined) {
|
|
5595
|
+
// 验证关闭成功 / inventory 已证明这个 tabId 不在:归属标记同步删除,绝不残留陈旧 auto。
|
|
5596
|
+
deleteSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, "verified-closed");
|
|
5597
|
+
}
|
|
5598
|
+
} else if (entry.attemptToken !== null && entry.attemptToken !== undefined) {
|
|
5599
|
+
// tabId 已经不属于这次验证:只按令牌结算本次动作自己的那一笔预算(owner 已被后来者替换时
|
|
5600
|
+
// settleAutoCloseAttempt 会自动放弃)。
|
|
5601
|
+
settleAutoCloseAttempt(key, { kind: "close", attemptToken: entry.attemptToken });
|
|
5602
|
+
}
|
|
5603
|
+
sidebarAutoCloseVerificationsRef.current.delete(key);
|
|
5604
|
+
// 结算原因随租约带给等待者:recycled 与 closed 对**别人**的证明力完全不同(见 token.result)。
|
|
5605
|
+
entry.lease?.release?.(reason === "recycled" ? "recycled" : "closed");
|
|
5606
|
+
bump((value) => value + 1);
|
|
5607
|
+
};
|
|
5608
|
+
|
|
5609
|
+
/**
|
|
5610
|
+
* 关闭请求的验证链(每轮同步跑一次):
|
|
5611
|
+
* 1. 隔离窗到期的迟到结果租约:只归还自己那一把(不碰 record / origin / attempt);
|
|
5612
|
+
* 2. 验证记录:只有连续两次可读 inventory 都读不到这个**精确 tabId**、或读到这个 id 已经被
|
|
5613
|
+
* **另一个资源**复用(contentId 与本 key 的资源地址不一致)才算 verified-closed;
|
|
5614
|
+
* present 重置缺失计数并保留归属;unreadable 不推进缺失计数(读不到证明不了任何事);
|
|
5615
|
+
* 超过验证窗口仍未验证则释放租约、保留 record/origin/attempt,由下一次同步决定是否重试。
|
|
5616
|
+
*/
|
|
5617
|
+
const verifyPendingSidebarCloses = () => {
|
|
5618
|
+
const now = Date.now();
|
|
5619
|
+
for (const [, token] of sharedSidebarTabCloseInFlight) {
|
|
5620
|
+
if (token.state !== "quarantined") continue;
|
|
5621
|
+
if (token.holdUntil > now) continue;
|
|
5622
|
+
// 隔离窗到期只说明那次请求**从未被验证**(watchdog 超时):结算原因必须是 timeout,
|
|
5623
|
+
// 绝不能是 closed——等待者据此知道「什么都没被证明」,需要自己用地址证据复核。
|
|
5624
|
+
token.release?.("timeout");
|
|
5625
|
+
}
|
|
5626
|
+
const verifications = sidebarAutoCloseVerificationsRef.current;
|
|
5627
|
+
for (const [key, entry] of [...verifications]) {
|
|
5628
|
+
if (entry.sessionId !== sidebarSessionId || entry.rootSessionId !== rootSessionId) continue;
|
|
5629
|
+
// 地址证据来自这次关闭自己那个 key 的资源地址(批量入口没有 key,地址为 null ⇒ 不比较地址)。
|
|
5630
|
+
const presence = sidebarTabPresenceInInventory(entry.tabId, entry.address);
|
|
5631
|
+
if (presence === "present") entry.misses = 0;
|
|
5632
|
+
else if (presence !== "unreadable") entry.misses += 1;
|
|
5633
|
+
/**
|
|
5634
|
+
* absent 与 recycled 都独立证明「这个精确 tabId 已经不再承载我们的资源」,因此可以混用同
|
|
5635
|
+
* 一个缺失计数:两种证据各采一次同样满足「连续两次」的确认要求(unreadable 绝不推进计数)。
|
|
5636
|
+
*/
|
|
5637
|
+
if (presence !== "present" && presence !== "unreadable"
|
|
5638
|
+
&& entry.misses >= SIDEBAR_TAB_DISAPPEAR_CONFIRMATIONS) {
|
|
5639
|
+
// 结算原因按证据分型:recycled(id 已被别的资源占用)绝不能对外冒充 verified-closed。
|
|
5640
|
+
finishVerifiedSidebarClose(key, entry, presence === "recycled" ? "recycled" : "closed");
|
|
5641
|
+
continue;
|
|
5642
|
+
}
|
|
5643
|
+
if (now >= entry.deadline) {
|
|
5644
|
+
// 验证超时:释放租约与验证记录,**保留** record / origin / attempt。
|
|
5645
|
+
verifications.delete(key);
|
|
5646
|
+
entry.lease?.release?.("timeout");
|
|
5647
|
+
// 同一批微任务级联里绝不立刻重选同一个 key(下一轮外部同步才重试)。
|
|
5648
|
+
sidebarAutoFailedKeysRef.current.add(key);
|
|
5649
|
+
}
|
|
5650
|
+
}
|
|
5651
|
+
};
|
|
5652
|
+
|
|
5653
|
+
/**
|
|
5654
|
+
* 关闭一个 tab 的唯一执行入口(单 tab 关闭与批量关闭共用),把「租约 + 结算信号 + 有限重试」
|
|
5655
|
+
* 全部收在这里。
|
|
5656
|
+
*
|
|
5657
|
+
* 并发语义由 waitForCompeting 区分:
|
|
5658
|
+
* - true(用户触发的手动单项与批量):同一个 tabId 上已经有一次关闭在途时,等待它结算,然后
|
|
5659
|
+
* **用它自己的期望地址重新探针复核**再决定——结算原因只说明「上一次关闭凭什么结束」,而
|
|
5660
|
+
* 这个 tabId 在两次关闭之间完全可能被宿主回收给另一个资源:
|
|
5661
|
+
* · 复核为 present(且地址一致)⇒ 这个 id 此刻仍然是我们要关的那个 tab,才允许一次有限重试;
|
|
5662
|
+
* · 复核为 absent ⇒ 我们的 tab 已经不在,按 verified-closed 收口,绝不再 close;
|
|
5663
|
+
* · 复核为 recycled ⇒ 这个 id 已承载别的资源,按 verified-recycled 收口自己这个 key;
|
|
5664
|
+
* · 复核为 unreadable ⇒ fail-closed,什么都不做;
|
|
5665
|
+
* · 上一次结算原因是 recycled 而**自己又没有期望地址**可复核 ⇒ 一律跳过:别人的
|
|
5666
|
+
* 「旧 tab 已消失」对没有地址证据的等待者什么都证明不了(recycled-unverifiable)。
|
|
5667
|
+
* - false(Auto 自动同步):遇到在途关闭立刻返回 contended 让位,绝不 await、绝不排队重试
|
|
5668
|
+
* (调用方负责回退本轮 closeAttempts/预留并维持防微任务循环屏障)。
|
|
5669
|
+
*
|
|
5670
|
+
* status 语义(只有 verified-closed / closed / verified-recycled 才允许调用方收口归属):
|
|
5671
|
+
* - verified-closed:preflight 或验证链用**精确 tabId** 的 inventory 证据证明这个 tab 已经不在;
|
|
5672
|
+
* - verified-recycled:这个 tabId 已经被宿主回收给**另一个资源**(条目暴露的资源地址与本次
|
|
5673
|
+
* 关闭那个 key 的地址不一致)⇒ 旧 tab 已经消失、新 tab 不是我们的。close **一次都没有发出**,
|
|
5674
|
+
* 但结论与 verified-closed 等价:这个 key 的 record / 预算 / 冷却必须收口,且绝不允许重试;
|
|
5675
|
+
* - request-resolved-unverified:宿主 close 已经 resolve,但仍在验证窗口里(记录/来源/计数全部保留);
|
|
5676
|
+
* - failed:宿主 close 同步抛错或 rejected(请求真的发出过,绝不回滚 count);
|
|
5677
|
+
* - timeout:watchdog 超时(同样不回滚 count,租约进入迟到隔离窗);
|
|
5678
|
+
* - contended / contended-timeout:有人在关,本次不发 / 等待竞争租约超过同一个 10 秒上限;
|
|
5679
|
+
* - recycled-unverifiable:上次结算是 recycled,而本次等待者没有地址证据可复核 ⇒ 跳过
|
|
5680
|
+
* (既不关闭也不收口归属),等下一次带地址证据的动作或同步链自行收口;
|
|
5681
|
+
* - unreadable:inventory 不可读(或地址不可证伪时保持既有语义),fail-closed 不发;
|
|
5682
|
+
* - stale:等待期间 surface 换代;unavailable:宿主没有 close 能力。
|
|
5683
|
+
*/
|
|
5684
|
+
const closeSidebarTabWithLease = async (tabId, options) => {
|
|
5685
|
+
if (closeSidebarResource === null) return { status: "unavailable", closed: false };
|
|
5686
|
+
const waitForCompeting = options?.waitForCompeting === true;
|
|
5687
|
+
// verify:close 请求 resolve 之后的验证上下文 { key, address, attemptToken, manual }。
|
|
5688
|
+
const verify = options?.verify ?? null;
|
|
5689
|
+
let lease = acquireSidebarTabClose(tabId);
|
|
5690
|
+
if (lease === null) {
|
|
5691
|
+
if (waitForCompeting !== true) return { status: "contended", closed: false };
|
|
5692
|
+
const competing = sidebarTabCloseLeaseOf(tabId);
|
|
5693
|
+
// 探测与读取之间没有 await,因此这里理论上不可达;真出现只可能是锁被别的实现动过,
|
|
5694
|
+
// fail-closed 让位总好过在拿不到结算信号的情况下盲发一次 close。
|
|
5695
|
+
if (competing === null) return { status: "contended", closed: false };
|
|
5696
|
+
// 等待结算:同一个 10 秒 watchdog 上限,绝不无限 await(宿主 Promise 不可取消)。
|
|
5697
|
+
const settledInTime = await waitForSidebarCloseLease(competing, SIDEBAR_TAB_CLOSE_WATCHDOG_MS);
|
|
5698
|
+
if (settledInTime !== true) return { status: "contended-timeout", closed: false };
|
|
5699
|
+
/**
|
|
5700
|
+
* 等待可能跨越一次组件重挂载、root / sidebar session 切换,或同一个实例的 A→B→A 快速
|
|
5701
|
+
* 回返:那次关闭属于旧 surface,本次动作绝不在新 surface 上继续(旧 tab 的归属由它自己
|
|
5702
|
+
* 那一轮的链路与既有同步器结算)。批量入口在 await 之后也有同一道复核,这里是共享执行
|
|
5703
|
+
* 入口里的等价收口;判据含不可复用的 surface 令牌,因此「切走又切回同一组值」同样作废。
|
|
5704
|
+
*/
|
|
5705
|
+
if (sidebarSurfaceStillCurrent() !== true) return { status: "stale", closed: false };
|
|
5706
|
+
/**
|
|
5707
|
+
* 等待者绝不直接采信别人的结算结论(旧实现只读布尔 ok),一律用自己的期望地址重新探针:
|
|
5708
|
+
*
|
|
5709
|
+
* 结算原因只回答「上一次关闭凭什么结束」:closed / recycled / failed / timeout。它**不**回答
|
|
5710
|
+
* 「此刻这个 tabId 是不是我那个 tab」——两次关闭之间,宿主完全可能把这个已经释放的 id 回收给
|
|
5711
|
+
* 另一个资源。跨 key 交错时(A 的 verified-recycled 与 T 的等待落在同一个 tabId 上),把 A 的
|
|
5712
|
+
* 「旧 tab 已消失」当成 T 自己的关闭完成,就会让 T 误删自己的 record / 来源 / 抑制,或者相反:
|
|
5713
|
+
* 对别人复用的新 tab 再发一次 close。地址复核是唯一的防线。
|
|
5714
|
+
*/
|
|
5715
|
+
const settledReason = competing.result;
|
|
5716
|
+
if (settledReason === "recycled"
|
|
5717
|
+
&& (verify?.address === null || verify?.address === undefined)) {
|
|
5718
|
+
// 没有地址证据的等待者遇到 recycled:既不关闭也不收口——跳过这一次,绝不盲从别人的结论。
|
|
5719
|
+
return { status: "recycled-unverifiable", closed: false };
|
|
5720
|
+
}
|
|
5721
|
+
/**
|
|
5722
|
+
* 只有当前 inventory 明确证明同一个 tabId 仍存在**且仍然是我们要关的那个资源**(条目暴露的
|
|
5723
|
+
* contentId 与本次关闭的地址一致),才允许这一次有限重试。
|
|
5724
|
+
* - recycled:这个 id 已经被宿主回收给别的资源 ⇒ 旧 tab 已经消失,绝不重试(绝不关别人的 tab),
|
|
5725
|
+
* 按「旧 tab 已消失」结算,调用方据此收口自己这个 key 的记账;
|
|
5726
|
+
* - absent:同上(用户的关闭意图已经达成);unreadable:fail-closed。
|
|
4003
5727
|
*/
|
|
4004
|
-
const
|
|
4005
|
-
if (
|
|
4006
|
-
if (
|
|
4007
|
-
if (
|
|
5728
|
+
const presence = sidebarTabPresenceInInventory(tabId, verify?.address ?? null);
|
|
5729
|
+
if (presence === "unreadable") return { status: "unreadable", closed: false };
|
|
5730
|
+
if (presence === "recycled") return { status: "verified-recycled", closed: false };
|
|
5731
|
+
if (presence !== "present") return { status: "verified-closed", closed: true };
|
|
5732
|
+
lease = acquireSidebarTabClose(tabId);
|
|
5733
|
+
// 已经有别人接手(或又一次在途):有限重试到此为止,绝不排队等第二次。
|
|
5734
|
+
if (lease === null) return { status: "contended", closed: false };
|
|
5735
|
+
}
|
|
5736
|
+
/**
|
|
5737
|
+
* 调用 close 之前的 preflight:必须用**当前** openTabs inventory 精确确认目标 tabId,并且
|
|
5738
|
+
* ——只要调用方给了这个 key 的资源地址——确认这个 id 此刻仍然承载**同一个资源地址**。
|
|
5739
|
+
*
|
|
5740
|
+
* 这是本插件唯一一次在副作用之前回答「这仍然是我们决定要关的那个 tab 吗」的地方:
|
|
5741
|
+
* - present:可以调用 close;
|
|
5742
|
+
* - absent:精确证据上的 verified-closed;
|
|
5743
|
+
* - recycled:id 已被宿主回收给别的资源(旧 tab 已经消失)⇒ 绝不调用 close(那会关掉别人的
|
|
5744
|
+
* tab),按「旧 tab 已消失」结算并让调用方收口本 key 的 record / 预算 / 冷却;
|
|
5745
|
+
* - unreadable:一律 fail-closed(不调用 close、不清理归属),绝不把「读不到」当成「没有」。
|
|
5746
|
+
*/
|
|
5747
|
+
const preflight = sidebarTabPresenceInInventory(tabId, verify?.address ?? null);
|
|
5748
|
+
/**
|
|
5749
|
+
* 手动路径在**读面缺失**(旧宿主没有 openTabs)时的兼容:没有验证证据,但用户明确要求关闭——
|
|
5750
|
+
* 照旧调用 close 并按历史语义收口,绝不因为读面缺失把用户的关闭意图丢掉。
|
|
5751
|
+
* 自动路径没有这条退路:没有精确证据时 fail-closed(不调用 close、不清理归属)。
|
|
5752
|
+
*/
|
|
5753
|
+
const manualWithoutEvidence = preflight === "unreadable" && verify !== null && verify.manual === true;
|
|
5754
|
+
if (preflight === "unreadable" && manualWithoutEvidence !== true) {
|
|
5755
|
+
// 什么都没发出、也什么都没证明:结算原因只能是 failed(等待者必须自己复核)。
|
|
5756
|
+
lease.release("failed");
|
|
5757
|
+
return { status: "unreadable", closed: false };
|
|
5758
|
+
}
|
|
5759
|
+
|
|
5760
|
+
if (preflight === "absent") {
|
|
5761
|
+
lease.release("closed");
|
|
5762
|
+
return { status: "verified-closed", closed: true };
|
|
5763
|
+
}
|
|
5764
|
+
if (preflight === "recycled") {
|
|
4008
5765
|
/**
|
|
4009
|
-
*
|
|
4010
|
-
*
|
|
4011
|
-
*
|
|
5766
|
+
* 地址证据证明这个 tabId 已经换了资源:旧 tab 已经消失。绝不调用 close——重试一次就会把
|
|
5767
|
+
* 别人(复用了这个 id 的新 tab)关掉。
|
|
5768
|
+
*
|
|
5769
|
+
* 租约必须按**原因**归还("recycled"),而不是布尔 ok=true:这个结论只对「本次关闭那个
|
|
5770
|
+
* key」有效(旧 tab 已消失),对同一个 tabId 上**别的 key** 的等待者完全没有证明力——
|
|
5771
|
+
* 「id 被复用」恰恰意味着这个 id 现在承载的不是我们的资源。等待者一律用自己的期望地址重新
|
|
5772
|
+
* 探针复核后再决定(见 closeSidebarTabWithLease 的等待分支),没有地址证据的一方直接跳过。
|
|
5773
|
+
*
|
|
5774
|
+
* 本次调用自己的 key 不受这条归还值影响:调用方按 verified-recycled 收口自己的 record /
|
|
5775
|
+
* 预算 / 冷却(见 handleSidebarAction),并且同样过 (key, tabId) 一致性闸门。
|
|
4012
5776
|
*/
|
|
4013
|
-
|
|
4014
|
-
|
|
4015
|
-
trimAutoKeyMap(reservations);
|
|
4016
|
-
return { key, address, kind: "open", epoch };
|
|
5777
|
+
lease.release("recycled");
|
|
5778
|
+
return { status: "verified-recycled", closed: false };
|
|
4017
5779
|
}
|
|
4018
|
-
|
|
4019
|
-
|
|
4020
|
-
|
|
4021
|
-
|
|
4022
|
-
|
|
4023
|
-
|
|
4024
|
-
|
|
4025
|
-
|
|
5780
|
+
const outcome = await requestSidebarTabClose(tabId);
|
|
5781
|
+
if (outcome === "rejected") {
|
|
5782
|
+
// 请求真的发出去过并失败:租约按未验证归还(failed),绝不回滚 count(那会突破三次快速上限)。
|
|
5783
|
+
lease.release("failed");
|
|
5784
|
+
return { status: "failed", closed: false };
|
|
5785
|
+
}
|
|
5786
|
+
if (outcome === "timeout") {
|
|
5787
|
+
// 迟到结果隔离窗:租约保留到隔离窗结束(由同步链路归还),期间绝不再发第二次 close。
|
|
5788
|
+
lease.hold("quarantined", Date.now() + SIDEBAR_TAB_CLOSE_LATE_QUARANTINE_MS);
|
|
5789
|
+
return { status: "timeout", closed: false };
|
|
5790
|
+
}
|
|
5791
|
+
/**
|
|
5792
|
+
* resolve 只代表请求完成:登记验证记录并**保留租约**,由后续同步按精确 inventory 收口。
|
|
5793
|
+
* 没有可验证的 key(调用方没有 Auto 记账,例如批量入口)时按未验证归还租约,绝不当作已关闭。
|
|
5794
|
+
*/
|
|
5795
|
+
if (manualWithoutEvidence === true) {
|
|
5796
|
+
// 无 inventory 读面的手动关闭:历史语义(用户意图优先),按「已关闭」结算并归还租约。
|
|
5797
|
+
lease.release("closed");
|
|
5798
|
+
return { status: "closed", closed: true };
|
|
5799
|
+
}
|
|
5800
|
+
if (verify === null || verify.key === null || verify.key === undefined) {
|
|
5801
|
+
// 没有可验证的 key(批量入口):请求完成了但**什么都没被证明** ⇒ failed,等待者自己复核。
|
|
5802
|
+
lease.release("failed");
|
|
5803
|
+
return { status: "request-resolved-unverified", closed: false };
|
|
4026
5804
|
}
|
|
5805
|
+
|
|
5806
|
+
beginSidebarCloseVerification(lease, tabId, verify);
|
|
5807
|
+
return { status: "request-resolved-unverified", closed: false };
|
|
4027
5808
|
};
|
|
4028
5809
|
/**
|
|
4029
5810
|
* 清理已经离开当前快照的复合键(来源与抑制两个集合),避免长期泄漏。
|
|
@@ -4037,8 +5818,13 @@
|
|
|
4037
5818
|
if (entry.sessionId !== sidebarSessionId || entry.rootSessionId !== rootSessionId) continue;
|
|
4038
5819
|
if (key === actingKey) continue;
|
|
4039
5820
|
if (known.has(entry.address) === true) continue;
|
|
5821
|
+
/**
|
|
5822
|
+
* 快照里暂时缺了这个地址,但 key 上仍有活动记账(record / 在途打开 / pending / 验证 / 冷却):
|
|
5823
|
+
* 绝不删除 origin——否则冷却到期后就再也关不掉这个 tab(快照缺项不等于宿主里没有)。
|
|
5824
|
+
*/
|
|
5825
|
+
if (sidebarAutoCloseKeyIsActive(key) === true) continue;
|
|
4040
5826
|
map.delete(key);
|
|
4041
|
-
|
|
5827
|
+
clearAutoCloseBudget(key);
|
|
4042
5828
|
}
|
|
4043
5829
|
}
|
|
4044
5830
|
// 预留同样要清理,但**在途动作自己那一条绝不能被清理**:它的 finally 才是唯一的释放点,
|
|
@@ -4051,6 +5837,65 @@
|
|
|
4051
5837
|
sidebarAutoReservationRef.current.delete(key);
|
|
4052
5838
|
}
|
|
4053
5839
|
};
|
|
5840
|
+
/**
|
|
5841
|
+
* 回收「Auto 打开已经发出、tabId 始终没落地」的共享来源**占位**(缺陷 2)。
|
|
5842
|
+
*
|
|
5843
|
+
* 为什么必须有这一步:占位同时承担两件事——(a) autoOpenCandidate 靠 origin.has(key) 跳过
|
|
5844
|
+
* 「本次运行已经为它打开过」,(b) 它占着归属账本的容量槽位(128)。宿主始终没落地该 tab 时,
|
|
5845
|
+
* 这两件事都会变成长期伤害:资源明明还在 running,Auto 却既不再打开、又占着名额,一批这样的
|
|
5846
|
+
* 占位就能把账本占满,让 Auto 再也开不出任何新 tab——只有整页刷新(内存账本归零)才能恢复。
|
|
5847
|
+
*
|
|
5848
|
+
* 判据(只在期限到达之后才动,期限见 SIDEBAR_AUTO_OPEN_PLACEHOLDER_TTL_MS):
|
|
5849
|
+
* - 本 scope:先按当前 inventory **精确核对**。地址上仍然没有 tab ⇒ 释放占位,让下一轮外部同步
|
|
5850
|
+
* 重新选出这个候选(一次有界重试:至少间隔一个 TTL 窗口,同一批微任务里还有失败屏障兜底);
|
|
5851
|
+
* 地址上已经有 tab ⇒ 同样释放(归属判定已经由 record / 收养路径接管,占位不再有意义);
|
|
5852
|
+
* **inventory 读不出来 ⇒ 一律保留(fail-closed)**:读不到既不证明存在、也不证明不存在,
|
|
5853
|
+
* 绝不当成「没有 tab」去释放。
|
|
5854
|
+
* - 别的 scope:占位本身不是归属证据(tabId 为空),释放它不会授权任何关闭;而对方候选选择
|
|
5855
|
+
* 必须在发出 openResource 之前重新核对它自己的 inventory,因此也不可能因此开出重复 tab。
|
|
5856
|
+
* 为免打断另一个 surface 仍在进行中的打开,这里用 4 倍期限(FOREIGN_TTL)。
|
|
5857
|
+
*
|
|
5858
|
+
* 在途动作(pending / 本地 opening)绝不释放:那两种状态说明这次打开还在被观察,提前释放会让
|
|
5859
|
+
* 尾随同步立刻再开一次。
|
|
5860
|
+
*/
|
|
5861
|
+
const sweepAutoOpenPlaceholders = (running) => {
|
|
5862
|
+
const originMap = sidebarAutoOriginRef.current;
|
|
5863
|
+
if (originMap.size === 0) return;
|
|
5864
|
+
const now = Date.now();
|
|
5865
|
+
for (const [key, entry] of [...originMap]) {
|
|
5866
|
+
// 已落地的条目(tabId 非空)由既有收口路径负责(verified-closed / inventory-absent /
|
|
5867
|
+
// tab-recycled / resource-running),TTL 绝不去碰它们。
|
|
5868
|
+
if (sidebarAutoOriginTabIdOf(entry) !== null) continue;
|
|
5869
|
+
const age = now - sidebarAutoOriginWrittenAtOf(entry);
|
|
5870
|
+
const scoped = entry.sessionId === sidebarSessionId && entry.rootSessionId === rootSessionId;
|
|
5871
|
+
if (scoped !== true) {
|
|
5872
|
+
if (age < SIDEBAR_AUTO_OPEN_PLACEHOLDER_FOREIGN_TTL_MS) continue;
|
|
5873
|
+
originMap.delete(key);
|
|
5874
|
+
recordSidebarAutoDiag({ kind: "ownership", event: "delete", reason: "placeholder-foreign-expired", key: sidebarAutoKeyDigest(key) });
|
|
5875
|
+
continue;
|
|
5876
|
+
}
|
|
5877
|
+
if (age < SIDEBAR_AUTO_OPEN_PLACEHOLDER_TTL_MS) continue;
|
|
5878
|
+
if (sidebarTabPendingRef.current.has(key) === true) continue;
|
|
5879
|
+
if (sidebarTabOpeningRef.current.has(key) === true) continue;
|
|
5880
|
+
const state = sidebarResourceTabStateOf(entry.address);
|
|
5881
|
+
if (state.readable !== true) {
|
|
5882
|
+
// fail-closed:读不到 inventory 时保留占位,绝不把「读不到」当成「没有 tab」。
|
|
5883
|
+
recordSidebarAutoDiag({ kind: "ownership", event: "keep", reason: "placeholder-unreadable", key: sidebarAutoKeyDigest(key) });
|
|
5884
|
+
continue;
|
|
5885
|
+
}
|
|
5886
|
+
originMap.delete(key);
|
|
5887
|
+
recordSidebarAutoDiag({
|
|
5888
|
+
kind: "ownership",
|
|
5889
|
+
event: "delete",
|
|
5890
|
+
reason: state.tabId === null
|
|
5891
|
+
? (running !== null && running !== undefined && running.has(entry.address) === true
|
|
5892
|
+
? "placeholder-retry"
|
|
5893
|
+
: "placeholder-released")
|
|
5894
|
+
: "placeholder-superseded",
|
|
5895
|
+
key: sidebarAutoKeyDigest(key),
|
|
5896
|
+
});
|
|
5897
|
+
}
|
|
5898
|
+
};
|
|
4054
5899
|
/**
|
|
4055
5900
|
* 放行一个自动动作。
|
|
4056
5901
|
*
|
|
@@ -4060,18 +5905,41 @@
|
|
|
4060
5905
|
*/
|
|
4061
5906
|
const launchAutoSidebarAction = (candidate) => {
|
|
4062
5907
|
sidebarAutoBusyRef.current = true;
|
|
5908
|
+
/**
|
|
5909
|
+
* 自动打开/自动关闭决策的诊断记录(只记结论与 key 摘要,绝不记提示词/正文/令牌):
|
|
5910
|
+
* 候选选中时记一条 launch,结算/失败时再记一条,便于事后离线核对「某次构建之后这个 tab 为什么
|
|
5911
|
+
* 没被收回去」。
|
|
5912
|
+
*/
|
|
5913
|
+
recordSidebarAutoDecision("launch", candidate, "candidate");
|
|
4063
5914
|
void Promise.resolve()
|
|
4064
5915
|
// candidate 作为自动动作上下文(kind/epoch/预留)传入:动作必须在每个 await 之后
|
|
4065
5916
|
// 复核它是否仍然有效,并在收尾时无条件释放预留(见 handleSidebarAction)。
|
|
4066
5917
|
.then(() => handleSidebarAction(candidate.key, candidate.address, SIDEBAR_TAB_ORIGIN_AUTO, candidate))
|
|
4067
|
-
.
|
|
5918
|
+
.then(
|
|
5919
|
+
() => { recordSidebarAutoDecision("settle", candidate, "ok"); },
|
|
5920
|
+
(error) => {
|
|
5921
|
+
/* 打开/关闭失败只影响这一次动作:状态由既有记录与重试记账负责。 */
|
|
5922
|
+
recordSidebarAutoDecision("settle", candidate, "failed", sidebarBoundedText(error === null || error === undefined ? undefined : error.message));
|
|
5923
|
+
},
|
|
5924
|
+
)
|
|
4068
5925
|
.then(() => {
|
|
4069
5926
|
sidebarAutoBusyRef.current = false;
|
|
4070
5927
|
/**
|
|
4071
5928
|
* 尾随同步只用来推进「下一个候选」。它必须带着级联标记执行:这一轮里失败过的 key
|
|
4072
5929
|
* 不会被重新选中,因此「失败 → 撤销预留 → 立刻重选」不在微任务里自转(见
|
|
4073
5930
|
* sidebarAutoFailedKeysRef)。真正的重试留给下一个外部同步轮。
|
|
5931
|
+
*
|
|
5932
|
+
* 但这次推进同样只能由**仍然有效**的那一轮 surface 发起:动作的 await 可能跨越一次组件
|
|
5933
|
+
* 重挂载 / root 切换,此时本闭包的 mountedRef 已经是 false(旧实例的挂载 effect 已清理),
|
|
5934
|
+
* 而它手里的旧快照与共享 Auto 来源账本不是一回事——旧闭包的 syncSidebarTabs() 会把新
|
|
5935
|
+
* Panel 刚写入的其它 Auto 来源当成「已经离开旧快照」清掉(新 Panel 随后再也认不出自己
|
|
5936
|
+
* 打开过的 tab),并且「旧实例入口放弃动作 → 尾随同步又选中同一个候选」会形成不让出宏
|
|
5937
|
+
* 任务的微任务自转(页面被拖住)。因此这里与 handleSidebarAction 的收尾闸门用同一条判据
|
|
5938
|
+
* (含不可复用的 surface 令牌,重挂载与 A→B→A 都算失配):surface 失配时只归还本实例的
|
|
5939
|
+
* 级联闸门,绝不调用旧闭包的同步;新 Panel 的下一轮外部同步会按真实 inventory 继续推进
|
|
5940
|
+
* 候选与清理。
|
|
4074
5941
|
*/
|
|
5942
|
+
if (sidebarSurfaceStillCurrent() !== true) return;
|
|
4075
5943
|
sidebarAutoCascadeRef.current = true;
|
|
4076
5944
|
try {
|
|
4077
5945
|
// 用引用取最新一轮渲染的同步器(与 observer/轮询同一写法),绝不复用当前闭包。
|
|
@@ -4081,6 +5949,39 @@
|
|
|
4081
5949
|
}
|
|
4082
5950
|
});
|
|
4083
5951
|
};
|
|
5952
|
+
/**
|
|
5953
|
+
* 观察到「资源已经明确空闲」时清除这个地址的 manual 抑制(内存 + 持久两层)。
|
|
5954
|
+
*
|
|
5955
|
+
* 清除时机只按**资源状态**判定(onIdle):
|
|
5956
|
+
* - 资源仍在运行(在 running 集合里)⇒ 一律保留:这正是「刷新时正在运行、用户已手动关闭的 tab」
|
|
5957
|
+
* 的形状,清掉就等于把用户的关闭又撤销一次(P1-B);
|
|
5958
|
+
* - 资源已明确空闲(ready)⇒ 清除:这一轮运行已经结束,用户当时的关闭意图不再需要跨运行保留,
|
|
5959
|
+
* 下一次运行必须能正常自动打开(否则一次手动关闭就永久关掉了这个地址的自动行为);
|
|
5960
|
+
* - 快照里既看不到运行也看不到空闲(暂时缺项 / 状态 unknown)⇒ 一律保留:那既不证明在运行、
|
|
5961
|
+
* 也不证明已结束,按 fail-closed 不动。空闲集合由 idleSidebarResourceAddresses 给出,它用的是
|
|
5962
|
+
* **严格**证据规则(sidebarNodeIsIdleReady),因此轻量快照下虽然 unknown 节点也会显示在空闲
|
|
5963
|
+
* 分组里(修复 B 的显示从宽),它们的 manual 抑制仍然一律保留、绝不被这里清掉。
|
|
5964
|
+
*
|
|
5965
|
+
* 只清 manual:
|
|
5966
|
+
* - 内存层(sidebarAutoSuppressedRef)与持久层是同一个语义的两份存储,必须一起清,否则刷新前的
|
|
5967
|
+
* 内存抑制会继续挡住下一次运行;
|
|
5968
|
+
* - **auto 标记绝不在这里清除**(origin !== manual 直接跳过):一个正在等待收口的 auto tab 一旦
|
|
5969
|
+
* 在空闲观察里被降级成 manual,就再也不会被自动收回——auto 仍只由 verified-close /
|
|
5970
|
+
* inventory-absent / tab-recycled 三条路径清除(见 deleteSidebarAutoOwnership 的说明)。
|
|
5971
|
+
*
|
|
5972
|
+
* 限项:只遍历当前 root 的空闲地址(快照已有),因此不会跨 scope 误清别的 root / session 的键
|
|
5973
|
+
* (键由当前 sidebar session + root + 地址现算)。
|
|
5974
|
+
*/
|
|
5975
|
+
const clearManualSuppressionOfIdleResources = (idle) => {
|
|
5976
|
+
if (idle === null || idle === undefined || idle.size === 0) return;
|
|
5977
|
+
for (const address of idle) {
|
|
5978
|
+
const key = sidebarTabKey(sidebarSessionId, rootSessionId, address);
|
|
5979
|
+
if (sidebarAutoSuppressedRef.current.has(key) === true) sidebarAutoSuppressedRef.current.delete(key);
|
|
5980
|
+
const persisted = readSidebarAutoOwnershipEntry(sidebarSessionId, rootSessionId, address, { quiet: true });
|
|
5981
|
+
if (persisted === null || persisted.origin !== SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL) continue;
|
|
5982
|
+
deleteSidebarAutoOwnership(sidebarSessionId, rootSessionId, address, "resource-idle", { manual: true });
|
|
5983
|
+
}
|
|
5984
|
+
};
|
|
4084
5985
|
/**
|
|
4085
5986
|
* 第二阶段:Auto(自动打开运行中的子代理侧栏)同步。
|
|
4086
5987
|
*
|
|
@@ -4102,6 +6003,17 @@
|
|
|
4102
6003
|
const known = knownSidebarResourceAddresses();
|
|
4103
6004
|
const running = runningSidebarResourceAddresses();
|
|
4104
6005
|
const enabled = autoOpenEnabled();
|
|
6006
|
+
/**
|
|
6007
|
+
* 先回收过期的打开占位(缺陷 2):它只维护插件自己的记账、绝不触碰宿主,因此与 Auto 开关无关
|
|
6008
|
+
* (与下面的记账清理同一条边界)。放在候选选择之前,被回收的容量当轮就能重新用上。
|
|
6009
|
+
*/
|
|
6010
|
+
sweepAutoOpenPlaceholders(running);
|
|
6011
|
+
/**
|
|
6012
|
+
* manual 抑制的清除只由「明确空闲」驱动,且与 Auto 开关无关(与上面的记账清理同一条边界:
|
|
6013
|
+
* 它只维护本插件自己的标记,绝不触碰宿主)。先清再选候选:清掉之后这一轮的开候选判据读到的
|
|
6014
|
+
* 就是最新状态;空闲地址本来就不在 running 集合里,因此这一步不会为本次运行重新打开任何 tab。
|
|
6015
|
+
*/
|
|
6016
|
+
clearManualSuppressionOfIdleResources(idleSidebarResourceAddresses(sidebarIdleChildren()));
|
|
4105
6017
|
let candidate = null;
|
|
4106
6018
|
if (enabled === true && sidebarAutoBusyRef.current !== true) {
|
|
4107
6019
|
candidate = autoCloseCandidate(running) ?? autoOpenCandidate(running);
|
|
@@ -4142,13 +6054,35 @@
|
|
|
4142
6054
|
sidebarAutoReservationRef.current.delete(key);
|
|
4143
6055
|
releaseAutoCloseAttempt(key, context);
|
|
4144
6056
|
};
|
|
4145
|
-
/**
|
|
6057
|
+
/**
|
|
6058
|
+
* 回退候选选择时预支的那一次自动关闭重试(动作在真正调用 close 之前被撤销时调用)。
|
|
6059
|
+
*
|
|
6060
|
+
* 只有**这条预算当前的所有者**才允许回滚:owner 账本里登记的必须与本次动作出发时拿到的是
|
|
6061
|
+
* 同一份不可复用令牌。旧代次的迟到收尾(重挂载、同一个实例 A→B→A、Auto 关闭取消)完全可能
|
|
6062
|
+
* 在新代次已经为同一个 key 重新预支预算之后才跑到这里——令牌不匹配时一律 fail-safe:绝不写、
|
|
6063
|
+
* 绝不删共享 attempts,否则新代次的预算会被删掉(等于复活),同一个 key 的实际 close 次数就会
|
|
6064
|
+
* 突破 3 次上限。owner 不存在或已被限容淘汰时同样 fail-safe(宁可白烧一次预算,也绝不动可能
|
|
6065
|
+
* 属于后来者的计数)。
|
|
6066
|
+
*/
|
|
4146
6067
|
const releaseAutoCloseAttempt = (key, context) => {
|
|
4147
6068
|
if (context === null || context === undefined || context.kind !== "close") return;
|
|
6069
|
+
const owners = sidebarAutoCloseAttemptOwnersRef.current;
|
|
6070
|
+
const token = context.attemptToken;
|
|
6071
|
+
if (token === null || token === undefined || owners.get(key) !== token) return;
|
|
4148
6072
|
const attempts = sidebarAutoCloseAttemptsRef.current;
|
|
4149
|
-
|
|
6073
|
+
// owner 还在、预算已经不在了(被限容淘汰或被别的收口路径清掉):只清掉自己这一份 owner。
|
|
6074
|
+
if (attempts.has(key) !== true) {
|
|
6075
|
+
owners.delete(key);
|
|
6076
|
+
return;
|
|
6077
|
+
}
|
|
4150
6078
|
if (context.attemptsBefore === 0) attempts.delete(key);
|
|
4151
|
-
else
|
|
6079
|
+
else {
|
|
6080
|
+
attempts.set(key, context.attemptsBefore);
|
|
6081
|
+
// 回退同样要限容:这一步是 set 的第二条路径,少了它这个 Map 就可能在长生命周期里无界增长。
|
|
6082
|
+
trimAutoKeyMap(attempts);
|
|
6083
|
+
}
|
|
6084
|
+
// 回滚完成即交还所有权:此后同一个 key 的新预支由新的令牌持有,旧令牌再也回不来。
|
|
6085
|
+
owners.delete(key);
|
|
4152
6086
|
};
|
|
4153
6087
|
/**
|
|
4154
6088
|
* 自动动作在副作用之前必须让位的「手动接管」状态:
|
|
@@ -4210,9 +6144,11 @@
|
|
|
4210
6144
|
if (recordScoped) {
|
|
4211
6145
|
// 用户手动打开 = 他重新要这个会话:清除抑制,并把来源收回 manual(Auto 不得再自动关它)。
|
|
4212
6146
|
record.origin = SIDEBAR_TAB_ORIGIN_MANUAL;
|
|
6147
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-open");
|
|
4213
6148
|
sidebarAutoSuppressedRef.current.delete(key);
|
|
4214
6149
|
sidebarAutoOriginRef.current.delete(key);
|
|
4215
|
-
|
|
6150
|
+
// 手动接管这个 key:未结算的自动关闭预算(含 owner)一并作废,Auto 不得再按旧预算重试。
|
|
6151
|
+
clearAutoCloseAttempt(key);
|
|
4216
6152
|
sidebarManualIntentRef.current.delete(key);
|
|
4217
6153
|
return;
|
|
4218
6154
|
}
|
|
@@ -4223,6 +6159,8 @@
|
|
|
4223
6159
|
// intent === "close"
|
|
4224
6160
|
if (recordScoped) {
|
|
4225
6161
|
sidebarManualIntentRef.current.delete(key);
|
|
6162
|
+
// 手动关闭信号在这里就落持久标记(抑制写入要等验证收口,太晚;手动恒优先必须立刻生效)。
|
|
6163
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-close");
|
|
4226
6164
|
void handleSidebarAction(key, entry.address, SIDEBAR_TAB_ORIGIN_MANUAL);
|
|
4227
6165
|
return;
|
|
4228
6166
|
}
|
|
@@ -4233,14 +6171,17 @@
|
|
|
4233
6171
|
*/
|
|
4234
6172
|
sidebarAutoSuppressedRef.current.set(key, { sessionId: sidebarSessionId, rootSessionId, address: entry.address });
|
|
4235
6173
|
trimAutoKeyMap(sidebarAutoSuppressedRef.current);
|
|
6174
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-close");
|
|
4236
6175
|
return;
|
|
4237
6176
|
}
|
|
4238
6177
|
// 没有可关闭的 tab:只登记抑制与撤销自动记账,绝不为了「执行关闭」先打开一个 tab。
|
|
4239
6178
|
sidebarManualIntentRef.current.delete(key);
|
|
4240
6179
|
sidebarAutoSuppressedRef.current.set(key, { sessionId: sidebarSessionId, rootSessionId, address: entry.address });
|
|
4241
6180
|
trimAutoKeyMap(sidebarAutoSuppressedRef.current);
|
|
6181
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, entry.address, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-close");
|
|
4242
6182
|
sidebarAutoOriginRef.current.delete(key);
|
|
4243
|
-
|
|
6183
|
+
// 手动关闭意图接管这个 key:未结算的自动关闭预算(含 owner)一并作废。
|
|
6184
|
+
clearAutoCloseAttempt(key);
|
|
4244
6185
|
};
|
|
4245
6186
|
|
|
4246
6187
|
/**
|
|
@@ -4258,6 +6199,8 @@
|
|
|
4258
6199
|
*/
|
|
4259
6200
|
if (sidebarAutoCascadeRef.current !== true) sidebarAutoFailedKeysRef.current.clear();
|
|
4260
6201
|
syncSidebarTabRecords();
|
|
6202
|
+
// 关闭请求的验证链先跑:上一轮 close 的验证结果必须先收口,候选选择才按真实归属推进。
|
|
6203
|
+
verifyPendingSidebarCloses();
|
|
4261
6204
|
// Auto 开关是渲染输入:设置页保存或面板自身切换后必须重渲染一次(标题栏开关的勾选态)。
|
|
4262
6205
|
// 与批量签名同一模式:只有真的变化才 bump,空闲轮询绝不产生重渲染。
|
|
4263
6206
|
const autoNow = autoOpenEnabled();
|
|
@@ -4287,11 +6230,22 @@
|
|
|
4287
6230
|
* - `contentId === 资源地址`:同一个 kind 下也可能是另一个子代理的地址。
|
|
4288
6231
|
* 不满足时保持 >> 的打开语义(按钮照旧可再次点击打开),绝不猜测 tabId。
|
|
4289
6232
|
*
|
|
4290
|
-
* origin
|
|
4291
|
-
*
|
|
4292
|
-
*
|
|
6233
|
+
* origin 的来源优先级(缺陷 1 之后的定稿判据,**每一层都必须自带证据**):
|
|
6234
|
+
* 手动意图 / 持久 manual > 显式传入的动作来源(**且必须带因果证明**)> 已存在记录(**且 tabId
|
|
6235
|
+
* 必须相等**)> 在途打开记录(**且因果证明成立**)> realm 共享来源账本(tabId 逐字相等)>
|
|
6236
|
+
* 持久 auto(tabId 逐字相等)> **manual** 兜底。最后那条兜底正是规格要求:「外部已存在但未由
|
|
6237
|
+
* 自动动作发起的 tab 视为手动来源」,因此自动同步永远关不掉一个它没有亲手打开过的 tab。
|
|
6238
|
+
*
|
|
6239
|
+
* 为什么「本次动作声明的来源」还不够:宿主 openResource() 的公开契约里**没有返回值**(返回
|
|
6240
|
+
* void,见 lib/types/client/service.d.ts),而且默认 revealIfOpened=true —— 同一个
|
|
6241
|
+
* (kind, contentId) 已经有 tab 时它**揭示那一个**,绝不新建。所以「调用过 openResource」+
|
|
6242
|
+
* 「随后 inventory 里有一个同地址 tab」并不能证明那个 tab 是我们创建出来的:它完全可能是用户
|
|
6243
|
+
* 在等待窗口里从 DSH 其它入口打开的同一个资源。认领它就等于事后替用户关掉他的 tab。
|
|
6244
|
+
*
|
|
6245
|
+
* 因此 actionProof.autoProven 只由「发出 openResource **之前**亲眼确认 inventory 可读、且该
|
|
6246
|
+
* 地址没有已提交 tab」写成(见 handleSidebarAction 的因果证明点)。缺证明一律 manual。
|
|
4293
6247
|
*/
|
|
4294
|
-
const recordSidebarTab = (key, resourceAddress, actionOrigin) => {
|
|
6248
|
+
const recordSidebarTab = (key, resourceAddress, actionOrigin, actionProof) => {
|
|
4295
6249
|
if (closeSidebarResource === null) return false;
|
|
4296
6250
|
if (readActiveSidebarResource === null && readSidebarOpenTabs() === null) return false;
|
|
4297
6251
|
// 左箭头图标缺失时不会渲染 <<,因此也不该建立只在 << 上才有意义的记录。
|
|
@@ -4299,6 +6253,13 @@
|
|
|
4299
6253
|
const declaredOrigin = actionOrigin === SIDEBAR_TAB_ORIGIN_AUTO || actionOrigin === SIDEBAR_TAB_ORIGIN_MANUAL
|
|
4300
6254
|
? actionOrigin
|
|
4301
6255
|
: null;
|
|
6256
|
+
/**
|
|
6257
|
+
* 本次动作是否带**因果证明**:只有 handleSidebarAction 的自动路径会传它,而且只在
|
|
6258
|
+
* 「发出 openResource 之前 inventory 可读且该地址确实没有 tab」时为 true。
|
|
6259
|
+
* 手动路径带 null(不需要证明:手动动作恒按 manual 记账)。
|
|
6260
|
+
*/
|
|
6261
|
+
const declaredAutoProven = actionProof !== null && actionProof !== undefined
|
|
6262
|
+
&& actionProof.autoProven === true;
|
|
4302
6263
|
let tab = null;
|
|
4303
6264
|
const inventory = readSidebarOpenTabs();
|
|
4304
6265
|
if (inventory !== null) {
|
|
@@ -4331,23 +6292,211 @@
|
|
|
4331
6292
|
if (text(source.contentId, null) !== resourceAddress) return false;
|
|
4332
6293
|
const previous = sidebarTabRecordsRef.current.get(key);
|
|
4333
6294
|
const opening = sidebarTabOpeningRef.current.get(key);
|
|
6295
|
+
const previousScoped = previous !== undefined
|
|
6296
|
+
&& previous.sessionId === sidebarSessionId && previous.rootSessionId === rootSessionId
|
|
6297
|
+
? previous
|
|
6298
|
+
: undefined;
|
|
6299
|
+
const openingScoped = opening !== undefined
|
|
6300
|
+
&& opening.sessionId === sidebarSessionId && opening.rootSessionId === rootSessionId
|
|
6301
|
+
? opening
|
|
6302
|
+
: undefined;
|
|
6303
|
+
/**
|
|
6304
|
+
* 别的写入者证据(缺陷 1 的第二个判据):这次打开**还没有**把 openResource 发给宿主
|
|
6305
|
+
* (causalIssuedAt 还是 null),我们却已经能读到这个地址上的 tab —— 那只可能是别人先打开的
|
|
6306
|
+
* (用户从 DSH 其它入口、或另一个 surface)。这次动作从此不再是这个 tab 的因果来源,落地
|
|
6307
|
+
* 时一律按 manual 记账,并把它写进在途记录,后续任何一次落地观察都不会再翻案。
|
|
6308
|
+
*/
|
|
6309
|
+
if (openingScoped !== undefined
|
|
6310
|
+
&& (openingScoped.causalIssuedAt === null || openingScoped.causalIssuedAt === undefined)) {
|
|
6311
|
+
openingScoped.foreignWriter = true;
|
|
6312
|
+
}
|
|
4334
6313
|
/**
|
|
4335
6314
|
* 手动接管优先于调用方声明的来源:用户在那个 key 上留下过「要打开」的手动意图时,即使这次
|
|
4336
6315
|
* 打开是 Auto 发出的,最终 tab 也必须记成 manual——手动打开的最终来源必须是 manual,
|
|
4337
6316
|
* Auto 绝不能在资源结束后把它当成自己的 tab 关掉。
|
|
4338
6317
|
*/
|
|
4339
6318
|
const manualTakeover = sidebarManualIntentOf(key);
|
|
4340
|
-
|
|
6319
|
+
/**
|
|
6320
|
+
* 共享 Auto 来源账本(键与打开记录同构,见 sharedSidebarAutoOrigin)。
|
|
6321
|
+
*
|
|
6322
|
+
* 收养路径(面板重挂载后 / 切 root 后从 inventory 重建记录)没有「本次动作的显式来源」,
|
|
6323
|
+
* 实例内的 previous 与 opening 也都是空的;唯一能证明「这个 tab 是 Auto 亲手打开的」的
|
|
6324
|
+
* 就是这条跨实例账本。缺了它,收养只能落到 manual 兜底,Auto 从此不再管这个 tab。
|
|
6325
|
+
*
|
|
6326
|
+
* 只认显式记成 auto 的账本条目,并且必须同 session + 同 root、且绑定的 tabId 与当前证据
|
|
6327
|
+
* 逐字相等(见下面的绑定闸门):别的 scope 的条目一律不可见,来源未知的外部 tab、其它 pane
|
|
6328
|
+
* 的同地址 tab,以及「同地址但已经换了 tabId」的 tab 都不会被误收养成 Auto 的 tab。
|
|
6329
|
+
*/
|
|
6330
|
+
const sharedOrigin = sidebarAutoOriginRef.current.get(key);
|
|
6331
|
+
const sharedOriginScoped = sharedOrigin !== undefined
|
|
6332
|
+
&& sharedOrigin.sessionId === sidebarSessionId && sharedOrigin.rootSessionId === rootSessionId
|
|
6333
|
+
? sharedOrigin
|
|
6334
|
+
: undefined;
|
|
6335
|
+
/**
|
|
6336
|
+
* tabId 绑定闸门(缺陷 1,与持久条目那条闸门逐字同源,只是证据来自另一层):
|
|
6337
|
+
*
|
|
6338
|
+
* 共享账本的条目里记着「Auto 打开/替换落地那一刻亲眼看到的 tab」。只要求「有条目」是不够的:
|
|
6339
|
+
* 旧 tab 被用户或宿主移除而插件没有观察到时,同一个 realm 里的下一次收养(重挂载 / 记录被判
|
|
6340
|
+
* stale 后的重建)会在同地址上看到**用户新开的 tab**——它的 tabId 与条目里那个不一样。不比对
|
|
6341
|
+
* tabId 就按 auto 收养,等于替用户认领他刚打开的 tab,资源随后的 idle 就会把它自动关掉。
|
|
6342
|
+
*
|
|
6343
|
+
* 条目没有 tabId(null:这次自动打开已经发出、落地证据还没到)同样**不是** auto 证据:它只
|
|
6344
|
+
* 回答「这次运行是否已经为它发过打开」,任何归属判定都必须按「证据不足」处理。
|
|
6345
|
+
*/
|
|
6346
|
+
const sharedOriginTabId = sidebarAutoOriginTabIdOf(sharedOriginScoped);
|
|
6347
|
+
const sharedOriginBound = sharedOriginTabId !== null && sharedOriginTabId === tabId;
|
|
6348
|
+
const sharedOriginStale = sharedOriginScoped !== undefined && sharedOriginBound !== true;
|
|
6349
|
+
/**
|
|
6350
|
+
* 持久归属标记是「整页刷新 / 进程重启 / HMR 之后」唯一还活着的证据(见 SIDEBAR_AUTO_OWNERSHIP_KEY):
|
|
6351
|
+
* 命中 manual 一律 manual(手动恒优先,安全侧);命中 auto 还要过下面那条 tabId 绑定闸门才按
|
|
6352
|
+
* auto 收养;没有标记按既有 manual 兜底。内存(含 realm 共享账本)与持久层不一致时以 manual
|
|
6353
|
+
* 为准,并在下面把内存来源一并抹掉,绝不留「内存 auto / 持久 manual」的歧义。
|
|
6354
|
+
*/
|
|
6355
|
+
const persistedEntry = readSidebarAutoOwnershipEntry(sidebarSessionId, rootSessionId, resourceAddress);
|
|
6356
|
+
const persistedManual = persistedEntry !== null && persistedEntry.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL;
|
|
6357
|
+
/**
|
|
6358
|
+
* tabId 绑定闸门(P1-A):持久 auto 条目只认「写入时那个 tab」。
|
|
6359
|
+
*
|
|
6360
|
+
* 条目里的 tabId 是记录这条 auto 归属时宿主 inventory 里这个地址的 tab。整页刷新之后持久条目
|
|
6361
|
+
* 是唯一还活着的证据,而右栏里同地址的 tab 完全可能是**另一次 tab 创建**出来的(旧 tab 被用户
|
|
6362
|
+
* 或宿主移除而插件没观察到、用户随后从 DSH 其它入口打开同一地址)。不比对 tabId 就按 auto 收养,
|
|
6363
|
+
* 等于替用户认领他刚打开的 tab——资源随后 idle,Auto 就会把它关掉。
|
|
6364
|
+
*
|
|
6365
|
+
* 判定顺序(三档,manual 恒优先):
|
|
6366
|
+
* 1. manual:手动意图(manualIntentOpen)/ 持久 manual 一律 manual,安全侧;
|
|
6367
|
+
* 2. 陈旧 auto:持久条目的 tabId 与当前证据不符(或旧格式条目根本没记 tabId)⇒ 它**不再**
|
|
6368
|
+
* 作为 auto 证据参与收养。若内存里也没有别的来源证据,最终落到下面的 manual 兜底,并在统一
|
|
6369
|
+
* 写入点把这条陈旧条目改写成 manual(理由 manual-stale-auto),避免它长期误导后续判断;
|
|
6370
|
+
* 3. auto:只有「内存来源证据」或「tabId 逐字相等的持久 auto」才认 auto。
|
|
6371
|
+
*
|
|
6372
|
+
* 为什么内存证据(本次动作声明的来源 / 已有记录 / 在途打开)仍然优先:它们是**本 realm 亲眼
|
|
6373
|
+
* 观察到的** Auto 动作;但「亲眼观察」必须落实到**证据**上,不能只凭「有一个 auto 来源」:
|
|
6374
|
+
* - 本次动作声明的来源(declaredOrigin):必须带因果证明(actionProof.autoProven,见上面的
|
|
6375
|
+
* 说明)——宿主 openResource 没有返回值、而且默认是「已存在就揭示」,光调用过它不足以
|
|
6376
|
+
* 证明随后出现的那个 tab 是我们创建的;
|
|
6377
|
+
* - 已有记录(previous.origin):必须 previous.tabId === 当前落地 tabId —— 记录说的是
|
|
6378
|
+
* 「T 这个 tab 归 Auto」,宿主换了一个新 id 之后这条记录已经不指向任何还在我们手里的 tab;
|
|
6379
|
+
* - 在途打开(opening):必须 causalProof === "proven"(发出之前亲眼确认地址上没有 tab)、
|
|
6380
|
+
* causalIssuedAt 非空(openResource 真的发出去过)、且 foreignWriter 未置位(期间没有
|
|
6381
|
+
* 观察到别的写入者)。
|
|
6382
|
+
* 而 realm 共享来源账本与持久条目各要多过一道 tabId 逐字相等的绑定闸门。任何一层缺证据都
|
|
6383
|
+
* 按安全侧落 manual:宁可漏收一次,也绝不误关用户刚打开的 tab。
|
|
6384
|
+
*
|
|
6385
|
+
* 取舍(刻意):本机页面刷新时宿主从它自己的持久化布局里带回**同一批 tabId**,因此正常刷新场景
|
|
6386
|
+
* 仍然恢复 auto;只有宿主真的重新 mint 了 id 时才退化成 manual——宁可漏收一次(那个 tab 留在
|
|
6387
|
+
* 右栏里交给用户手动处理,绝不会自己消失),也绝不误关一个可能是用户刚打开的 tab。
|
|
6388
|
+
*/
|
|
6389
|
+
const persistedAutoBound = persistedEntry !== null
|
|
6390
|
+
&& persistedEntry.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO
|
|
6391
|
+
&& persistedEntry.tabId !== null
|
|
6392
|
+
&& persistedEntry.tabId === tabId;
|
|
6393
|
+
const persistedStaleAuto = persistedEntry !== null
|
|
6394
|
+
&& persistedEntry.origin === SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO
|
|
6395
|
+
&& persistedAutoBound !== true;
|
|
6396
|
+
/**
|
|
6397
|
+
* 内存两层的证据闸门(缺陷 1):
|
|
6398
|
+
* - previous:记录必须**绑定当前这个 tabId**,否则那条 auto 记录描述的是另一个已经不存在的
|
|
6399
|
+
* tab(宿主重 mint / 回收),继承它就等于替用户认领他刚打开的 tab;
|
|
6400
|
+
* - opening:因果证明成立、openResource 真的发出过、期间没有别的写入者(见 causalProof /
|
|
6401
|
+
* causalIssuedAt / foreignWriter 的说明)。
|
|
6402
|
+
*/
|
|
6403
|
+
const previousUsableAuto = previousScoped !== undefined
|
|
6404
|
+
&& previousScoped.origin === SIDEBAR_TAB_ORIGIN_AUTO
|
|
6405
|
+
&& previousScoped.tabId === tabId;
|
|
6406
|
+
const openingUsableAuto = openingScoped !== undefined
|
|
6407
|
+
&& openingScoped.origin === SIDEBAR_TAB_ORIGIN_AUTO
|
|
6408
|
+
&& openingScoped.causalProof === "proven"
|
|
6409
|
+
&& openingScoped.causalIssuedAt !== null && openingScoped.causalIssuedAt !== undefined
|
|
6410
|
+
&& openingScoped.foreignWriter !== true;
|
|
6411
|
+
/**
|
|
6412
|
+
* 声明的来源也要过证据闸门:声明 auto 但缺因果证明时**直接落 manual**,绝不继续借用更弱的
|
|
6413
|
+
* 层(那正是缺陷 1 的误关形状:这次落地可能压根不是我们的动作打出来的那个 tab)。
|
|
6414
|
+
*/
|
|
6415
|
+
const declaredUsable = declaredOrigin === SIDEBAR_TAB_ORIGIN_AUTO
|
|
6416
|
+
? (declaredAutoProven === true ? SIDEBAR_TAB_ORIGIN_AUTO : SIDEBAR_TAB_ORIGIN_MANUAL)
|
|
6417
|
+
: declaredOrigin;
|
|
6418
|
+
const manualIntentOpen = manualTakeover !== undefined && manualTakeover.intent === "open";
|
|
6419
|
+
const origin = manualIntentOpen || persistedManual
|
|
4341
6420
|
? SIDEBAR_TAB_ORIGIN_MANUAL
|
|
4342
|
-
: (
|
|
4343
|
-
?? (
|
|
4344
|
-
?
|
|
4345
|
-
:
|
|
4346
|
-
|
|
4347
|
-
|
|
4348
|
-
|
|
4349
|
-
|
|
6421
|
+
: (declaredUsable
|
|
6422
|
+
?? (previousUsableAuto === true
|
|
6423
|
+
? SIDEBAR_TAB_ORIGIN_AUTO
|
|
6424
|
+
: (openingUsableAuto === true
|
|
6425
|
+
? SIDEBAR_TAB_ORIGIN_AUTO
|
|
6426
|
+
: (sharedOriginBound === true
|
|
6427
|
+
? SIDEBAR_TAB_ORIGIN_AUTO
|
|
6428
|
+
: (persistedAutoBound === true ? SIDEBAR_TAB_ORIGIN_AUTO : SIDEBAR_TAB_ORIGIN_MANUAL)))));
|
|
4350
6429
|
const recordOrigin = origin === SIDEBAR_TAB_ORIGIN_AUTO ? SIDEBAR_TAB_ORIGIN_AUTO : SIDEBAR_TAB_ORIGIN_MANUAL;
|
|
6430
|
+
/**
|
|
6431
|
+
* 证据存在但 tabId 对不上(或根本没有 tabId)时,那条共享账本条目已经被这一轮判定为**不是**
|
|
6432
|
+
* 本次归属的证据,必须就地清掉:它会一直躺在 realm 账本里,在下一次收养里继续参与判断
|
|
6433
|
+
* (长期误导),也会让「本次运行已经为它发过打开」这条去重记账与真实状态脱节。
|
|
6434
|
+
*
|
|
6435
|
+
* 清掉不会造成重复打开:这个地址此刻确实有 tab(收养的前提就是 inventory 里读到了它),
|
|
6436
|
+
* autoOpenCandidate 的「inventory 里已经有这个地址的 tab」判据会照常跳过。持久 manual 与
|
|
6437
|
+
* 内存 auto 的歧义同样按 manual 清理(既有语义)。
|
|
6438
|
+
*/
|
|
6439
|
+
if (sharedOriginStale === true
|
|
6440
|
+
|| (persistedManual === true && sharedOriginScoped !== undefined)) {
|
|
6441
|
+
sidebarAutoOriginRef.current.delete(key);
|
|
6442
|
+
}
|
|
6443
|
+
/**
|
|
6444
|
+
* 归属成立(auto)时,把**当前亲眼观察到的 tabId** 写进共享来源账本:关闭候选的遍历与
|
|
6445
|
+
* 「绝不重复打开」的记账都长在这份账本上,两者本来就是同一份归属证据;缺了它,收养出来的
|
|
6446
|
+
* record 虽然是 auto,Auto 却永远不会再为它选出关闭候选(仍然漏收)。
|
|
6447
|
+
*
|
|
6448
|
+
* 这里也是**唯一**允许刷新 tabId 的位置之一(另一个是 handleSidebarAction 里 openResource
|
|
6449
|
+
* 成功落地的那次调用):tabId 一律来自本次从宿主 inventory / active 读到的证据,绝不缓存、
|
|
6450
|
+
* 绝不猜测。刻意不做任何限容淘汰——归属容量由 autoOpenCandidate 在发出 openResource 之前
|
|
6451
|
+
* fail-closed 判定(见 autoSidebarOwnershipHasCapacity),收养路径绝不允许挤掉别的 scope
|
|
6452
|
+
* 仍然有效的 owner。
|
|
6453
|
+
*/
|
|
6454
|
+
if (recordOrigin === SIDEBAR_TAB_ORIGIN_AUTO) {
|
|
6455
|
+
sidebarAutoOriginRef.current.set(
|
|
6456
|
+
key,
|
|
6457
|
+
sidebarAutoOriginEntry(sidebarSessionId, rootSessionId, resourceAddress, tabId),
|
|
6458
|
+
);
|
|
6459
|
+
}
|
|
6460
|
+
/**
|
|
6461
|
+
* 归属标记与内存账本在**同一处**收口(写入 / 删除同源):
|
|
6462
|
+
* - auto:DEG 自己成功打开(openIssued 成功落地)时写 auto-open;收养证据证明是 Auto 时写
|
|
6463
|
+
* auto-adopt。同一地址此前若是 manual,必须由这次自动打开改回 auto(这是插件新开的一次自动行为);
|
|
6464
|
+
* - manual:手动打开 / 手动接管 / 来源未知的外部 tab 一律写 manual(手动恒优先)。
|
|
6465
|
+
*/
|
|
6466
|
+
writeSidebarAutoOwnership(
|
|
6467
|
+
sidebarSessionId,
|
|
6468
|
+
rootSessionId,
|
|
6469
|
+
resourceAddress,
|
|
6470
|
+
recordOrigin === SIDEBAR_TAB_ORIGIN_AUTO ? SIDEBAR_AUTO_OWNERSHIP_ORIGIN_AUTO : SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL,
|
|
6471
|
+
recordOrigin === SIDEBAR_TAB_ORIGIN_AUTO
|
|
6472
|
+
? (declaredOrigin === SIDEBAR_TAB_ORIGIN_AUTO ? "auto-open" : "auto-adopt")
|
|
6473
|
+
/**
|
|
6474
|
+
* 陈旧 auto 被降级成 manual 时用独立理由:诊断里据此能区分「用户手动接管」
|
|
6475
|
+
* (manual-takeover)与「某条 auto 证据的 tabId 与当前 tab 不符,按安全侧退让」两种完全
|
|
6476
|
+
* 不同的原因,事后排查「这个 tab 为什么没被自动收回」时才有的放矢。
|
|
6477
|
+
*
|
|
6478
|
+
* - manual-stale-auto:持久条目的 tabId 与当前 tab 不符(跨整页刷新的那条证据);
|
|
6479
|
+
* - manual-stale-origin:realm 共享来源账本的 tabId 与当前 tab 不符或缺席(同一次页面
|
|
6480
|
+
* 会话内、宿主重 mint 了 tabId 而插件没有观察到那次替换);
|
|
6481
|
+
* - manual-unproven-open:本次自动打开**没有**因果证明(发出前没能确认地址上没有 tab),
|
|
6482
|
+
* 或因果证明成立却在途期间观察到了别的写入者——落地到的这个 tab 无法与「用户自己打开的
|
|
6483
|
+
* 同一个资源」区分,按安全侧落 manual(缺陷 1)。
|
|
6484
|
+
*/
|
|
6485
|
+
: (manualIntentOpen === true
|
|
6486
|
+
? "manual-open"
|
|
6487
|
+
: (persistedStaleAuto === true
|
|
6488
|
+
? "manual-stale-auto"
|
|
6489
|
+
: (sharedOriginStale === true
|
|
6490
|
+
? "manual-stale-origin"
|
|
6491
|
+
: (declaredOrigin === SIDEBAR_TAB_ORIGIN_AUTO && declaredAutoProven !== true
|
|
6492
|
+
? "manual-unproven-open"
|
|
6493
|
+
: (openingScoped !== undefined && openingScoped.origin === SIDEBAR_TAB_ORIGIN_AUTO
|
|
6494
|
+
&& openingUsableAuto !== true && previousUsableAuto !== true
|
|
6495
|
+
? "manual-unproven-open"
|
|
6496
|
+
: "manual-takeover"))))),
|
|
6497
|
+
// 条目与内存账本同源写入当前的 tabId:下一次刷新后的收养按它比对(见上面的绑定闸门)。
|
|
6498
|
+
tabId,
|
|
6499
|
+
);
|
|
4351
6500
|
if (previous !== undefined && previous.sessionId === sidebarSessionId
|
|
4352
6501
|
&& previous.rootSessionId === rootSessionId && previous.tabId === tabId) {
|
|
4353
6502
|
previous.title = tabTitle ?? previous.title;
|
|
@@ -4371,23 +6520,45 @@
|
|
|
4371
6520
|
* origin 是**内部**参数,默认 manual:普通 UI 调用(箭头、键盘)一律手动来源;只有自动同步
|
|
4372
6521
|
* 显式传 auto。它决定三件事:记录来源、手动动作是否清除抑制/自动来源、关闭时是否登记抑制。
|
|
4373
6522
|
*
|
|
4374
|
-
* autoAction 也是**内部**参数,只在自动路径上出现:{ kind, epoch, attemptsBefore }
|
|
4375
|
-
*
|
|
4376
|
-
*
|
|
6523
|
+
* autoAction 也是**内部**参数,只在自动路径上出现:{ kind, epoch, attemptsBefore, attemptToken }。
|
|
6524
|
+
* 它让同一条实现能在每个 await 之后、真正调用宿主 open/close 之前复核「Auto 是否仍然开启、动作
|
|
6525
|
+
* 是否已过期、用户是否已经手动接管」,并在收尾时无条件释放在途预留(见 finally)。关闭类候选还
|
|
6526
|
+
* 带着预支预算时新建的 attemptToken:回滚/收口共享重试计数只认这份不可复用的所有权凭据。
|
|
4377
6527
|
*/
|
|
4378
6528
|
const handleSidebarAction = async (key, resourceAddress, actionOrigin, autoAction) => {
|
|
4379
6529
|
const origin = actionOrigin === SIDEBAR_TAB_ORIGIN_AUTO ? SIDEBAR_TAB_ORIGIN_AUTO : SIDEBAR_TAB_ORIGIN_MANUAL;
|
|
6530
|
+
/**
|
|
6531
|
+
* 手动来源的动作在入口就把归属标记改写成 manual(手动恒优先,且必须在任何 await 之前落盘):
|
|
6532
|
+
* 有记录 ⇒ 用户在关闭这个 tab(manual-close);没有记录 ⇒ 用户在打开它(manual-open)。
|
|
6533
|
+
* 这条写入同时抹掉内存里的共享来源,绝不留「内存 auto / 持久 manual」的歧义。
|
|
6534
|
+
*/
|
|
6535
|
+
if (origin === SIDEBAR_TAB_ORIGIN_MANUAL) {
|
|
6536
|
+
const manualRecord = sidebarTabRecordsRef.current.get(key);
|
|
6537
|
+
writeSidebarAutoOwnership(
|
|
6538
|
+
sidebarSessionId,
|
|
6539
|
+
rootSessionId,
|
|
6540
|
+
resourceAddress,
|
|
6541
|
+
SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL,
|
|
6542
|
+
manualRecord === undefined ? "manual-open" : "manual-close",
|
|
6543
|
+
);
|
|
6544
|
+
}
|
|
4380
6545
|
const autoContext = origin === SIDEBAR_TAB_ORIGIN_AUTO && autoAction !== null && typeof autoAction === "object"
|
|
4381
6546
|
? {
|
|
4382
6547
|
kind: autoAction.kind === "close" ? "close" : "open",
|
|
4383
6548
|
epoch: Number.isFinite(Number(autoAction.epoch)) ? Number(autoAction.epoch) : sidebarAutoEpochRef.current,
|
|
4384
6549
|
attemptsBefore: Number.isFinite(Number(autoAction.attemptsBefore)) ? Number(autoAction.attemptsBefore) : 0,
|
|
6550
|
+
// 只有候选选择真的登记过一份令牌时才带上它:缺失/畸形一律按 null 处理,后续回滚因此
|
|
6551
|
+
// fail-safe 地放弃(绝不按 key 盲写共享计数)。
|
|
6552
|
+
attemptToken: autoAction.attemptToken !== null && autoAction.attemptToken !== undefined
|
|
6553
|
+
&& typeof autoAction.attemptToken === "object"
|
|
6554
|
+
? autoAction.attemptToken
|
|
6555
|
+
: null,
|
|
4385
6556
|
}
|
|
4386
6557
|
: null;
|
|
4387
6558
|
// React 重挂载或 root 切换后,旧 DOM 可能短暂保留旧 handler;它不能操作当前 session-scoped 服务。
|
|
4388
|
-
|
|
4389
|
-
|
|
4390
|
-
|
|
6559
|
+
// 这里的判据含不可复用的 surface 令牌:同一个实例 A→B→A 之后,旧 handler 手里的字符串会重新
|
|
6560
|
+
// 相等,只有令牌能证明它已经不属于当前 surface。
|
|
6561
|
+
if (sidebarSurfaceStillCurrent() !== true) {
|
|
4391
6562
|
/**
|
|
4392
6563
|
* 连入口都没通过的自动动作:这里必须自己释放候选选择时写下的预留(以及自动关闭的重试记账)。
|
|
4393
6564
|
* 这些键属于已经被换掉的 surface,当前闭包之后再也不会为它们做清理。
|
|
@@ -4431,15 +6602,133 @@
|
|
|
4431
6602
|
}
|
|
4432
6603
|
// 关闭态:只调用记录里的精确 tabId。绝不根据 active() 当前是谁来决定关哪个 tab。
|
|
4433
6604
|
if (record !== undefined && closeSidebarResource !== null) {
|
|
4434
|
-
|
|
4435
|
-
|
|
4436
|
-
|
|
4437
|
-
|
|
4438
|
-
|
|
4439
|
-
|
|
4440
|
-
|
|
6605
|
+
/**
|
|
6606
|
+
* 关闭的唯一执行入口(见 closeSidebarTabWithLease):
|
|
6607
|
+
* - 手动单项(用户触发):同一个 tabId 上已经有一次关闭在途时等待它结算——上次成功就当作
|
|
6608
|
+
* 这个 tab 已经被关掉(绝不再 close),上次失败才用**当前** inventory 证明同一个 tabId
|
|
6609
|
+
* 仍在之后做一次有限重试。用户的关闭意图因此既不会重复,也不会在竞争失败时被静默丢失;
|
|
6610
|
+
* - 自动动作:遇到在途关闭立刻让位,绝不 await(Auto 同步绝不能被一次永不结算的宿主
|
|
6611
|
+
* Promise 拖住),并回退本轮 closeAttempts/预留、记入本次级联的失败屏障。
|
|
6612
|
+
*/
|
|
6613
|
+
/**
|
|
6614
|
+
* 这次关闭出发时看到的 split 意图身份(不可复用令牌)。
|
|
6615
|
+
*
|
|
6616
|
+
* 它的作用域**只到这次关闭**:收口时只有当前意图仍然是这一份才允许取消(见
|
|
6617
|
+
* cancelPendingSidebarSplitOfClose)。只按 key 取消的旧写法会把验证窗口里出现的
|
|
6618
|
+
* 同 key 新 generation 的 split/open 事务一起掐掉。出发时没有意图就记 null——
|
|
6619
|
+
* 那一刻之后出现的任何意图都只属于后来者,这次关闭一律不碰。
|
|
6620
|
+
*/
|
|
6621
|
+
const splitIntentAtClose = sidebarSplitIntentRef.current;
|
|
6622
|
+
const closeSplitIntentToken = splitIntentAtClose !== null && splitIntentAtClose.key === key
|
|
6623
|
+
? splitIntentAtClose.token
|
|
6624
|
+
: null;
|
|
6625
|
+
const closeOutcome = await closeSidebarTabWithLease(record.tabId, {
|
|
6626
|
+
waitForCompeting: origin === SIDEBAR_TAB_ORIGIN_MANUAL,
|
|
6627
|
+
/**
|
|
6628
|
+
* 验证上下文:close 请求 resolve 之后必须由 inventory 的精确 tabId 证据收口。
|
|
6629
|
+
* 手动关闭同样要验证(attemptToken = null ⇒ 验证成功后按手动语义登记抑制)。
|
|
6630
|
+
* splitIntentToken 随验证记录一起保留:验证链的收口可能在若干轮同步之后才发生。
|
|
6631
|
+
*/
|
|
6632
|
+
verify: {
|
|
6633
|
+
key,
|
|
6634
|
+
address: resourceAddress,
|
|
6635
|
+
attemptToken: autoContext === null ? null : autoContext.attemptToken,
|
|
6636
|
+
manual: origin === SIDEBAR_TAB_ORIGIN_MANUAL,
|
|
6637
|
+
splitIntentToken: closeSplitIntentToken,
|
|
6638
|
+
},
|
|
6639
|
+
});
|
|
6640
|
+
|
|
6641
|
+
/**
|
|
6642
|
+
* await 之后的 surface 身份闸门(单项关闭的收尾边界,与批量入口同一条判据)。
|
|
6643
|
+
*
|
|
6644
|
+
* 这次 await 可能跨越一次组件重挂载或 root / sidebar session 切换:本闭包里的 ref、
|
|
6645
|
+
* records 与快照都已经不属于当前 surface,而**共享**的 Auto 来源 / 抑制 / 重试记账却是
|
|
6646
|
+
* 同一份。此时若还按旧闭包继续收尾(删记录、删共享来源、登记抑制、bump)并调用旧闭包的
|
|
6647
|
+
* syncSidebarTabs(),旧快照会把新 Panel 刚刚写入的**其它** Auto 来源当成「已经离开当前
|
|
6648
|
+
* 快照」而清掉——新 Panel 随后再也认不出自己打开过的 tab,资源结束后也不会自动关闭它。
|
|
6649
|
+
*
|
|
6650
|
+
* 因此任何返回结果(closed / failed / settled-closed / contended / unreadable / stale)
|
|
6651
|
+
* 都必须在写共享账本、删记录、登记抑制或调用旧闭包同步**之前**复核 surface 身份;任一失配
|
|
6652
|
+
* 立即停止本实例的后续收尾。判据含不可复用的 surface 令牌:同一个实例 A→B→A 之后
|
|
6653
|
+
* root/sidebar session 字符串会重新相等,只有令牌能证明这次收尾已经不属于当前 surface
|
|
6654
|
+
* (否则旧动作会删掉 A 里已经换成新 tabId 的 record / Auto 来源)。租约已经由
|
|
6655
|
+
* closeSidebarTabWithLease 自己的 finally 结算并归还(这里绝不重复释放),旧 tab 的归属交给
|
|
6656
|
+
* 新 Panel 后续同步按真实 inventory 结算:成功关掉的由那次同步收口,失败 / 还没落地的则仍
|
|
6657
|
+
* 留在 inventory 里等下一轮有界重试。
|
|
6658
|
+
*/
|
|
6659
|
+
if (sidebarSurfaceStillCurrent() !== true) {
|
|
6660
|
+
return;
|
|
6661
|
+
}
|
|
6662
|
+
if (closeOutcome.status === "contended" || closeOutcome.status === "contended-timeout") {
|
|
6663
|
+
/**
|
|
6664
|
+
* 让位路径(自动动作):这次关闭根本没有发出,因此必须归还候选选择时预支的那一次重试
|
|
6665
|
+
* 预算与在途预留,否则一次「有人在关」的等待就会白烧掉一次有界重试,甚至让 Auto 提前
|
|
6666
|
+
* 放弃这个 tab。**绝不在这里清理来源**:来源只在关闭真的成功后才允许撤销(失败 / 让位
|
|
6667
|
+
* 都必须继续归 Auto 管,留给后续同步重试)。
|
|
6668
|
+
*/
|
|
6669
|
+
if (autoContext !== null) {
|
|
6670
|
+
sidebarAutoReservationRef.current.delete(key);
|
|
6671
|
+
releaseAutoCloseAttempt(key, autoContext);
|
|
6672
|
+
/**
|
|
6673
|
+
* 同时记进本次级联的失败屏障:这次关闭没有发出,但它绝不能在**同一批微任务级联**里被
|
|
6674
|
+
* 重新选中(候选与执行之间只隔一次微任务,动作收尾的尾随同步会立刻再选一次;若冲突
|
|
6675
|
+
* 持续存在,那会变成不让出宏任务的微任务死循环)。屏障在下一次外部同步轮自动失效,
|
|
6676
|
+
* 那时锁通常已经归还,重试照常。
|
|
6677
|
+
*/
|
|
6678
|
+
sidebarAutoFailedKeysRef.current.add(key);
|
|
6679
|
+
}
|
|
6680
|
+
return;
|
|
6681
|
+
}
|
|
6682
|
+
/**
|
|
6683
|
+
* 只有拿到「已经关掉」的结算才收口:亲手关闭成功,或等待竞争租约后拿到成功 / inventory
|
|
6684
|
+
* 已证明 tab 消失的结算。失败、inventory 不可读(fail-closed)与「有人接手」都不允许在
|
|
6685
|
+
* 这里改写记录或来源——记录只由真实结算(这里或既有同步器)收口,绝不因为「这次不是自己
|
|
6686
|
+
* 亲手关的」就跳过收口,否则会留下一份与宿主 inventory 不符的账。
|
|
6687
|
+
*/
|
|
6688
|
+
if (closeOutcome.status === "unreadable") {
|
|
6689
|
+
// preflight 没通过:close 根本没有发出 → 按令牌回滚这次预支,绝不清理归属。
|
|
6690
|
+
if (autoContext !== null) {
|
|
6691
|
+
sidebarAutoReservationRef.current.delete(key);
|
|
6692
|
+
releaseAutoCloseAttempt(key, autoContext);
|
|
6693
|
+
sidebarAutoFailedKeysRef.current.add(key);
|
|
6694
|
+
}
|
|
6695
|
+
return;
|
|
6696
|
+
}
|
|
6697
|
+
if (closeOutcome.status === "stale") {
|
|
6698
|
+
// 等待期间 surface 换代:close 没有发出 → 同样按令牌回滚,旧 tab 交给新 generation 收口。
|
|
6699
|
+
if (autoContext !== null) {
|
|
6700
|
+
sidebarAutoReservationRef.current.delete(key);
|
|
6701
|
+
releaseAutoCloseAttempt(key, autoContext);
|
|
6702
|
+
}
|
|
6703
|
+
return;
|
|
6704
|
+
}
|
|
6705
|
+
if (closeOutcome.status === "failed" || closeOutcome.status === "timeout") {
|
|
6706
|
+
/**
|
|
6707
|
+
* 请求真的发出去过(reject 或 watchdog 超时):**绝不回滚 count**——回滚就等于把三次快速
|
|
6708
|
+
* 上限又还给它,实际 close 次数会突破上限。record / origin / 冷却一律保留,留给后续同步重试。
|
|
6709
|
+
*/
|
|
6710
|
+
sidebarAutoFailedKeysRef.current.add(key);
|
|
6711
|
+
return;
|
|
6712
|
+
}
|
|
6713
|
+
if (closeOutcome.status === "request-resolved-unverified") {
|
|
6714
|
+
/**
|
|
6715
|
+
* resolve 只代表请求完成:验证链已经登记在共享账本里,record / origin / attempt 全部保留。
|
|
6716
|
+
* 这里直接返回,绝不落到下面的 openResource 分支,也绝不当成「已经关掉」收口。
|
|
6717
|
+
*/
|
|
6718
|
+
return;
|
|
4441
6719
|
}
|
|
4442
|
-
|
|
6720
|
+
/**
|
|
6721
|
+
* verified-closed:精确 inventory 证据证明这个 tab 已经不在;
|
|
6722
|
+
* verified-recycled:这个 tabId 已经被宿主回收给另一个资源(地址不一致)——旧 tab 已经
|
|
6723
|
+
* 消失、close 一次也没有发出,但「这个 key 已经没有自己的 tab」这个结论与 verified-closed
|
|
6724
|
+
* 完全等价,因此收口规则一致(下面的 (key, tabId) 一致性闸门照旧生效);
|
|
6725
|
+
* closed:旧宿主没有 inventory 读面时的手动关闭(历史语义,用户意图优先)。
|
|
6726
|
+
* 只有这三种结算允许收口归属。
|
|
6727
|
+
*/
|
|
6728
|
+
if (closeOutcome.status === "verified-closed" || closeOutcome.status === "closed"
|
|
6729
|
+
|| closeOutcome.status === "verified-recycled") {
|
|
6730
|
+
|
|
6731
|
+
|
|
4443
6732
|
/**
|
|
4444
6733
|
* 关闭成功后一起收口这个 key 上尚未结算的分栏事务。
|
|
4445
6734
|
*
|
|
@@ -4451,21 +6740,57 @@
|
|
|
4451
6740
|
*
|
|
4452
6741
|
* 只有同 key 的意图会被取消:别的行的在途打开照旧继续。
|
|
4453
6742
|
*/
|
|
4454
|
-
|
|
4455
|
-
|
|
4456
|
-
|
|
6743
|
+
/**
|
|
6744
|
+
* (key, tabId) 一致性闸门:只有这个 key 当前记录的 tabId 仍是本次动作关闭的那一个,才允许
|
|
6745
|
+
* 收口 record / origin。宿主换过 tabId(旧 tab 消失、同一个资源换成新 tab)时,旧代次的
|
|
6746
|
+
* 结算只能清理它自己那一笔预算,绝不能删掉新 generation 的 record 与 Auto 归属。
|
|
6747
|
+
*/
|
|
6748
|
+
const currentRecord = sidebarTabRecordsRef.current.get(key);
|
|
6749
|
+
const recordStillSame = currentRecord !== undefined && currentRecord.tabId === record.tabId;
|
|
6750
|
+
/**
|
|
6751
|
+
* 分栏事务只收口**这次关闭出发时看到的那一份意图**:这次关闭确实发生了,事务必须收口
|
|
6752
|
+
* (否则右栏停在临时 50%);但同一个 key 上如果已经出现新 generation 的 split/open
|
|
6753
|
+
* 事务(用户或 Auto 重新打开了这个资源),旧 close 的结算绝不取消它——那会把新一次打开
|
|
6754
|
+
* 的 pane 归属与临时扩栏一起打断。令牌逐对象比较,A→B→A 或同 key 重开都无法冒充。
|
|
6755
|
+
*/
|
|
6756
|
+
cancelPendingSidebarSplitOfClose(key, closeSplitIntentToken);
|
|
6757
|
+
if (recordStillSame === true) {
|
|
6758
|
+
sidebarTabRecordsRef.current.delete(key);
|
|
6759
|
+
}
|
|
6760
|
+
// 重试预算按所有权收口:手动关闭恒优先,直接清空;自动关闭只有 owner 仍是本次动作的
|
|
6761
|
+
// 令牌时才清空(旧代次的迟到成功结算绝不把后来者重新预支的预算一起清零)。
|
|
6762
|
+
settleAutoCloseAttempt(key, autoContext);
|
|
6763
|
+
|
|
4457
6764
|
/**
|
|
4458
6765
|
* 关闭成功后收口来源与抑制记账(两种开放的语义差别就在这两行):
|
|
4459
6766
|
*
|
|
4460
6767
|
* - 自动关闭:只撤销来源标记——本次运行不会再对同一个资源重复动作;
|
|
4461
6768
|
* - 手动关闭:除撤销来源外还要登记**抑制**,Auto 不得立刻把它重新打开。抑制只由
|
|
4462
6769
|
* 用户手动重新打开同一资源清除(手动意图优先)。
|
|
6770
|
+
*
|
|
6771
|
+
* 「等待竞争租约后拿到成功结算」同样走这里:tab 确实已经被关掉,收口规则与亲手关闭一致;
|
|
6772
|
+
* 反过来说,让位 / 失败 / inventory 不可读的路径一律在上面 return,绝不提前清理来源。
|
|
4463
6773
|
*/
|
|
4464
|
-
|
|
4465
|
-
|
|
4466
|
-
|
|
4467
|
-
|
|
6774
|
+
// 来源与抑制同样只在这个 key 仍然指向本次关闭的那个 tabId 时收口:否则删掉的会是
|
|
6775
|
+
// 新 generation 刚刚为**新 tabId** 写下的 Auto 归属。
|
|
6776
|
+
if (recordStillSame === true && closeOutcome.status === "verified-recycled") {
|
|
6777
|
+
/**
|
|
6778
|
+
* 地址复用证明旧 tab 已经消失:这个 key 的失败冷却也随之失效,必须一起清掉。否则一条
|
|
6779
|
+
* 永远等不到自己 tab 的冷却(最长 15 分钟)会白白屏蔽这个 key 后续的真实关闭。
|
|
6780
|
+
* 仍然只在 record 仍指向本次证明消失的那个 tabId 时清理:后来者已经接管这个 key 时,
|
|
6781
|
+
* 它的冷却记账不属于这次结算(与 finishVerifiedSidebarClose 的 sameTab 闸门同源)。
|
|
6782
|
+
*/
|
|
6783
|
+
sidebarAutoCloseCooldownsRef.current.delete(key);
|
|
6784
|
+
}
|
|
6785
|
+
if (recordStillSame === true) {
|
|
6786
|
+
sidebarAutoOriginRef.current.delete(key);
|
|
6787
|
+
if (origin === SIDEBAR_TAB_ORIGIN_MANUAL) {
|
|
6788
|
+
sidebarAutoSuppressedRef.current.set(key, { sessionId: sidebarSessionId, rootSessionId, address: resourceAddress });
|
|
6789
|
+
trimAutoKeyMap(sidebarAutoSuppressedRef.current);
|
|
6790
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, resourceAddress, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-close");
|
|
6791
|
+
}
|
|
4468
6792
|
}
|
|
6793
|
+
|
|
4469
6794
|
bump((value) => value + 1);
|
|
4470
6795
|
// 关闭改变了右栏组成,必须立刻重估一次:宽度与手柄锁都在同一条同步链路上。
|
|
4471
6796
|
syncSidebarTabs();
|
|
@@ -4485,6 +6810,17 @@
|
|
|
4485
6810
|
if (autoContext === null) return "proceed";
|
|
4486
6811
|
if (autoContext === null) return "proceed";
|
|
4487
6812
|
if (autoActionStillValid(autoContext) !== true) return "abort";
|
|
6813
|
+
/**
|
|
6814
|
+
* 这里刻意**不**再加一道「持久 manual ⇒ abort」的闸门(持久抑制的判据只落在候选选择处,
|
|
6815
|
+
* 见 autoOpenCandidate)。原因:这条路是「候选已经选中、正在等宿主布局」的在途窗口,窗口里
|
|
6816
|
+
* 出现的 manual 条目可能来自用户**手动打开同一个资源**(handleSidebarAction 的入口写入),
|
|
6817
|
+
* 那种形状的既有契约是「这一次打开照常发出,但最终 tab 记成 manual」(见 autoTakeoverStateOf
|
|
6818
|
+
* 的 "open" 分支与「等待布局期间手动打开」用例);在这里 abort 会连同用户的手动意图一起
|
|
6819
|
+
* 丢掉(那次点击不会补发 openResource)。
|
|
6820
|
+
*
|
|
6821
|
+
* 窗口里的「手动关闭」不依赖持久条目:它由 applyPendingManualIntent 立刻写抑制,并且
|
|
6822
|
+
* autoTakeoverStateOf 返回 "close" ⇒ 下面直接 abort,行为逐字不变。
|
|
6823
|
+
*/
|
|
4488
6824
|
const takeover = autoTakeoverStateOf(key);
|
|
4489
6825
|
if (takeover === "close") return "abort";
|
|
4490
6826
|
if (takeover === "open") return "manual";
|
|
@@ -4504,6 +6840,20 @@
|
|
|
4504
6840
|
resourceAddress,
|
|
4505
6841
|
expiresAt: Date.now() + SIDEBAR_TAB_OPEN_CONFIRMATION_TIMEOUT_MS,
|
|
4506
6842
|
origin,
|
|
6843
|
+
/**
|
|
6844
|
+
* 因果证明状态(缺陷 1):这一次打开到底凭什么说「随后落地的那个 tab 是我们创建的」。
|
|
6845
|
+
*
|
|
6846
|
+
* - causalProof:"pending"(还没判)→ "proven"(发出 openResource 之前亲眼确认
|
|
6847
|
+
* inventory 可读且该地址没有已提交 tab)/ "failed"(有 tab 或读不到,一律不认领);
|
|
6848
|
+
* - causalIssuedAt:openResource 真正发给宿主的时刻(null = 还没发出)。在此之前读到
|
|
6849
|
+
* 同地址 tab 只可能是**别的写入者**;
|
|
6850
|
+
* - foreignWriter:期间观察到别的写入者的证据(见 recordSidebarTab 的置位点)。
|
|
6851
|
+
*
|
|
6852
|
+
* 三个字段缺一不可:任何一层不成立都不允许把落地证据认成 auto(宁可漏收一次)。
|
|
6853
|
+
*/
|
|
6854
|
+
causalProof: "pending",
|
|
6855
|
+
causalIssuedAt: null,
|
|
6856
|
+
foreignWriter: false,
|
|
4507
6857
|
});
|
|
4508
6858
|
}
|
|
4509
6859
|
/**
|
|
@@ -4516,7 +6866,8 @@
|
|
|
4516
6866
|
if (origin === SIDEBAR_TAB_ORIGIN_MANUAL) {
|
|
4517
6867
|
sidebarAutoSuppressedRef.current.delete(key);
|
|
4518
6868
|
sidebarAutoOriginRef.current.delete(key);
|
|
4519
|
-
|
|
6869
|
+
// 用户手动重新打开同一资源:手动接管,这个 key 上未结算的自动关闭预算(含 owner)一并作废。
|
|
6870
|
+
clearAutoCloseAttempt(key);
|
|
4520
6871
|
}
|
|
4521
6872
|
const targetPaneId = existingSubagentPaneId();
|
|
4522
6873
|
let openOptions = null;
|
|
@@ -4565,9 +6916,7 @@
|
|
|
4565
6916
|
// 宽度 action 返回只代表 store 已写入;必须等宿主把新宽度提交到 DockLayout,
|
|
4566
6917
|
// 否则 split() 仍会读到旧 room.row=false,并弹出「栏宽不足」。
|
|
4567
6918
|
await waitForSidebarSplitLayoutCommit();
|
|
4568
|
-
const splitStillCurrent =
|
|
4569
|
-
&& currentRootRef.current === rootSessionId
|
|
4570
|
-
&& currentSidebarSessionRef.current === sidebarSessionId
|
|
6919
|
+
const splitStillCurrent = sidebarSurfaceStillCurrent() === true
|
|
4571
6920
|
&& sidebarSplitIntentRef.current?.token === splitToken;
|
|
4572
6921
|
if (!splitStillCurrent) {
|
|
4573
6922
|
// session 切换、卸载或 deadline 已经收口时,不得让旧点击继续操作新 surface。
|
|
@@ -4586,6 +6935,7 @@
|
|
|
4586
6935
|
// 用户要的是关闭:立刻登记抑制,Auto 不得在下一轮同步里把它重新选成候选。
|
|
4587
6936
|
sidebarAutoSuppressedRef.current.set(key, { sessionId: sidebarSessionId, rootSessionId, address: resourceAddress });
|
|
4588
6937
|
trimAutoKeyMap(sidebarAutoSuppressedRef.current);
|
|
6938
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, resourceAddress, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-close");
|
|
4589
6939
|
}
|
|
4590
6940
|
return;
|
|
4591
6941
|
}
|
|
@@ -4633,20 +6983,118 @@
|
|
|
4633
6983
|
// 用户要的是关闭:立刻登记抑制,绝不在同一轮或下一轮同步里把这个资源重新打开。
|
|
4634
6984
|
sidebarAutoSuppressedRef.current.set(key, { sessionId: sidebarSessionId, rootSessionId, address: resourceAddress });
|
|
4635
6985
|
trimAutoKeyMap(sidebarAutoSuppressedRef.current);
|
|
6986
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, resourceAddress, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-close");
|
|
4636
6987
|
}
|
|
4637
6988
|
return;
|
|
4638
6989
|
}
|
|
4639
6990
|
if (beforeOpenReview === "manual") effectiveOrigin = SIDEBAR_TAB_ORIGIN_MANUAL;
|
|
4640
|
-
|
|
6991
|
+
/**
|
|
6992
|
+
* 副作用之前的**因果证明**(缺陷 1,与复核点在同一个同步段里,中间没有任何 await)。
|
|
6993
|
+
*
|
|
6994
|
+
* 宿主 openResource() 的公开契约里没有返回值(void),默认 revealIfOpened=true —— 同一个
|
|
6995
|
+
* (kind, contentId) 已经有 tab 时它只是**揭示**那一个。因此「我们调用过 openResource」+
|
|
6996
|
+
* 「随后 inventory 里出现同地址 tab」并不构成因果:那个 tab 完全可能是用户刚刚从 DSH 其它
|
|
6997
|
+
* 入口打开的同一个资源。这里在发动作之前亲眼核对一次:
|
|
6998
|
+
* - inventory 可读、且该地址没有已提交 tab ⇒ 之后出现的那个 tab 只可能是本次调用打出来的
|
|
6999
|
+
* (同一帧内没有别的写入者能插进来),记为 proven;
|
|
7000
|
+
* - 已经有 tab(用户在等待窗口里打开了它)、或 inventory 读不出来(证明不了)⇒ 一律降级
|
|
7001
|
+
* manual:这次调用最多只是揭示别人的 tab,绝不认领、绝不在资源结束后把它关掉。
|
|
7002
|
+
*
|
|
7003
|
+
* 取舍(刻意):宁可漏收一次(那个 tab 留在右栏交给用户手动处理),也绝不误关用户刚打开的
|
|
7004
|
+
* tab。手动路径(autoContext === null)不需要证明:它本来就记 manual。
|
|
7005
|
+
*/
|
|
7006
|
+
let openProof = null;
|
|
7007
|
+
if (autoContext !== null) {
|
|
7008
|
+
const openWitness = sidebarResourceTabStateOf(resourceAddress);
|
|
7009
|
+
const autoProven = openWitness.readable === true && openWitness.tabId === null;
|
|
7010
|
+
openProof = { autoProven };
|
|
7011
|
+
if (autoProven !== true) {
|
|
7012
|
+
/**
|
|
7013
|
+
* 刻意**不**在这里改 effectiveOrigin:留成 auto 才能让「声明过 auto 但缺因果证明」这个
|
|
7014
|
+
* 事实一路带到来源判据(recordSidebarTab 的 declaredUsable ⇒ manual,理由
|
|
7015
|
+
* manual-unproven-open,诊断里一眼能看出是**没证明出来**而不是用户手动接管)。
|
|
7016
|
+
* 占位写入与最终归属都由 openProof 把关。
|
|
7017
|
+
*/
|
|
7018
|
+
recordSidebarAutoDecision("open", { key, kind: "open" }, "downgrade", "causal-unproven");
|
|
7019
|
+
}
|
|
7020
|
+
const pendingOpening = sidebarTabOpeningRef.current.get(key);
|
|
7021
|
+
if (pendingOpening !== undefined
|
|
7022
|
+
&& pendingOpening.sessionId === sidebarSessionId && pendingOpening.rootSessionId === rootSessionId) {
|
|
7023
|
+
pendingOpening.causalProof = autoProven === true ? "proven" : "failed";
|
|
7024
|
+
}
|
|
7025
|
+
}
|
|
7026
|
+
/**
|
|
7027
|
+
* 「已发出」标记必须写在**调用之前**、与调用处在同一个同步段里(时序加固,可用性阻塞)。
|
|
7028
|
+
*
|
|
7029
|
+
* 宿主链路(已按实现核实,见 @deepseek-ai/dsh-client-ui-sidebar-right/lib/client.js 与
|
|
7030
|
+
* client-store 的 snapshot store):openResource → store.actions.openContent → zustand setState
|
|
7031
|
+
* 的同步 forEach → adopt() 里 store.subscribe(sync) 注册的回调 → inventory.publish() →
|
|
7032
|
+
* openTabs.set → 插件在挂载期注册的 inventory 订阅回调。整条链路上没有任何 await / 微任务,
|
|
7033
|
+
* 宿主因此会在 openResource() **返回之前**同步重入本插件一次(syncSidebarTabs →
|
|
7034
|
+
* syncSidebarTabRecords → 对在途 opening 调 recordSidebarTab)。
|
|
7035
|
+
*
|
|
7036
|
+
* 若标记晚于这次重入写入(旧实现),重入结算读到的 causalIssuedAt 还是 null,于是按
|
|
7037
|
+
* 「别的写入者」置位 foreignWriter 并把 tab 记成 manual、落盘持久 manual 归属;随后的声明式
|
|
7038
|
+
* Auto 记录又被持久 manual 压制,资源结束也收不回来(不会误关,但正常自动收回失效)。
|
|
7039
|
+
*
|
|
7040
|
+
* 三件套一条都不放宽:标记只让重入结算把这次 landing 认作**本次调用**打出来的 tab,是否可作
|
|
7041
|
+
* auto 证据仍由 recordSidebarTab 判:发出前 inventory 可读且该地址无 tab(causalProof ===
|
|
7042
|
+
* "proven")+ 标记非空 + 期间没有别的写入者(foreignWriter !== true)。调用**同步抛错**时立刻
|
|
7043
|
+
* 回滚标记(下面的 try/catch),绝不留下「已经发出」的假证据。
|
|
7044
|
+
*/
|
|
7045
|
+
const issuedOpening = autoContext === null ? undefined : sidebarTabOpeningRef.current.get(key);
|
|
7046
|
+
const issuedOpeningScoped = issuedOpening !== undefined
|
|
7047
|
+
&& issuedOpening.sessionId === sidebarSessionId && issuedOpening.rootSessionId === rootSessionId
|
|
7048
|
+
? issuedOpening
|
|
7049
|
+
: undefined;
|
|
7050
|
+
// 回滚用的原值:畸形值按 null(「还没发出」)处理,绝不把脏值留在记录里。
|
|
7051
|
+
const issuedAtBefore = issuedOpeningScoped === undefined
|
|
7052
|
+
|| issuedOpeningScoped.causalIssuedAt === null || issuedOpeningScoped.causalIssuedAt === undefined
|
|
7053
|
+
? null
|
|
7054
|
+
: issuedOpeningScoped.causalIssuedAt;
|
|
7055
|
+
if (issuedOpeningScoped !== undefined) issuedOpeningScoped.causalIssuedAt = Date.now();
|
|
7056
|
+
try {
|
|
7057
|
+
openSidebarResource.call(sidebarRight, resourceAddress, openOptions);
|
|
7058
|
+
} catch (error) {
|
|
7059
|
+
/**
|
|
7060
|
+
* 同步抛错:宿主没有完成这次打开,这次调用必须回到「从未发出」的状态——否则任何一条把它们
|
|
7061
|
+
* 联系起来的后续判据(重入结算 / 重试 / 收养)都可能把失败的动作当成已发出的证据。
|
|
7062
|
+
* 回滚后原样抛出,交给外层 catch 收口(撤销来源占位、清掉在途记录)。
|
|
7063
|
+
*/
|
|
7064
|
+
if (issuedOpeningScoped !== undefined) issuedOpeningScoped.causalIssuedAt = issuedAtBefore;
|
|
7065
|
+
throw error;
|
|
7066
|
+
}
|
|
4641
7067
|
openIssued = true;
|
|
4642
7068
|
/**
|
|
4643
7069
|
* 预留 → 来源的升级点:只有 openResource 真的成功发出、且宿主具备可追踪能力(能读到 tabId、
|
|
4644
7070
|
* 能精确关闭)时,才把这次打开记成「Auto 亲手打开」。openResource 抛错时直接走 catch,
|
|
4645
7071
|
* 来源标记绝不写;能力不足时也不写——将来无法精确回收的 tab 不归 Auto 管。
|
|
4646
7072
|
*/
|
|
4647
|
-
if (effectiveOrigin === SIDEBAR_TAB_ORIGIN_AUTO && canTrackOpen === true
|
|
4648
|
-
|
|
4649
|
-
|
|
7073
|
+
if (effectiveOrigin === SIDEBAR_TAB_ORIGIN_AUTO && canTrackOpen === true
|
|
7074
|
+
&& openProof !== null && openProof.autoProven === true) {
|
|
7075
|
+
/**
|
|
7076
|
+
* 此刻落地证据还没到(tabId 未知):这里只写下「本次运行已经为它发出过一次 Auto 打开」
|
|
7077
|
+
* 这条去重记账,tabId 一律留空——它不是归属证据(见 sidebarAutoOriginEntry)。真正的
|
|
7078
|
+
* tabId 只由 recordSidebarTab 在宿主 inventory 里**亲手读到那个 tab** 时写入 / 刷新。
|
|
7079
|
+
*
|
|
7080
|
+
* 刻意不做限容淘汰:归属容量由候选选择阶段在发出 openResource 之前 fail-closed 判定
|
|
7081
|
+
* (见 autoSidebarOwnershipHasCapacity),这里绝不允许挤掉别的 scope 仍然有效的 owner。
|
|
7082
|
+
*
|
|
7083
|
+
* 覆盖闸门(时序加固):这次打开可能在**调用内部**就已经被重入结算(宿主同步发布 inventory,
|
|
7084
|
+
* 见上面「已发出」标记的说明),结算会把**真实 tabId** 写进这条账本条目。那条条目比占位强,
|
|
7085
|
+
* 绝不能用 tabId=null 的占位把它覆盖回「落地证据还没到」:覆盖会让这条账本条目短暂失去
|
|
7086
|
+
* tabId 绑定(紧接着的声明式 recordSidebarTab 通常会按当时的证据重新写下绑定,但那条写入
|
|
7087
|
+
* 依赖「此刻还读得到 tabId」;读不到时这次丢失就一直留着),此后重挂载 / 重收养只能看到共享
|
|
7088
|
+
* 账本,绑定失配即退化 manual,Auto 再也收不回这个 tab——与本次加固要修的症状同类。
|
|
7089
|
+
* 只放行「没有 tabId」的写入(含条目缺失 / 畸形值),其余一律保留现场。
|
|
7090
|
+
*/
|
|
7091
|
+
const landedOriginEntry = sidebarAutoOriginRef.current.get(key);
|
|
7092
|
+
if (sidebarAutoOriginTabIdOf(landedOriginEntry) === null) {
|
|
7093
|
+
sidebarAutoOriginRef.current.set(
|
|
7094
|
+
key,
|
|
7095
|
+
sidebarAutoOriginEntry(sidebarSessionId, rootSessionId, resourceAddress, null),
|
|
7096
|
+
);
|
|
7097
|
+
}
|
|
4650
7098
|
}
|
|
4651
7099
|
if (splitToken !== null) {
|
|
4652
7100
|
let acknowledged = true;
|
|
@@ -4660,7 +7108,8 @@
|
|
|
4660
7108
|
}
|
|
4661
7109
|
}
|
|
4662
7110
|
// 记录必须发生在 openResource 之后:它读的是宿主提交后的 active tab,是打开的证据。
|
|
4663
|
-
|
|
7111
|
+
// openProof 把「发出之前地址上没有 tab」这条因果证据一路带进来源判据(见 recordSidebarTab)。
|
|
7112
|
+
const opened = recordSidebarTab(key, resourceAddress, effectiveOrigin, openProof);
|
|
4664
7113
|
// 只要这次打开的 tab 已经落定,就不能留下 opening 记录:它的语义是「这次打开还没有确定
|
|
4665
7114
|
// 证据」(split 事务仍在等待 pane 证据、或本来就没有事务时都一样)。残留的 opening 会让
|
|
4666
7115
|
// 用户收回这个 tab 之后的下一次同步把关闭记录重新建回来(<< 复活),并把之后的点击挡成
|
|
@@ -4668,7 +7117,10 @@
|
|
|
4668
7117
|
if (opened) sidebarTabOpeningRef.current.delete(key);
|
|
4669
7118
|
// openResource 可能已经同步提交 tab:立即推进一次同步,让同 pane 回退不依赖下一轮 observer。
|
|
4670
7119
|
// 若宿主稍后才渲染 DOM,keepMounted + observer/轮询仍会继续补偿。
|
|
4671
|
-
|
|
7120
|
+
// 旧闭包绝不允许在新 surface 上推进同步:中间的宿主调用可能已经触发一次重挂载或 A→B→A
|
|
7121
|
+
// 回返,那时这份闭包手里的快照会把新 Panel 的账本当成本轮的旧状态处理。新 Panel 自己的
|
|
7122
|
+
// 下一轮外部同步会按真实 inventory 继续收口。
|
|
7123
|
+
if (sidebarSurfaceStillCurrent() === true) syncSidebarTabs();
|
|
4672
7124
|
} catch {
|
|
4673
7125
|
if (sidebarSplitIntentRef.current?.key === key) cancelPendingSidebarSplit("resource-failed");
|
|
4674
7126
|
sidebarTabOpeningRef.current.delete(key);
|
|
@@ -4677,25 +7129,37 @@
|
|
|
4677
7129
|
finally {
|
|
4678
7130
|
pending.delete(key);
|
|
4679
7131
|
/**
|
|
4680
|
-
*
|
|
4681
|
-
* surface
|
|
4682
|
-
*
|
|
4683
|
-
* -
|
|
7132
|
+
* 自动动作收尾时释放在途记账(split busy、准备失败、layout 失效、open 抛错、surface 变化、
|
|
7133
|
+
* 被撤销都走这里)。必须按 surface 是否仍是出发时那一份分成两种行为:
|
|
7134
|
+
*
|
|
7135
|
+
* - 仍是出发时那一份:历史行为逐字不变——预留必须释放(否则一次失败会被永久记成「已经
|
|
7136
|
+
* 打开过」,该资源在本次运行里再也打不开),打开没有真正发出时撤销残留来源,并结算用户
|
|
7137
|
+
* 在这个窗口里留下的手动意图;
|
|
7138
|
+
* - generation 已经换掉(组件重挂载,或同一个实例 A→B→A):只能清理**明确属于本实例这一次
|
|
7139
|
+
* 动作**的在途记录——预留是本实例的 Map,且候选选择在预留存在期间绝不会为同一个 key 再选
|
|
7140
|
+
* 一次,因此这一刻它只可能是本次动作写下的那一笔。共享 Auto 账本(来源 / 抑制 / 重试)与
|
|
7141
|
+
* 手动意图一律不碰:openIssued 为假说明本次动作从来没有发出过 openResource,此刻那个 key
|
|
7142
|
+
* 上的来源只可能属于新 generation 已经成功打开的那次动作(旧实现无条件 delete 会把它清掉,
|
|
7143
|
+
* 新 Panel 从此再也认不出自己开出的 tab,资源结束后也不会自动关闭它)。
|
|
4684
7144
|
*/
|
|
7145
|
+
const surfaceCurrent = sidebarSurfaceStillCurrent() === true;
|
|
4685
7146
|
if (autoContext !== null) {
|
|
4686
7147
|
sidebarAutoReservationRef.current.delete(key);
|
|
4687
|
-
if (autoContext.kind === "open" && openIssued !== true) {
|
|
7148
|
+
if (surfaceCurrent === true && autoContext.kind === "open" && openIssued !== true) {
|
|
4688
7149
|
sidebarAutoOriginRef.current.delete(key);
|
|
4689
7150
|
// 本次打开没有发出:把 key 记进失败屏障,同一批微任务里绝不再重选它(见其说明)。
|
|
4690
7151
|
sidebarAutoFailedKeysRef.current.add(key);
|
|
4691
7152
|
}
|
|
4692
|
-
if (openIssued === true) sidebarAutoFailedKeysRef.current.delete(key);
|
|
7153
|
+
if (surfaceCurrent === true && openIssued === true) sidebarAutoFailedKeysRef.current.delete(key);
|
|
4693
7154
|
}
|
|
4694
7155
|
/**
|
|
4695
7156
|
* 在途动作收尾后立刻结算用户在这个窗口里表达的手动意图:手动恒优先,绝不因为「那次点击撞上
|
|
4696
7157
|
* 了 pending 锁」而丢失。没有意图时这一步是幂等空操作。
|
|
7158
|
+
*
|
|
7159
|
+
* 只由仍然属于当前 surface 的闭包结算:applyPendingManualIntent 会改共享的来源 / 抑制 / 重试
|
|
7160
|
+
* 账本,并可能派发新的打开或关闭动作;surface 换代后这些收尾属于新 Panel 的下一轮外部同步。
|
|
4697
7161
|
*/
|
|
4698
|
-
applyPendingManualIntent(key);
|
|
7162
|
+
if (surfaceCurrent === true) applyPendingManualIntent(key);
|
|
4699
7163
|
}
|
|
4700
7164
|
};
|
|
4701
7165
|
|
|
@@ -4708,17 +7172,22 @@
|
|
|
4708
7172
|
* root/session 的批量按钮保持可用,绝不被一个与它无关的在途序列(甚至永不 settle 的
|
|
4709
7173
|
* 宿主 Promise)阻塞;
|
|
4710
7174
|
* 2) 候选集合在**点击那一刻**从同一个 inventory 快照固定下来(渲染期算好、随点击闭包传入),
|
|
4711
|
-
* 后续再点同一个按钮也不会把新出现的 tab
|
|
4712
|
-
*
|
|
4713
|
-
*
|
|
7175
|
+
* 后续再点同一个按钮也不会把新出现的 tab 混进这一轮;但这个快照只用来决定「处理哪些候选」,
|
|
7176
|
+
* 真正调用 close 之前必须逐个重读**当前** inventory:等待前一个候选的 close 期间,同一个 tab
|
|
7177
|
+
* 可能已经被单项入口成功关掉,按旧快照再 close 一次就是重复副作用。inventory 读不到时
|
|
7178
|
+
* fail-closed 跳过,绝不按 active tab 猜;
|
|
7179
|
+
* 3) 每次 await 前后都过 surface 闸门(mountedRef / currentRootRef / currentSidebarSessionRef
|
|
7180
|
+
* 三条既有判据 + 不可复用的 surface 令牌):root 或 sidebar session 切换、组件卸载,以及
|
|
7181
|
+
* 「切走又切回同一组值」(A→B→A)之后立即停止后续关闭,绝不让旧点击继续操作新 surface。
|
|
4714
7182
|
*
|
|
4715
7183
|
* 单项失败严格隔离:close 同步抛错或返回 rejected Promise 只跳过这一项并继续其余项,
|
|
4716
7184
|
* 也绝不把失败项标成已关闭——关闭记录一律交给宿主 inventory 与既有同步器确认(这里不删记录)。
|
|
7185
|
+
* 与单项入口共用同一个执行入口(closeSidebarTabWithLease):候选上已经有一次关闭在途时等待它
|
|
7186
|
+
* 结算,上次成功就直接收口、上次失败才用当前 inventory 复核后接管一次有限重试;用户按下的
|
|
7187
|
+
* 批量意图绝不在冲突里被静默丢失,也绝不对已经关掉的 tab 重复调用 close。
|
|
4717
7188
|
*/
|
|
4718
7189
|
const handleSidebarBatchClose = async (candidates) => {
|
|
4719
|
-
if (
|
|
4720
|
-
|| currentRootRef.current !== rootSessionId
|
|
4721
|
-
|| currentSidebarSessionRef.current !== sidebarSessionId) return;
|
|
7190
|
+
if (sidebarSurfaceStillCurrent() !== true) return;
|
|
4722
7191
|
if (closeSidebarResource === null) return;
|
|
4723
7192
|
if (Array.isArray(candidates) !== true || candidates.length === 0) return;
|
|
4724
7193
|
// 锁只覆盖「这一个 surface」:同一个 scope 的重复点击被拦下,别的 root/session 的批量按钮
|
|
@@ -4730,29 +7199,57 @@
|
|
|
4730
7199
|
// 立刻进入 pending 态:按钮 disabled + aria-busy,第二次点击在 has 检查处被拦下。
|
|
4731
7200
|
bump((value) => value + 1);
|
|
4732
7201
|
try {
|
|
4733
|
-
for (const
|
|
4734
|
-
// await 之前:root/session
|
|
4735
|
-
|
|
4736
|
-
|
|
4737
|
-
|
|
4738
|
-
|
|
4739
|
-
|
|
4740
|
-
|
|
4741
|
-
|
|
4742
|
-
|
|
4743
|
-
|
|
4744
|
-
|
|
4745
|
-
|
|
7202
|
+
for (const candidate of candidates) {
|
|
7203
|
+
// await 之前:surface 已经换掉(卸载、root/session 切换,或同一个实例 A→B→A 回返)即停止
|
|
7204
|
+
// 后续关闭。判据含不可复用的 surface 令牌,字符串重新相等不算「还是当前 surface」。
|
|
7205
|
+
if (sidebarSurfaceStillCurrent() !== true) return;
|
|
7206
|
+
/**
|
|
7207
|
+
* 候选形状闸门:候选必须**同时**携带 tabId 与资源地址(见 sidebarBatchCandidates)。
|
|
7208
|
+
* 缺任何一个都无法在副作用之前回答「这个 id 此刻仍然是我们要关的那个资源」——一律跳过
|
|
7209
|
+
* 这一项(其余候选继续处理),绝不退化成「只按 tabId 盲关」。
|
|
7210
|
+
*/
|
|
7211
|
+
const tabId = text(object(candidate).tabId, null);
|
|
7212
|
+
const candidateAddress = text(object(candidate).address, null);
|
|
7213
|
+
if (tabId === null || candidateAddress === null) continue;
|
|
7214
|
+
/**
|
|
7215
|
+
* 每个候选调用前重新读**当前** inventory,并同时复核**地址**:候选集合只是点击那一刻的
|
|
7216
|
+
* 渲染快照,而等待前一个候选的 close 期间,同一个 tab 完全可能已经被别的入口(用户刚点的
|
|
7217
|
+
* 单项箭头、Auto 的关闭、旧 Panel 的迟到收尾)成功关闭,甚至这个 tabId 已经被宿主回收给了
|
|
7218
|
+
* 另一个资源。只有「present 且条目暴露的地址与候选地址逐字一致」才允许调用 close;
|
|
7219
|
+
* absent / recycled / unreadable 一律跳过这一项,绝不按 active tab 或渲染时快照猜一个 id。
|
|
7220
|
+
*/
|
|
7221
|
+
if (sidebarTabPresenceInInventory(tabId, candidateAddress) !== "present") continue;
|
|
7222
|
+
// 批量关闭是显式手动语义:按候选地址把持久标记改写成 manual(手动恒优先)。
|
|
7223
|
+
writeSidebarAutoOwnership(sidebarSessionId, rootSessionId, candidateAddress, SIDEBAR_AUTO_OWNERSHIP_ORIGIN_MANUAL, "manual-close");
|
|
7224
|
+
/**
|
|
7225
|
+
* 与单 tab 关闭共用同一个执行入口(同一把 session + root + tabId 租约 + 结算信号):
|
|
7226
|
+
* 这个 tab 上已经有一次关闭在途时(典型:用户刚点的单项箭头还停在宿主 Promise 里),
|
|
7227
|
+
* 批量必须等待它结算再决定——上次成功就直接收口(绝不重复 close),上次失败且当前
|
|
7228
|
+
* inventory 仍证明这个精确 tabId 存在**且地址一致**时才接管**一次**有限重试。用户按下的
|
|
7229
|
+
* 批量意图因此绝不在冲突里被静默丢失,也不会对已经关掉的 tab 重复调用 close。
|
|
7230
|
+
*/
|
|
7231
|
+
await closeSidebarTabWithLease(tabId, {
|
|
7232
|
+
waitForCompeting: true,
|
|
7233
|
+
/**
|
|
7234
|
+
* 批量入口没有 key(它的候选只有 tabId + 地址):按手动语义处理,不做验证收口——记录由
|
|
7235
|
+
* 同步层结算。地址必须传下去:它既是 preflight 的地址判据,也是等待竞争租约时等待者
|
|
7236
|
+
* 自己那份复核证据(没有地址证据的等待者遇到 recycled 结算只能跳过)。
|
|
7237
|
+
*/
|
|
7238
|
+
verify: { key: null, address: candidateAddress, attemptToken: null, manual: true },
|
|
7239
|
+
});
|
|
7240
|
+
|
|
7241
|
+
// await 之后:surface 已切换(含同一个实例 A→B→A 回返)时不再继续(已经发出的那一次
|
|
7242
|
+
// 关闭照旧由宿主结算)。判据含不可复用的 surface 令牌,字符串重新相等不算「还是当前 surface」。
|
|
7243
|
+
if (sidebarSurfaceStillCurrent() !== true) return;
|
|
4746
7244
|
}
|
|
4747
7245
|
} finally {
|
|
4748
7246
|
// 只释放自己那一个 scope:旧序列的收尾绝不改写别的 root/session 的锁。
|
|
4749
7247
|
pendingScopes.delete(scopeKey);
|
|
4750
7248
|
// 重渲染与同步只服务**自己这一轮渲染**的 surface:root/session 已经切换时它们会去操作
|
|
4751
7249
|
// 新 surface(旧 scope 的 bump 会让新 root 白白重渲染、旧闭包的 sync 会去同步旧 root)。
|
|
4752
|
-
//
|
|
4753
|
-
|
|
4754
|
-
|
|
4755
|
-
&& currentSidebarSessionRef.current === sidebarSessionId) {
|
|
7250
|
+
// 判据含不可复用的 surface 令牌:同一个实例 A→B→A 之后字符串会重新相等,但这一轮批量序列
|
|
7251
|
+
// 已经不属于当前 surface,收尾交给新 Panel 自己的同步(bump 只由它自己发起)。
|
|
7252
|
+
if (sidebarSurfaceStillCurrent() === true) {
|
|
4756
7253
|
bump((value) => value + 1);
|
|
4757
7254
|
// 关闭序列结束后推进一次同步:候选集合与签名都按宿主 inventory 重新读取,
|
|
4758
7255
|
// 真正被宿主关掉的 tab 由既有同步器(present/active/浮窗标题证据)结算,插件不抢先删记录。
|
|
@@ -4972,13 +7469,15 @@
|
|
|
4972
7469
|
* 的 childId),缺失时只用快照证据。运行状态本身必须继续来自目录 activity 与 DEG 元数据,
|
|
4973
7470
|
* 目录项缺失也绝不把 running 猜成 ready。
|
|
4974
7471
|
*/
|
|
4975
|
-
const runtimeStatusOfNode = (node, parentId, childId) => runtimeStatusOf(
|
|
7472
|
+
const runtimeStatusOfNode = (node, parentId, childId, options) => runtimeStatusOf(
|
|
4976
7473
|
node,
|
|
4977
7474
|
catalogEntryOf(parentId, childId ?? text(object(node).sessionId, null)),
|
|
7475
|
+
options,
|
|
4978
7476
|
);
|
|
4979
7477
|
|
|
4980
7478
|
const renderExpert = (node, index, parentId) => {
|
|
4981
|
-
|
|
7479
|
+
// 轻量快照里没有活动证据的专家行渲染中性圆点(不声明已结束),完整快照不受影响。
|
|
7480
|
+
const runtimeStatus = runtimeStatusOfNode(node, parentId, undefined, { partial: partialSnapshot });
|
|
4982
7481
|
return react.createElement("div", { key: node.id || node.sessionId || "expert-" + index, className: "deg_expert_group_node" },
|
|
4983
7482
|
react.createElement("div", { className: "deg_expert_group_row", "data-status": runtimeStatus, "data-expanded": true },
|
|
4984
7483
|
statusIcon(react, primitives, runtimeStatus),
|
|
@@ -5005,9 +7504,12 @@
|
|
|
5005
7504
|
// 空闲分组的批量候选只来自当前 idleChildren;运行中的专家或分片会被排除。
|
|
5006
7505
|
// slot 与计数标题同属第三列的 inline flex,标题按可用宽度省略,slot 不会被推到行尾。
|
|
5007
7506
|
if (trailing !== undefined && trailing !== null) idleTitleChildren.push(trailing);
|
|
7507
|
+
// 轻量快照下分组容器同样不声明「已结束」:它收纳的成员状态可能还没被完整读取,
|
|
7508
|
+
// 因此容器圆点跟随成员的中性态;完整快照仍按既有 ready 圆点渲染。
|
|
7509
|
+
const idleGroupStatus = partialSnapshot === true ? neutralRuntimeStatus : "ready";
|
|
5008
7510
|
return react.createElement("div", { className: "deg_expert_group_idle_group", "data-expanded": open },
|
|
5009
|
-
react.createElement("div", { className: "deg_expert_group_row deg_expert_group_idle_header", "data-status":
|
|
5010
|
-
statusIcon(react, primitives,
|
|
7511
|
+
react.createElement("div", { className: "deg_expert_group_row deg_expert_group_idle_header", "data-status": idleGroupStatus, "data-expanded": open },
|
|
7512
|
+
statusIcon(react, primitives, idleGroupStatus),
|
|
5011
7513
|
renderChevron(group, open),
|
|
5012
7514
|
react.createElement("div", { className: "deg_expert_group_idle_title_line" }, ...idleTitleChildren)),
|
|
5013
7515
|
open ? react.createElement("div", { className: "deg_expert_group_children deg_expert_group_idle_children" }, members.map((node, index) => node.kind === "fanout" ? renderFanout(node, index) : renderExpert(node, index, rootSessionId))) : null);
|
|
@@ -5136,23 +7638,30 @@
|
|
|
5136
7638
|
|
|
5137
7639
|
const children = Array.isArray(snapshot?.root?.children) ? snapshot.root.children : [];
|
|
5138
7640
|
// 普通专家按实际运行状态分组,fan-out 父任务则按 manager 的聚合终态进入空闲组。
|
|
7641
|
+
// 轻量快照(partial)下没有活动证据的专家是 unknown:**仍进空闲组显示**(位置与完整快照
|
|
7642
|
+
// 一致,不再因证据缺失而换组),但圆点/文案保持中性,且不参与任何批量关闭或抑制清理
|
|
7643
|
+
// (见 sidebarNodeIsIdleMembership 与 idleSidebarResourceAddresses 的分工)。
|
|
5139
7644
|
// fan-out 展示与取消/重试仍使用各自的 manager 状态,不受分组位置影响。
|
|
5140
7645
|
const idleChildren = sidebarIdleChildren();
|
|
5141
7646
|
const visibleChildren = children.filter((node) => !idleChildren.includes(node));
|
|
5142
7647
|
// 两行标题后的批量 slot 内容:主代理行只覆盖运行中的普通专家/最新分片,空闲标题行只覆盖
|
|
5143
|
-
// idleChildren
|
|
7648
|
+
// idleChildren(因此天然继承同一套证据规则:unknown 成员不在其中,绝不成为关闭候选)。
|
|
7649
|
+
// 两者都只在渲染期纯读 openTabs inventory 与 close 能力(inventory 读不出来、
|
|
5144
7650
|
// 或候选存在但 close 缺失时返回 null,不渲染任何东西);打开能力不参与这里的判定。
|
|
5145
7651
|
const rootBatchSlot = renderSidebarBatchSlot(runningSidebarResourceAddresses(), "运行中的子代理");
|
|
5146
7652
|
const idleBatchSlot = renderSidebarBatchSlot(idleSidebarResourceAddresses(idleChildren), "空闲子代理");
|
|
5147
7653
|
const root = snapshot?.root;
|
|
5148
7654
|
const rootOpen = root === null ? true : expand(root);
|
|
7655
|
+
// 根行的圆点走与专家行同一条 partial 规则:轻量快照里没有活动证据的根会话渲染中性圆点,
|
|
7656
|
+
// 而不是「已结束」的绿色圆点;完整快照与旧宿主下与既有渲染逐字一致。
|
|
7657
|
+
const rootStatus = runtimeStatusOf(root, null, { partial: partialSnapshot });
|
|
5149
7658
|
const body = viewState.loading && snapshot === null
|
|
5150
7659
|
? react.createElement("div", { className: "deg_expert_group_tree", "aria-busy": "true" }, react.createElement("div", { className: "deg_expert_group_skeleton" }), react.createElement("div", { className: "deg_expert_group_skeleton" }))
|
|
5151
7660
|
: snapshot === null
|
|
5152
7661
|
? react.createElement("div", { className: "deg_expert_group_empty" }, "暂无 Expert Group 任务")
|
|
5153
7662
|
: react.createElement("div", { className: "deg_expert_group_tree" },
|
|
5154
7663
|
react.createElement("div", { className: "deg_expert_group_node deg_expert_group_node_root", "data-root": "true" },
|
|
5155
|
-
react.createElement("div", { className: "deg_expert_group_row", "data-status":
|
|
7664
|
+
react.createElement("div", { className: "deg_expert_group_row", "data-status": rootStatus, "data-expanded": true }, statusIcon(react, primitives, rootStatus), renderChevron(root, rootOpen), react.createElement("div", null, renderThreeLines(root, { sessionId: root.sessionId, parentId: null, expanded: true, trailing: rootBatchSlot }))),
|
|
5156
7665
|
rootOpen ? react.createElement("div", { className: "deg_expert_group_children" }, [
|
|
5157
7666
|
...visibleChildren.map((node, index) => node.kind === "fanout" ? renderFanout(node, index) : renderExpert(node, index, rootSessionId)),
|
|
5158
7667
|
renderIdleGroup(idleChildren, idleBatchSlot),
|
|
@@ -12677,7 +15186,10 @@ window.__ModuleLoader__.load({
|
|
|
12677
15186
|
const PROMPT_ROLE_IDS = SETTINGS_ROLE_IDS;
|
|
12678
15187
|
const DEFAULT_PROMPT_MAX_GRAPHEMES = 32000;
|
|
12679
15188
|
const PROMPT_WARNING_RATIO = 0.9;
|
|
12680
|
-
|
|
15189
|
+
// 只读提示的语义必须与运行期一致:固定执行纪律由 child 的 persona/system context
|
|
15190
|
+
// 与 scoped 工具策略(tools.restrict + runtime guard)在运行时注入,**不写进任务
|
|
15191
|
+
// 提示词**;用户只能编辑专家专属部分,纪律本身不可编辑、也不随草稿提交。
|
|
15192
|
+
const PROMPT_DISCIPLINE_HINT = "固定执行纪律不可编辑:它由 child 的 persona/system context 与 scoped 工具策略在运行时注入,不写进任务提示词;内容包含叶子 worker、工具与权限边界、continuable child 约束、交付协议和中文输出要求。";
|
|
12681
15193
|
|
|
12682
15194
|
/**
|
|
12683
15195
|
* grapheme 分段器按「locale + granularity」缓存。
|
|
@@ -16885,16 +19397,21 @@ window.__ModuleLoader__.load({
|
|
|
16885
19397
|
disabled: saving,
|
|
16886
19398
|
onChange: (event) => editDraft((previous) => ({ ...previous, notificationHoldMs: notificationHoldMsOf(Number(event.target.value)) })),
|
|
16887
19399
|
}, NOTIFICATION_HOLD_OPTIONS.map((option) => react.createElement("option", { key: option.value, value: option.value }, option.label)))),
|
|
16888
|
-
|
|
19400
|
+
// 两个输入控件分别提供可访问名称,避免一个 label 同时包裹多个可标记控件。
|
|
19401
|
+
react.createElement("div", { className: "deg_settings_control" },
|
|
16889
19402
|
react.createElement("span", { className: "deg_settings_label" }, "通知音量"),
|
|
16890
19403
|
react.createElement("input", {
|
|
19404
|
+
id: "deg-settings-notification-volume-range",
|
|
16891
19405
|
type: "range", min: 0, max: 100, step: 1,
|
|
19406
|
+
"aria-label": "通知音量滑块",
|
|
16892
19407
|
value: draft.notificationVolume,
|
|
16893
19408
|
disabled: saving,
|
|
16894
19409
|
onChange: (event) => editDraft((previous) => ({ ...previous, notificationVolume: clampNotificationVolume(event.target.value) })),
|
|
16895
19410
|
}),
|
|
16896
19411
|
react.createElement("input", {
|
|
19412
|
+
id: "deg-settings-notification-volume-number",
|
|
16897
19413
|
type: "number", min: 0, max: 100, step: 1,
|
|
19414
|
+
"aria-label": "通知音量数值",
|
|
16898
19415
|
value: draft.notificationVolume,
|
|
16899
19416
|
disabled: saving,
|
|
16900
19417
|
onChange: (event) => editDraft((previous) => ({ ...previous, notificationVolume: clampNotificationVolume(event.target.value) })),
|