@bolloon/bolloon-agent 0.5.4 → 0.5.5

package/dist/orbitdb/cid-database.js

@@ -102,6 +102,61 @@ export class OrbitDBAdapter {
     get ipfsPaths() {
         return this.node?.paths ?? null;
     }
+    // ============ P2P 观测/接入口 (2026-09-30, 为真两节点复制验证加的) ============
+    // 之前 helia/libp2p 完全藏在私有字段里 —— 于是所有多节点测试只能注入 fake CIDDatabase,
+    // 「真两节点能不能同步」从来没被验过。这三个口只读/只拨号, 不改变任何既有行为。
+    /** 本节点 peerId (未初始化时 null; 验收/诊断用) */
+    get peerId() {
+        return this.node?.peerId ?? null;
+    }
+    /** 本节点当前监听地址 (multiaddr 字符串; 未初始化时 []) */
+    listenAddrs() {
+        const l = this.node?.helia?.libp2p;
+        try {
+            return (l?.getMultiaddrs?.() ?? []).map((m) => m.toString());
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 当前与本节点**有连接**的对端 (诊断用只读口)。
+     * 用途: P0 门里 S3「不拨号必须看不见」不稳定 (关 mDNS、全静默档都仍 seen=101) ——
+     * 得先看清"是谁、通过什么连上的", 再谈判据。返回 `peerId ← 远端地址`。
+     */
+    peerConnections() {
+        const l = this.node?.helia?.libp2p;
+        try {
+            return (l?.getConnections?.() ?? []).map((c) => {
+                const p = c.remotePeer?.toString?.() ?? String(c.remotePeer);
+                const a = c.remoteAddr?.toString?.() ?? '';
+                return `${p} ← ${a}`;
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 某个 pubsub 主题当前的订阅者 peerId (诊断用只读口)。
+     * OrbitDB 的同步靠 pubsub: 新 peer 订阅 `address` 主题后, 已在线的 peer 会把 heads 发给它
+     * (@orbitdb/core src/sync.js:143 的 join 事件)。所以"订阅者为 0"和"日志为空"是两回事, 必须分开看。
+     */
+    pubsubSubscribers(topic) {
+        const ps = this.node?.helia?.libp2p?.services?.pubsub;
+        try {
+            return (ps?.getSubscribers?.(topic) ?? []).map((x) => x.toString());
+        }
+        catch {
+            return [];
+        }
+    }
+    /** 拨号到另一个真节点 (验收/群组接入用)。失败原样抛, 不吞。 */
+    async dial(addr) {
+        await this.ensure();
+        const { multiaddr } = await import('@multiformats/multiaddr');
+        await this.node.helia.libp2p.dial(multiaddr(addr));
+    }
     /** 懒初始化: 首次使用时启动 helia + OrbitDB + 打开 keyvalue store */
     async ensure() {
         if (this.db)

package/dist/orbitdb/event-index.js

@@ -0,0 +1,370 @@
+/**
+ * event-index.ts — 事件网络的**可重建索引层** (P2, 2026-10-01)
+ *
+ * 三个索引 store (keyvalue, 天然可增量复制):
+ *   `by-topic`      key = <topic>::<ts>::<eventId>
+ *   `by-capability` key = <capability>::<ts>::<eventId>
+ *   `by-time`       key = <ts>::<eventId>            (所有事件都进这一条, 时间线)
+ *
+ * 核心不变式 (本文件存在的全部理由):
+ *
+ *   ① 索引 = f(事件流), **纯函数**。
+ *      `deriveIndexEntries(event)` / `rebuildIndexes(events)` 不读任何索引、不读网络、不读时钟 ——
+ *      输入相同 ⇒ 输出逐字节相同。所以「删掉索引 → 重放事件流 → 逐字节相同」是**可判**的,
+ *      而且同一结论在任何节点上重复一次都一样 (不需要中心索引)。
+ *
+ *   ② 索引项**只放元数据 + CID**, 绝不放正文。
+ *      `indexEntryFor` 用**显式白名单**构造 IndexEntry (不是展开外壳再删字段 ——
+ *      "删字段"会在外壳加字段那天静默漏出正文), 白名单见 `ALLOWED_INDEX_ENTRY_KEYS`。
+ *      正文只以 `cid` 出现; 只有**有界摘要** (≤ event-shell 的 MAX_SUMMARY_LEN) 会进索引。
+ *
+ *   ③ 字节可比。
+ *      `indexBundleCbor(bundle)` = dag-cbor 编码的 `{store: {key: value}}` (键排序由 canonicalize 保证),
+ *      这就是三个 store 内容的**字节像**; `indexBundleFingerprint` 给它 sha256。
+ *      重建前后比这个指纹 = "逐字节相同"。
+ */
+import * as dagCbor from '@ipld/dag-cbor';
+import { sha256 } from 'multiformats/hashes/sha2';
+import { canonicalJson, canonicalize, MAX_SUMMARY_LEN, } from './event-shell.js';
+export const INDEX_STORE_NAMES = ['by-topic', 'by-capability', 'by-time'];
+/** 索引项版本 (与外壳版本解耦: 索引布局变了就 +1) */
+export const INDEX_ENTRY_VERSION = 1;
+/**
+ * 索引项**只允许**有这些键。反事实门 (verify-event-index ④) 拿它当白名单:
+ * 出现集合外的键 = 索引里混进了别的东西。
+ */
+export const ALLOWED_INDEX_ENTRY_KEYS = [
+    'v',
+    'id',
+    'type',
+    'actor',
+    'actorId',
+    'group',
+    'ts',
+    'refs',
+    'topic',
+    'capability',
+    'summary',
+    'cid',
+];
+const TS_WIDTH = 13; // Date.now() 13 位 (够用到 2286 年); 补零 ⇒ 字符串序 = 时间序
+/** key 里的变量部分一律 encodeURIComponent ⇒ 分隔符 `::` 不会被标识符里的字符污染 */
+const enc = (s) => encodeURIComponent(s);
+const tsPart = (ts) => String(Math.trunc(ts)).padStart(TS_WIDTH, '0');
+export function topicKey(ev) {
+    return ev.topic ? `${enc(ev.topic)}::${tsPart(ev.ts)}::${enc(ev.id)}` : null;
+}
+export function capabilityKey(ev) {
+    return ev.capability ? `${enc(ev.capability)}::${tsPart(ev.ts)}::${enc(ev.id)}` : null;
+}
+export function timeKey(ev) {
+    return `${tsPart(ev.ts)}::${enc(ev.id)}`;
+}
+/** 从 key 反解 (读侧/调试用); 反解不出的返回 null, 不硬凑 */
+export function parseIndexKey(store, key) {
+    const parts = key.split('::');
+    try {
+        if (store === 'by-time') {
+            if (parts.length !== 2)
+                return null;
+            return { ts: Number(parts[0]), id: decodeURIComponent(parts[1]) };
+        }
+        if (parts.length !== 3)
+            return null;
+        return { label: decodeURIComponent(parts[0]), ts: Number(parts[1]), id: decodeURIComponent(parts[2]) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 外壳 → 索引项。**显式白名单**: 只列出的字段会被搬过来。
+ * 这就是"索引项里不许出现正文"在实现层的落实 (不是靠自觉)。
+ */
+export function indexEntryFor(ev) {
+    const entry = {
+        v: ev.v ?? INDEX_ENTRY_VERSION,
+        id: ev.id,
+        type: ev.type,
+        actor: ev.actor,
+        actorId: ev.actorId,
+        group: ev.group,
+        ts: ev.ts,
+        refs: (ev.refs ?? []).map((r) => (r.rel !== undefined ? { type: r.type, id: r.id, rel: r.rel } : { type: r.type, id: r.id })),
+        summary: ev.summary,
+    };
+    if (ev.topic)
+        entry.topic = ev.topic;
+    if (ev.capability)
+        entry.capability = ev.capability;
+    if (ev.cid)
+        entry.cid = ev.cid;
+    return entry;
+}
+/** 一个事件 → 它应该出现在哪几个索引里 (topic/capability 缺省就不进对应索引; 时间线一定进) */
+export function deriveIndexEntries(ev) {
+    const value = indexEntryFor(ev);
+    const out = [
+        { store: 'by-time', key: timeKey(ev), value },
+    ];
+    const tk = topicKey(ev);
+    if (tk)
+        out.push({ store: 'by-topic', key: tk, value });
+    const ck = capabilityKey(ev);
+    if (ck)
+        out.push({ store: 'by-capability', key: ck, value });
+    return out;
+}
+function sortDedupe(entries) {
+    const byKey = new Map();
+    for (const e of entries)
+        byKey.set(e.key, e); // 同 key 后到者胜 (流顺序 ⇒ 确定性)
+    return Array.from(byKey.values()).sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+}
+/**
+ * 纯重建: 事件流 → 三个索引的完整内容。**只依赖输入数组** (无时钟、无网络、无其它 store)。
+ * 结果按键排序 + 同键去重 ⇒ 与输入顺序无关 (除非真有同键冲突)。
+ */
+export function rebuildIndexes(events) {
+    const bundle = { 'by-topic': [], 'by-capability': [], 'by-time': [] };
+    for (const ev of events)
+        for (const d of deriveIndexEntries(ev))
+            bundle[d.store].push(d);
+    for (const name of INDEX_STORE_NAMES)
+        bundle[name] = sortDedupe(bundle[name]);
+    return bundle;
+}
+/** bundle → `{store: {key: value}}` (就是三个 kv store 的内容像) */
+export function indexStoreMap(bundle) {
+    const map = {};
+    for (const name of INDEX_STORE_NAMES) {
+        const m = {};
+        for (const e of bundle[name])
+            m[e.key] = e.value;
+        map[name] = m;
+    }
+    return map;
+}
+/** 索引内容的 canonical JSON (键排序) —— 人可读的"逐字节"版本 */
+export function indexBundleCanonicalJson(bundle) {
+    return canonicalJson(indexStoreMap(bundle));
+}
+/** 索引内容的 dag-cbor 字节 —— 与 OrbitDB 实际存的编码同一套, 可做真字节比对 */
+export function indexBundleCbor(bundle) {
+    const clean = canonicalize(indexStoreMap(bundle));
+    return dagCbor.encode(clean);
+}
+/** 内容指纹 (sha256 over dag-cbor 字节) + 计数 —— 重建前后比它 */
+export async function indexBundleFingerprint(bundle) {
+    const bytes = indexBundleCbor(bundle);
+    const hash = await sha256.digest(bytes);
+    const perStore = {};
+    for (const name of INDEX_STORE_NAMES)
+        perStore[name] = bundle[name].length;
+    return {
+        sha256: toHex(hash.digest),
+        bytes: bytes.length,
+        entries: INDEX_STORE_NAMES.reduce((n, s) => n + bundle[s].length, 0),
+        perStore,
+    };
+}
+export function toHex(bytes) {
+    let out = '';
+    for (const b of bytes)
+        out += b.toString(16).padStart(2, '0');
+    return out;
+}
+export function bytesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+/* 2026-10-01: 原注释「群/网络共用: 任何成员都可写」已不成立 —— 索引默认创建者独占, 见 INDEX_ACCESS */
+/**
+ * 索引 store 的访问控制 (2026-10-01 收紧)。
+ *
+ * 之前是 `write: ['*']` —— 任何人可写。索引是**派生数据**, 而且**查询面读的正是它** (event-query.ts)
+ * ⇒ 放开的后果不是"多几行垃圾", 而是**查询结果可被投毒**。所以默认收紧成**创建者独占**
+ * (@orbitdb/core 的默认语义: 不传 write 列表 ⇒ write=[创建者身份 id])。
+ *
+ * 要与别人共享同一份索引 (例如由一个可信索引者统一派生、其他人只读), 由调用方显式传写身份。
+ *
+ * 如实记一条**未做**: 查询面目前**不校验**索引项与事件流的一致性 (P2 的 rebuildIndexes 能重建,
+ * 但"读到一份被改过的索引"这件事现在无法被查询侧发现)。要么后续加校验, 要么索引只由本节点自己派生。
+ */
+export const INDEX_ACCESS = {};
+export async function openIndexStores(opener, names = INDEX_STORE_NAMES) {
+    const stores = {};
+    for (const name of names)
+        stores[name] = await opener.openStore(name, 'keyvalue', INDEX_ACCESS);
+    return stores;
+}
+/** 把 bundle 写进真 store (幂等: 同 key 同值覆盖) */
+export async function writeBundle(stores, bundle) {
+    let n = 0;
+    for (const name of INDEX_STORE_NAMES) {
+        for (const e of bundle[name]) {
+            await stores[name].put(e.key, e.value);
+            n++;
+        }
+    }
+    return n;
+}
+/** 增量写: 只写这一个事件该写的项 (P4 的日常路径) */
+export async function applyEvent(stores, ev) {
+    const derived = deriveIndexEntries(ev);
+    for (const d of derived)
+        await stores[d.store].put(d.key, d.value);
+    return derived;
+}
+/**
+ * 从真 store 读回全部索引内容 → bundle。
+ * 排序 + 去重与 rebuildIndexes 同一套规则 ⇒ 可直接比指纹。
+ */
+export async function readBundleFromStores(stores) {
+    const bundle = { 'by-topic': [], 'by-capability': [], 'by-time': [] };
+    for (const name of INDEX_STORE_NAMES) {
+        const all = await stores[name].all();
+        for (const e of all)
+            bundle[name].push({ store: name, key: String(e.key), value: e.value });
+    }
+    for (const name of INDEX_STORE_NAMES)
+        bundle[name] = sortDedupe(bundle[name]);
+    return bundle;
+}
+/** store 里现有的全部 key (删索引前的留档 / 裁剪用) */
+export async function storeKeys(stores) {
+    const out = {};
+    for (const name of INDEX_STORE_NAMES) {
+        const all = await stores[name].all();
+        out[name] = all.map((e) => String(e.key)).sort();
+    }
+    return out;
+}
+/**
+ * 裁剪: 删掉不在 keep 里的 key。store 没暴露 del 就**如实报 skipped**, 不假装删了。
+ */
+export async function pruneIndexes(stores, bundle) {
+    let removed = 0;
+    const skipped = [];
+    for (const name of INDEX_STORE_NAMES) {
+        const keep = new Set(bundle[name].map((e) => e.key));
+        const store = stores[name];
+        const all = await store.all();
+        const stale = all.map((e) => String(e.key)).filter((k) => !keep.has(k));
+        if (!stale.length)
+            continue;
+        if (typeof store.del !== 'function') {
+            skipped.push(`${name}: ${stale.length} 个陈旧 key (store 未暴露 del)`);
+            continue;
+        }
+        for (const k of stale) {
+            await store.del(k);
+            removed++;
+        }
+    }
+    return { removed, skipped };
+}
+/** 递归收集一个值里的全部字符串叶子 (正文只可能**整段**落在某个叶子字段里, 不会跨字段拼接) */
+function stringLeaves(v, out = []) {
+    if (typeof v === 'string')
+        out.push(v);
+    else if (Array.isArray(v))
+        for (const x of v)
+            stringLeaves(x, out);
+    else if (typeof v === 'object' && v !== null)
+        for (const k of Object.keys(v))
+            stringLeaves(v[k], out);
+    return out;
+}
+const MIN_BODY_FOR_FULL_CHECK = 64; // 太短的"正文"没有判据意义
+const MIN_TAIL_FOR_CHECK = 32;
+/**
+ * 反事实检查: 索引项里**有没有正文**。三件事分开报, 不混成一个 bool:
+ *   · forbiddenKeys   — 结构面: 出现了白名单以外的键 (比如 content/body/text)
+ *   · fullBodyHits    — 内容面: 整段正文出现在索引项的某个字段里
+ *   · overBudgetHits  — 长度面: 正文里超过摘要预算 (bodyCharBudget) 的那一段出现在索引里
+ * `bodyOf(ev)` 由调用方给 (外壳本身不带正文 —— 这正是设计): 返回 null 表示这个事件没有正文可比。
+ */
+export function indexLeakReport(events, bundle, opts) {
+    const budget = opts.bodyCharBudget ?? MAX_SUMMARY_LEN;
+    const forbidden = new Set();
+    let maxEntryKeys = 0;
+    let totalIndexBytes = 0;
+    let totalBodyChars = 0;
+    let fullBodyHits = 0;
+    let overBudgetHits = 0;
+    const unchecked = [];
+    const details = [];
+    const allowed = new Set(ALLOWED_INDEX_ENTRY_KEYS);
+    const byEvent = new Map();
+    for (const name of INDEX_STORE_NAMES) {
+        for (const e of bundle[name]) {
+            const list = byEvent.get(e.value.id) ?? [];
+            list.push(e.value);
+            byEvent.set(e.value.id, list);
+        }
+    }
+    for (const ev of events) {
+        const entries = byEvent.get(ev.id) ?? [];
+        byEvent.delete(ev.id);
+        const leaves = [];
+        const keys = [];
+        let bytes = 0;
+        for (const e of entries) {
+            for (const k of Object.keys(e)) {
+                keys.push(k);
+                if (!allowed.has(k))
+                    forbidden.add(k);
+            }
+            bytes += canonicalJson(e).length;
+            stringLeaves(e, leaves);
+        }
+        maxEntryKeys = Math.max(maxEntryKeys, new Set(keys).size);
+        totalIndexBytes += bytes;
+        const bodyStr = opts.bodyOf(ev);
+        let fullHit = false;
+        let tailHit = false;
+        if (bodyStr !== null) {
+            if (bodyStr.length >= MIN_BODY_FOR_FULL_CHECK)
+                fullHit = leaves.some((s) => s.includes(bodyStr));
+            if (bodyStr.length > budget) {
+                const tail = bodyStr.slice(budget);
+                if (tail.length >= MIN_TAIL_FOR_CHECK)
+                    tailHit = leaves.some((s) => s.includes(tail));
+            }
+        }
+        if (fullHit)
+            fullBodyHits++;
+        if (tailHit)
+            overBudgetHits++;
+        if (bodyStr === null)
+            unchecked.push(ev.id);
+        else
+            totalBodyChars += bodyStr.length;
+        details.push({
+            id: ev.id,
+            entryKeys: Array.from(new Set(keys)).sort(),
+            entryBytes: bytes,
+            bodyChars: bodyStr === null ? 0 : bodyStr.length,
+            fullBodyHit: fullHit,
+            overBudgetHit: tailHit,
+        });
+    }
+    details.sort((a, b) => (a.id < b.id ? -1 : 1));
+    return {
+        forbiddenKeys: Array.from(forbidden).sort(),
+        fullBodyHits,
+        overBudgetHits,
+        checkedEvents: details.length - unchecked.length,
+        uncheckedEvents: unchecked,
+        orphanEntryIds: Array.from(byEvent.keys()).sort(),
+        maxEntryKeys,
+        totalIndexBytes,
+        totalBodyChars,
+        details,
+    };
+}

package/dist/orbitdb/event-query.js

@@ -0,0 +1,131 @@
+/**
+ * event-query.ts — 事件网络的**查询面** (P4, 2026-10-01)
+ *
+ * 定位: 1 万 agent 的目标里 "记录可被查询和调用" 是半壁。OrbitDB 只能按 key 迭代, 没有查询面;
+ * 本模块把 P2 的三个索引 store (by-topic / by-capability / by-time) 变成可查询的读口,
+ * 并且**只出元数据 + CID** —— 正文永远要按 CID 单独取 (L2/L3 分层, 与 cid-database 的惰性取块一致)。
+ *
+ * 三条硬规则 (都写进判据, 不靠自觉):
+ *   ① 同一份索引 + 同一个查询 ⇒ **逐条相同**的结果 (纯函数, 无时钟无网络无随机);
+ *   ② 窄范围查询**不许扫全量**: by-time 的 ts 是 13 位补零 ⇒ 字符串序 = 时间序 ⇒ 先用二分定位起点,
+ *      再顺序扫到 until 为止 (超出即停), 并如实报 keysRead / keysScanned 两个数;
+ *   ③ **没有索引时不许假装成功**: 返回空结果 + 显式 degraded 标注 (reason), 由调用方决定怎么办
+ *      (可以从事件流重建索引 —— 那是 P2 的 rebuildIndexes)。
+ */
+import { INDEX_STORE_NAMES, parseIndexKey, timeKey, } from './event-index.js';
+const TS_WIDTH = 13;
+const tsPart = (ts) => String(Math.trunc(ts)).padStart(TS_WIDTH, '0');
+/** 选索引: 有时间窗就用 by-time (可裁剪), 否则按 topic / capability */
+export function planQuery(q) {
+    if (q.since !== undefined || q.until !== undefined)
+        return 'by-time';
+    if (q.topic)
+        return 'by-topic';
+    if (q.capability)
+        return 'by-capability';
+    return 'by-time';
+}
+function matches(entry, q) {
+    if (q.topic && entry.topic !== q.topic)
+        return false;
+    if (q.capability && entry.capability !== q.capability)
+        return false;
+    if (q.actor && entry.actor !== q.actor)
+        return false;
+    if (q.actorId && entry.actorId !== q.actorId)
+        return false;
+    if (q.group && entry.group !== q.group)
+        return false;
+    if (q.type) {
+        const want = Array.isArray(q.type) ? q.type : [q.type];
+        if (!want.includes(entry.type))
+            return false;
+    }
+    if (q.since !== undefined && entry.ts < q.since)
+        return false;
+    if (q.until !== undefined && entry.ts > q.until)
+        return false;
+    return true;
+}
+/** 二分: 第一个 ts >= 目标的 key 下标 (by-time 的 key 前缀就是补零 ts) */
+function lowerBoundTime(sortedKeys, targetTs) {
+    const target = tsPart(targetTs);
+    let lo = 0, hi = sortedKeys.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if ((sortedKeys[mid] ?? '') < target)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+/**
+ * 纯函数查询: 输入一份索引 (P2 的 IndexBundle), 输出结果 + 真实扫描计数。
+ * by-time 的范围裁剪在这里发生 —— 超出 until 立刻停 (不是"全扫一遍再过滤")。
+ */
+export function queryIndexBundle(bundle, q) {
+    const store = planQuery(q);
+    const all = bundle[store] ?? [];
+    const keys = all.map((d) => d.key).sort(); // 排序 = 复制一份并排好 (by-time 的 key 天然时间序)
+    const byKey = new Map(all.map((d) => [d.key, d.value]));
+    let keysScanned = 0;
+    const out = [];
+    const start = q.since !== undefined && store === 'by-time' ? lowerBoundTime(keys, q.since) : 0;
+    for (let i = start; i < keys.length; i++) {
+        const key = keys[i];
+        let ts;
+        try {
+            ts = Number(key.split('::')[0]);
+        }
+        catch {
+            ts = NaN;
+        }
+        if (store === 'by-time' && q.until !== undefined && ts > q.until)
+            break; // ← 早停: 不扫全量
+        keysScanned++;
+        const parsed = parseIndexKey(store, key);
+        if (!parsed)
+            continue; // 反解不出的不硬凑
+        const entry = byKey.get(key);
+        if (!entry)
+            continue;
+        if (matches(entry, q))
+            out.push(entry);
+    }
+    out.sort((a, b) => (a.ts - b.ts) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    const limited = q.limit !== undefined && out.length > q.limit ? out.slice(0, q.limit) : out;
+    return {
+        items: limited,
+        store,
+        keysRead: keys.length,
+        keysScanned,
+        complete: q.limit === undefined || out.length <= q.limit,
+    };
+}
+/** 从真 store 的 key 列表构造一个 IndexBundle (读侧用; key 列表由 P2 的 storeKeys 提供) */
+export function bundleFromKeys(keys, values) {
+    const out = {};
+    for (const store of INDEX_STORE_NAMES) {
+        out[store] = (keys[store] ?? []).map((key) => ({ store, key, value: values[store]?.[key] }))
+            .filter((d) => d.value !== undefined && d.value !== null);
+    }
+    return out;
+}
+/** 空索引入口: 调用方拿到它必须知道"这是没有索引", 不是"查不到" */
+export function emptyIndexDegradation() {
+    return {
+        reason: 'no-index',
+        hint: '这个节点上没有索引项。可以从事件流重建 (event-index.rebuildIndexes) 后重查; 不要把它当"查询结果为空"。',
+    };
+}
+/** 便捷: 全空 bundle */
+export function emptyBundle() {
+    return { 'by-topic': [], 'by-capability': [], 'by-time': [] };
+}
+/** 全空 bundle 上的查询 —— 必须带 degraded 标注 (判据 ③) */
+export function queryWithoutIndex(q) {
+    const r = queryIndexBundle(emptyBundle(), q);
+    return { ...r, degraded: emptyIndexDegradation() };
+}
+export { timeKey };