Skip to content

Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演

32.7 KB
Raw Blame
import { COMPOSER_STATE_REVISION_KEY, COMPOSER_TOOLS_KEY, createComposerToolStorage } from './composer-tool-storage.js';
import { assistantChatViews } from './assistant-chat-view.js';
import { COMPOSER_DRAFTS_KEY, withComposerDrafts, withAssistantChatDrafts } from './composer-session-drafts.js';
import { LIBRARY_VIEW_SUMMARY_KEY, LIBRARY_VIEW_SUMMARY_SOURCES, updateLibraryViewSummary, composerSessionSummaries } from './library-view-summary.js';
import { jsonBytes, startPhase } from "./perf-trace.js";
import { assertLibraryWritable } from "./library-version-guard.js";
import { SCHEMA_VERSION } from "./taxonomy.js";
import { BROWSE_PROJECTION_VERSION, BROWSE_PROJECTION_META_KEY, caseBrowseKey, caseBrowseProjection } from "./library-browse-index.js";
import { CASE_INDEX_KEY, ENTRIES_KEY, LEGACY_ENTRIES_KEY, assembleEntries, caseIdFromRecordKey, caseIndexFor, caseRecordKey,
  caseText, indexedCaseIds, isCaseRecordKey, keyableEntries, planCaseWrite, sameCaseValue, translateCaseChanges } from "./library-case-records.js";

// The case library records a reader needs to find, show and edit cases.
export const CASE_LIBRARY_KEYS = Object.freeze(['schemaVersion', 'entries', 'trashState', 'compoundCases',
  'taxonomy', 'facetCatalog', 'classificationRules', 'organizerState']);
// Written in the same storage call as any case library change, so an unchanged value proves the
// records are unchanged; removing a case key drops it, which disables reuse until the next write.
export const CASE_LIBRARY_REVISION_KEY = 'caseLibraryRevision';
const isBrowseKey = key => key === BROWSE_PROJECTION_META_KEY || key.startsWith('caseView:');
const browseMarker = revision => ({ format: BROWSE_PROJECTION_VERSION, revision });
const validBrowseMarker = (marker, revision) => Boolean(revision) && marker?.format === BROWSE_PROJECTION_VERSION && marker.revision === revision;
const browseRecords = entries => Object.fromEntries(entries.map(entry => [caseBrowseKey(entry.id), caseBrowseProjection(entry)]));
const touchesCaseLibrary = keys => keys.some(key => CASE_LIBRARY_KEYS.includes(key));
const freezeCaseSnapshot = value => {
  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
  Object.freeze(value);
  for (const item of Object.values(value)) freezeCaseSnapshot(item);
  return value;
};

// Browser metadata writes share one lock across extension pages. Read/modify/write
// commits preserve concurrent sync markers; originals stay in media-store.js.
export function createLibraryStorage({ backend, changes, lock, revision = () => globalThis.crypto.randomUUID(), assertWritable = async () => {} }) {
  if (!["get", "set", "remove"].every(name => typeof backend?.[name] === "function") || typeof lock !== "function") {
    throw new Error("资料读写接口缺少存储或写入协调能力。");
  }
  const toolStorage = createComposerToolStorage({ backend, revision, cleanup: async keys => {
    if (keys.length) await backend.remove(keys).catch(error => console.warn('Tool journal cleanup deferred', error.name));
  } });
  const withRevision = update => touchesCaseLibrary(Object.keys(update))
    ? { ...update, [CASE_LIBRARY_REVISION_KEY]: revision() } : update;
  const withSummary = async update => {
    update = withRevision(update);
    if (Object.hasOwn(update, 'composerSessions') || Object.hasOwn(update, COMPOSER_DRAFTS_KEY)) {
      update = { ...update, [COMPOSER_STATE_REVISION_KEY]: revision() };
    }
    if (Object.hasOwn(update, 'composerSessions')) {
      const sessions = update.composerSessions;
      update = { ...update, composerSessions: sessions, [COMPOSER_DRAFTS_KEY]: {}, composerSessionSummaries: composerSessionSummaries(sessions), assistantChatViews: assistantChatViews(sessions) };
    }
    if (!LIBRARY_VIEW_SUMMARY_SOURCES.some(key => Object.hasOwn(update, key))) return update;
    const stored = await backend.get(LIBRARY_VIEW_SUMMARY_KEY);
    return { ...update, [LIBRARY_VIEW_SUMMARY_KEY]: updateLibraryViewSummary(update[LIBRARY_VIEW_SUMMARY_KEY] || stored[LIBRARY_VIEW_SUMMARY_KEY], update) };
  };
  // Independent snapshots as last stored by this page, valid while its revision is unchanged.
  let caseCache = null;
  const updateCachedCases = (values, area = 'local') => {
    if (area !== 'local' || !caseCache) return;
    const change = values[CASE_LIBRARY_REVISION_KEY];
    if (!change) {
      if (Object.hasOwn(values, CASE_INDEX_KEY) || Object.keys(values).some(key => isCaseRecordKey(key) && caseCache.values.has(caseIdFromRecordKey(key)))) caseCache = null;
      return;
    }
    if (change.newValue && change.newValue === caseCache.revision) return;
    if (!change.newValue || change.oldValue !== caseCache.revision) { caseCache = null; return; }
    const ids = Object.hasOwn(values, CASE_INDEX_KEY) ? indexedCaseIds(values[CASE_INDEX_KEY].newValue) : caseCache.ids;
    if (!ids) { caseCache = null; return; }
    const records = new Map(caseCache.values);
    for (const [key, item] of Object.entries(values)) if (isCaseRecordKey(key)) {
      if (Object.hasOwn(item, 'newValue')) records.set(caseIdFromRecordKey(key), structuredClone(item.newValue));
      else records.delete(caseIdFromRecordKey(key));
    }
    const kept = new Set(ids);
    const removed = [...records.keys()].filter(id => !kept.has(id));
    for (const id of removed) records.delete(id);
    if (ids.some(id => !records.has(id))) { caseCache = null; return; }
    caseCache = { revision: change.newValue, ids: [...ids], values: records,
      orphanKeys: caseCache.orphanKeys === null ? null : [...caseCache.orphanKeys, ...removed.map(caseRecordKey)] };
  };
  changes?.addListener(updateCachedCases);
  const records = async ids => {
    const values = ids.length ? await backend.get(ids.map(caseRecordKey)) : {};
    return Object.fromEntries(Object.entries(values).map(([key, value]) => [caseIdFromRecordKey(key), value]));
  };
  // Reads see one consistent library: the records are read again if a write landed in between,
  // and a record named by the index but absent is reported instead of showing fewer cases.
  const withCases = async (stored, wantsRevision, refetch, readonlyEntries) => {
    for (let attempt = 0; attempt < 5; attempt++) {
      const index = stored[CASE_INDEX_KEY];
      const ids = indexedCaseIds(index) ?? [];
      const cached = caseCache && stored[CASE_LIBRARY_REVISION_KEY] && caseCache.revision === stored[CASE_LIBRARY_REVISION_KEY] ? caseCache : null;
      const found = cached ? Object.fromEntries(cached.values) : await records(ids);
      const { [CASE_LIBRARY_REVISION_KEY]: revision } = ids.length ? await backend.get([CASE_LIBRARY_REVISION_KEY]) : stored;
      if (revision !== stored[CASE_LIBRARY_REVISION_KEY]) {
        stored = await refetch();
        if (!stored[CASE_INDEX_KEY]) return stored;
        continue;
      }
      const assembled = assembleEntries(index, found, stored[ENTRIES_KEY]);
      if (assembled.missingIds.length) throw Object.assign(new Error(`资料库有 ${assembled.missingIds.length} 个案例记录读取不到,已停止读取;资料没有改动`), { code: "CASE_RECORDS_MISSING", missingIds: assembled.missingIds.slice(0, 20) });
      if (!cached && revision) caseCache = { revision, ids, values: new Map(Object.entries(found)), orphanKeys: null };
      const { [CASE_INDEX_KEY]: _index, ...rest } = stored;
      if (!wantsRevision) delete rest[CASE_LIBRARY_REVISION_KEY];
      return { ...rest, [ENTRIES_KEY]: readonlyEntries ? freezeCaseSnapshot(assembled.entries) : structuredClone(assembled.entries) };
    }
    throw Object.assign(new Error("资料库正在连续写入,暂时读不到一致的案例;请稍后重试"), { code: "CASE_RECORDS_BUSY" });
  };
  const readComposerDrafts = async keys => {
    const names = typeof keys === 'string' ? [keys] : Array.isArray(keys) ? keys : Object.keys(keys || {});
    const wantsSessions = keys == null || names.includes('composerSessions');
    const wantsViews = keys == null || names.includes('assistantChatViews');
    const requested = keys == null ? keys : wantsSessions || wantsViews ? [...new Set([...names, COMPOSER_DRAFTS_KEY, ...(wantsSessions ? [COMPOSER_TOOLS_KEY] : [])])] : keys;
    const stored = await backend.get(requested);
    if (wantsSessions && Object.hasOwn(stored, 'composerSessions')) {
      await toolStorage.join(stored);
      stored.composerSessions = withComposerDrafts(stored.composerSessions, stored[COMPOSER_DRAFTS_KEY]);
    }
    if (keys == null) toolStorage.strip(stored);
    else if (!names.includes(COMPOSER_TOOLS_KEY)) delete stored[COMPOSER_TOOLS_KEY];
    if (wantsViews && Object.hasOwn(stored, 'assistantChatViews')) stored.assistantChatViews = withAssistantChatDrafts(stored.assistantChatViews, stored[COMPOSER_DRAFTS_KEY]);
    if (!names.includes(COMPOSER_DRAFTS_KEY)) delete stored[COMPOSER_DRAFTS_KEY];
    if (keys && !Array.isArray(keys) && typeof keys === 'object') for (const [key, value] of Object.entries(keys)) if (!Object.hasOwn(stored, key)) stored[key] = value;
    return stored;
  };
  const read = async (keys, readonlyEntries = false) => {
    if (keys == null) {
      const all = await readComposerDrafts(keys);
      if (!all[CASE_INDEX_KEY]) {
        if (readonlyEntries) freezeCaseSnapshot(all[ENTRIES_KEY]);
        return Object.fromEntries(Object.entries(all).filter(([key]) => !isCaseRecordKey(key) && !isBrowseKey(key) && key !== CASE_INDEX_KEY));
      }
      const ids = indexedCaseIds(all[CASE_INDEX_KEY]) ?? [];
      const found = Object.fromEntries(ids.filter(id => Object.hasOwn(all, caseRecordKey(id))).map(id => [id, all[caseRecordKey(id)]]));
      const assembled = assembleEntries(all[CASE_INDEX_KEY], found, all[ENTRIES_KEY]);
      if (assembled.missingIds.length) throw Object.assign(new Error(`资料库有 ${assembled.missingIds.length} 个案例记录读取不到,已停止读取;资料没有改动`), { code: "CASE_RECORDS_MISSING", missingIds: assembled.missingIds.slice(0, 20) });
      const rest = Object.fromEntries(Object.entries(all).filter(([key]) => !isCaseRecordKey(key) && !isBrowseKey(key) && key !== CASE_INDEX_KEY));
      return { ...rest, [ENTRIES_KEY]: readonlyEntries ? freezeCaseSnapshot(assembled.entries) : assembled.entries };
    }
    const defaults = typeof keys === 'object' && !Array.isArray(keys) ? keys : null;
    const names = typeof keys === 'string' ? [keys] : defaults ? Object.keys(defaults) : keys;
    if (!names.includes(ENTRIES_KEY)) return readComposerDrafts(keys);
    const fetch = () => readComposerDrafts([...new Set([...names, CASE_INDEX_KEY, CASE_LIBRARY_REVISION_KEY])]);
    const stored = await fetch();
    const result = stored[CASE_INDEX_KEY] ? await withCases(stored, true, fetch, readonlyEntries) : stored;
    if (!names.includes(CASE_INDEX_KEY)) delete result[CASE_INDEX_KEY];
    if (!names.includes(CASE_LIBRARY_REVISION_KEY)) delete result[CASE_LIBRARY_REVISION_KEY];
    if (defaults) for (const [key, value] of Object.entries(defaults)) if (!Object.hasOwn(result, key)) result[key] = readonlyEntries && key === ENTRIES_KEY ? structuredClone(value) : value;
    if (readonlyEntries) freezeCaseSnapshot(result[ENTRIES_KEY]);
    return result;
  };
  // Progressive reads keep partial records private to this iterator. Only a verified, complete
  // result becomes the shared library cache; callers choose budgets from their visible layout.
  async function* getSnapshotBatches(keys, { batchSize, selectIds, useBrowseIndex = false } = {}) {
    const names = typeof keys === 'string' ? [keys] : Array.isArray(keys) ? keys : keys && Object.keys(keys);
    if (!names || !names.includes(ENTRIES_KEY)) throw new Error('分批读取需要指定案例列表');
    if (typeof backend.getKeys !== 'function') { yield { requiresFullRead: true }; return; }
    const [stored, storageKeys] = await Promise.all([
      readComposerDrafts([...new Set([...names.filter(key => key !== ENTRIES_KEY), 'schemaVersion', CASE_INDEX_KEY, CASE_LIBRARY_REVISION_KEY, ...(useBrowseIndex ? [BROWSE_PROJECTION_META_KEY] : [])])]),
      backend.getKeys()
    ]);
    const indexed = indexedCaseIds(stored[CASE_INDEX_KEY]);
    if (!indexed || stored.schemaVersion !== SCHEMA_VERSION || storageKeys.includes(ENTRIES_KEY)
      || !stored[CASE_LIBRARY_REVISION_KEY]) { yield { requiresFullRead: true }; return; }
    const entryIds = Object.freeze([...indexed]);
    const expectedRevision = stored[CASE_LIBRARY_REVISION_KEY];
    const { [CASE_INDEX_KEY]: _index, [CASE_LIBRARY_REVISION_KEY]: _revision, [BROWSE_PROJECTION_META_KEY]: _browse, ...metadata } = stored;
    const assertCurrent = async () => {
      const current = await backend.get([CASE_LIBRARY_REVISION_KEY, 'schemaVersion']);
      if (current[CASE_LIBRARY_REVISION_KEY] !== expectedRevision || current.schemaVersion !== SCHEMA_VERSION) {
        throw Object.assign(new Error('案例库已更新,请重新读取当前内容'), { code: 'CASE_RECORDS_CHANGED' });
      }
    };
    const makeResult = values => ({
      stored: { ...metadata, [ENTRIES_KEY]: freezeCaseSnapshot(entryIds.filter(id => values.has(id)).map(id => values.get(id))) },
      entryIds, loaded: values.size, total: entryIds.length, complete: values.size === entryIds.length, revision: expectedRevision
    });
    if (!useBrowseIndex && caseCache?.revision === expectedRevision) {
      const cached = caseCache;
      await assertCurrent();
      yield makeResult(cached.values);
      return;
    }
    const found = new Map();
    if (!entryIds.length) {
      if (useBrowseIndex) metadata.browseEntries = Object.freeze([]);
      await assertCurrent();
      caseCache = { revision: expectedRevision, ids: [], values: found, orphanKeys: null };
      yield makeResult(found);
      return;
    }
    yield makeResult(found);
    if (useBrowseIndex) {
      let thin;
      if (validBrowseMarker(stored[BROWSE_PROJECTION_META_KEY], expectedRevision)) {
        thin = await backend.get(entryIds.map(caseBrowseKey));
        await assertCurrent();
      }
      if (!thin || entryIds.some(id => thin[caseBrowseKey(id)]?.id !== id)) {
        // This disposable directory is backfilled once for existing libraries, using the same
        // verified full snapshot the view will receive. Cache writes never alter formal revision.
        thin = await lock(async () => {
          await assertCurrent();
          if ((await backend.getKeys()).includes(ENTRIES_KEY)) throw Object.assign(new Error('案例库已更新,请重新读取当前内容'), { code: 'CASE_RECORDS_CHANGED' });
          const values = caseCache?.revision === expectedRevision ? caseCache.values : new Map(Object.entries(await records(entryIds)));
          const missingIds = entryIds.filter(id => !values.has(id));
          if (missingIds.length) throw Object.assign(new Error(`资料库有 ${missingIds.length} 个案例记录读取不到,资料没有改动`), { code: 'CASE_RECORDS_MISSING', missingIds: missingIds.slice(0, 20) });
          await assertCurrent();
          const projections = browseRecords(entryIds.map(id => values.get(id)));
          try {
            await backend.set({ ...projections, [BROWSE_PROJECTION_META_KEY]: browseMarker(expectedRevision) });
          } catch (error) {
            console.warn('PromptDirector: browse cache could not be saved; using the verified cases', error);
          }
          caseCache = { revision: expectedRevision, ids: [...entryIds], values, orphanKeys: null };
          return projections;
        });
      }
      metadata.browseEntries = freezeCaseSnapshot(entryIds.map(id => thin[caseBrowseKey(id)]));
      if (caseCache?.revision === expectedRevision) {
        const cached = caseCache;
        await assertCurrent();
        yield makeResult(cached.values);
        return;
      }
    }
    const known = new Set(entryIds);
    const groupById = new Map();
    for (const compound of Array.isArray(metadata.compoundCases) ? metadata.compoundCases : []) {
      const members = (Array.isArray(compound?.memberEntryIds) ? compound.memberEntryIds : []).filter(id => known.has(id));
      const group = [...new Set(members.flatMap(id => groupById.get(id) ?? [id]))];
      for (const id of group) groupById.set(id, group);
    }
    while (found.size < entryIds.length) {
      const selected = selectIds ? await selectIds({ ids: entryIds, stored: metadata }) : [];
      if (!Array.isArray(selected)) throw new Error('首批案例选择无效');
      const order = [...new Set([...selected.filter(id => known.has(id)), ...entryIds])];
      let position = 0;
      const budget = typeof batchSize === 'function' ? batchSize({ loaded: found.size, total: entryIds.length }) : batchSize;
      if (!Number.isSafeInteger(budget) || budget < 1) throw new Error('每批读取数量必须是正整数');
      const pending = new Set();
      while (position < order.length && pending.size < budget) {
        const id = order[position++];
        if (found.has(id)) continue;
        for (const member of groupById.get(id) ?? [id]) if (!found.has(member)) pending.add(member);
      }
      const batch = await records([...pending]);
      await assertCurrent();
      const missingIds = [...pending].filter(id => !Object.hasOwn(batch, id));
      if (missingIds.length) throw Object.assign(new Error(`资料库有 ${missingIds.length} 个案例记录读取不到,资料没有改动`),
        { code: 'CASE_RECORDS_MISSING', missingIds: missingIds.slice(0, 20) });
      for (const [id, entry] of Object.entries(batch)) found.set(id, entry);
      if (found.size === entryIds.length) {
        // An older version can add a plain list without a revision. Never silently omit it.
        if ((await backend.getKeys()).includes(ENTRIES_KEY)) throw Object.assign(new Error('案例库已更新,请重新读取当前内容'), { code: 'CASE_RECORDS_CHANGED' });
        await assertCurrent();
        caseCache = { revision: expectedRevision, ids: [...entryIds], values: found, orphanKeys: null };
      }
      yield makeResult(found);
    }
  }
  const storedCases = async (ids, revision) => {
    const cached = caseCache && revision && caseCache.revision === revision ? caseCache : null;
    if (cached && cached.orphanKeys !== null) return cached;
    const values = cached?.values ?? new Map(Object.entries(await records(ids)));
    // Records left by an interrupted removal are not part of the library; clear them with this write.
    const orphanKeys = typeof backend.getKeys === 'function'
      ? (await backend.getKeys()).filter(key => (isCaseRecordKey(key) && !values.has(caseIdFromRecordKey(key)))
        || (key.startsWith('caseView:') && !values.has(key.slice('caseView:'.length)))) : [];
    return { revision, ids, values, orphanKeys };
  };
  const cleanup = async keys => {
    if (!keys.length) return [];
    try {
      await backend.remove(keys);
      return [];
    } catch (error) {
      console.warn('PromptDirector: auxiliary case cleanup will retry', error);
      return keys;
    }
  };
  // Stage and verify the records before publishing their index. An interrupted readback leaves
  // the old list and version active; only the final commit switches the library to the new layout.
  const switchToCaseRecords = async (update, plainEntries, hadLegacyCopy, storageKeys) => {
    const entries = update[ENTRIES_KEY];
    const { [ENTRIES_KEY]: _entries, ...rest } = update;
    const payload = Object.fromEntries(entries.map(entry => [caseRecordKey(entry.id), entry]));
    if (Array.isArray(plainEntries) && !hadLegacyCopy) payload[LEGACY_ENTRIES_KEY] = plainEntries;
    await backend.set(payload);
    const back = await backend.get(entries.map(entry => caseRecordKey(entry.id)));
    const intact = entries.every(entry => caseText(back[caseRecordKey(entry.id)]) === caseText(entry));
    if (!intact) {
      await cleanup(entries.map(entry => caseRecordKey(entry.id)));
      throw Object.assign(new Error("按案例保存的核对没有通过,仍使用原来的资料;资料没有丢失"), { code: "CASE_RECORDS_VERIFY_FAILED" });
    }
    // Empty the old list in the commit itself: a failed removal must not resurrect deleted cases.
    await backend.set({ ...rest, ...browseRecords(entries), [BROWSE_PROJECTION_META_KEY]: browseMarker(update[CASE_LIBRARY_REVISION_KEY]), [CASE_INDEX_KEY]: caseIndexFor(entries), ...(Array.isArray(plainEntries) ? { [ENTRIES_KEY]: [] } : {}) });
    const values = new Map(entries.map(entry => [entry.id, back[caseRecordKey(entry.id)]]));
    const kept = new Set(entries.flatMap(entry => [caseRecordKey(entry.id), caseBrowseKey(entry.id)]));
    const leftovers = storageKeys.filter(key => (isCaseRecordKey(key) || key.startsWith('caseView:')) && !kept.has(key));
    caseCache = { revision: update[CASE_LIBRARY_REVISION_KEY], ids: entries.map(entry => entry.id), values,
      orphanKeys: await cleanup([...leftovers, ...(Array.isArray(plainEntries) ? [ENTRIES_KEY] : [])]) };
  };
  const write = async update => {
    if (!Object.hasOwn(update, ENTRIES_KEY)) {
      if (Object.hasOwn(update, CASE_LIBRARY_REVISION_KEY)) {
        const current = await backend.get([CASE_LIBRARY_REVISION_KEY, BROWSE_PROJECTION_META_KEY]);
        if (validBrowseMarker(current[BROWSE_PROJECTION_META_KEY], current[CASE_LIBRARY_REVISION_KEY])) {
          update = { ...update, [BROWSE_PROJECTION_META_KEY]: browseMarker(update[CASE_LIBRARY_REVISION_KEY]) };
        }
      }
      return backend.set(update);
    }
    const entries = update[ENTRIES_KEY];
    const stored = await backend.get(['schemaVersion', CASE_INDEX_KEY, CASE_LIBRARY_REVISION_KEY, ENTRIES_KEY, BROWSE_PROJECTION_META_KEY]);
    const split = Boolean(stored[CASE_INDEX_KEY]);
    if (!keyableEntries(entries)) {
      if (split) throw Object.assign(new Error("案例编号缺失或重复,无法保存;资料没有改动"), { code: "CASE_ID_INVALID" });
      console.warn("PromptDirector: cases without distinct ids stay in the single list", { count: Array.isArray(entries) ? entries.length : 0 });
      return backend.set(update);
    }
    if (!split) {
      // Only a library at the current version is moved, so an older version that refuses newer
      // libraries never meets records it cannot read.
      const version = Object.hasOwn(update, 'schemaVersion') ? update.schemaVersion : stored.schemaVersion;
      if (version !== SCHEMA_VERSION) return backend.set(update);
      const storageKeys = typeof backend.getKeys === 'function' ? await backend.getKeys() : [];
      const hadLegacyCopy = typeof backend.getKeys === 'function'
        ? storageKeys.includes(LEGACY_ENTRIES_KEY)
        : Object.hasOwn(await backend.get(LEGACY_ENTRIES_KEY), LEGACY_ENTRIES_KEY);
      return switchToCaseRecords(update, stored[ENTRIES_KEY], hadLegacyCopy, storageKeys);
    }
    const cache = await storedCases(indexedCaseIds(stored[CASE_INDEX_KEY]) ?? [], stored[CASE_LIBRARY_REVISION_KEY]);
    const plan = planCaseWrite(entries, cache.ids, cache.values);
    const { [ENTRIES_KEY]: _entries, ...rest } = update;
    const hasPlainEntries = Object.hasOwn(stored, ENTRIES_KEY);
    const projected = validBrowseMarker(stored[BROWSE_PROJECTION_META_KEY], stored[CASE_LIBRARY_REVISION_KEY]) ? Object.values(plan.records) : entries;
    await backend.set({ ...rest, ...plan.records, ...browseRecords(projected), [BROWSE_PROJECTION_META_KEY]: browseMarker(update[CASE_LIBRARY_REVISION_KEY]), ...(plan.index ? { [CASE_INDEX_KEY]: plan.index } : {}),
      ...(hasPlainEntries ? { [ENTRIES_KEY]: [] } : {}) });
    // A plain list beside the records came from an older version; its cases are part of this write.
    const kept = new Set(plan.ids.flatMap(id => [caseRecordKey(id), caseBrowseKey(id)]));
    const leftovers = [...plan.removedKeys.flatMap(key => [key, caseBrowseKey(caseIdFromRecordKey(key))]), ...cache.orphanKeys.filter(key => !kept.has(key)),
      ...(hasPlainEntries ? [ENTRIES_KEY] : [])];
    caseCache = { revision: update[CASE_LIBRARY_REVISION_KEY], ids: plan.ids, values: plan.values,
      orphanKeys: await cleanup([...new Set(leftovers)]) };
  };
  const updateCases = (entryIds, transform, { keys = [], metadata = () => ({}) } = {}) => lock(async () => {
    await assertWritable(backend);
    const ids = [...new Set(entryIds)];
    const stored = await backend.get([...new Set([CASE_INDEX_KEY, CASE_LIBRARY_REVISION_KEY, BROWSE_PROJECTION_META_KEY, ...ids.map(caseRecordKey), ...keys])]);
    const indexed = new Set(indexedCaseIds(stored[CASE_INDEX_KEY]) ?? []);
    let entries;
    if (ids.some(id => !indexed.has(id))) {
      // Retain the established old-library merge path, once per batch.
      const plain = await backend.get(ENTRIES_KEY);
      if (plain[ENTRIES_KEY]?.some(entry => ids.includes(entry.id) && !indexed.has(entry.id))) {
        const legacy = indexed.size ? await read([ENTRIES_KEY, ...keys]) : plain;
        entries = legacy[ENTRIES_KEY] ?? [];
        Object.assign(stored, legacy);
      }
    }
    const legacyById = entries && new Map(entries.map(entry => [entry.id, entry]));
    const results = [], records = {};
    for (const id of ids) {
      const current = entries ? legacyById.get(id) : indexed.has(id) ? stored[caseRecordKey(id)] : null;
      if (!current && indexed.has(id)) throw Object.assign(new Error('案例记录读取不到,资料没有改动'), { code: 'CASE_RECORDS_MISSING', missingIds: [id] });
      const next = await transform(current ? structuredClone(current) : null, id);
      // Batch callers can skip a concurrently removed or changed record without losing other results.
      if (!next) continue;
      if (!current) throw Object.assign(new Error('没有找到这条案例'), { code: 'CASE_NOT_FOUND' });
      if (next.id !== id) throw Object.assign(new Error('案例编号不能在编辑时改变,资料没有改动'), { code: 'CASE_ID_INVALID' });
      const changed = !sameCaseValue(current, next);
      results.push({ entry: structuredClone(next), changed });
      if (changed) records[caseRecordKey(id)] = next;
    }
    if (!Object.keys(records).length) return results;
    const extra = await metadata(stored);
    if (!extra || typeof extra !== 'object' || Array.isArray(extra)
      || Object.keys(extra).some(name => touchesCaseLibrary([name]) || name === CASE_INDEX_KEY || name === CASE_LIBRARY_REVISION_KEY || isCaseRecordKey(name) || isBrowseKey(name))) throw new Error('案例附加更新内容无效');
    if (entries) await write(await withSummary({ ...extra, [ENTRIES_KEY]: entries.map(entry => records[caseRecordKey(entry.id)] ?? entry) }));
    else {
      const nextRevision = revision();
      await backend.set({ ...extra, ...records, ...browseRecords(Object.values(records)), [CASE_LIBRARY_REVISION_KEY]: nextRevision,
        ...(validBrowseMarker(stored[BROWSE_PROJECTION_META_KEY], stored[CASE_LIBRARY_REVISION_KEY]) ? { [BROWSE_PROJECTION_META_KEY]: browseMarker(nextRevision) } : {}) });
      updateCachedCases({ ...Object.fromEntries(Object.entries(records).map(([key, value]) => [key, { newValue: value }])),
        [CASE_LIBRARY_REVISION_KEY]: { oldValue: stored[CASE_LIBRARY_REVISION_KEY], newValue: nextRevision } });
    }
    return results;
  });
  const updateCase = async (entryId, transform, options) => (await updateCases([entryId], async current => {
    if (!current) throw Object.assign(new Error('没有找到这条案例'), { code: 'CASE_NOT_FOUND' });
    const next = await transform(current);
    if (!next) throw Object.assign(new Error('案例编号不能在编辑时改变,资料没有改动'), { code: 'CASE_ID_INVALID' });
    return next;
  }, options))[0];
  const writeWithSummary = async values => {
    const replacement = Object.hasOwn(values, 'composerSessions') ? await toolStorage.replacement() : null;
    await write(await withSummary({ ...values, ...replacement?.update }));
    if (replacement?.obsolete.length) await backend.remove(replacement.obsolete).catch(error => console.warn('Tool journal cleanup deferred', error.name));
  };
  return Object.freeze({
    get: read,
    prepareComposerConfirmation: () => lock(async () => { await assertWritable(backend); await toolStorage.confirmationVersion(); }),
    getComposerToolState: id => toolStorage.get(id),
    updateComposerToolState: (id, transform, markDirty) => lock(async () => {
      await assertWritable(backend);
      return toolStorage.update(id, transform, markDirty);
    }),
    // View readers may share frozen case records; editing callers keep the mutable get contract.
    getSnapshot: keys => read(keys, true),
    getSnapshotBatches,
    updateCase,
    updateCases,
    // Available before our minimum Chrome version; never load values to enumerate keys.
    getKeys: () => backend.getKeys(),
    set: values => lock(async () => {
      await assertWritable(backend);
      await writeWithSummary(values);
    }),
    remove: keys => lock(async () => {
      await assertWritable(backend);
      const removed = typeof keys === 'string' ? [keys] : keys;
      const toolReplacement = removed.includes('composerSessions') ? await toolStorage.replacement() : null;
      // Removing the case list removes every case record with its index.
      const caseKeys = removed.includes(ENTRIES_KEY) && typeof backend.getKeys === 'function'
        ? (await backend.getKeys()).filter(key => isCaseRecordKey(key) || isBrowseKey(key) || key === CASE_INDEX_KEY) : [];
      if (caseKeys.length) caseCache = null;
      // Invalidate derived values in the same lock. The next reader rebuilds
      // them from the retained source instead of advertising a deleted undo.
      return backend.remove([...new Set([...removed, ...caseKeys, ...(toolReplacement ? [COMPOSER_TOOLS_KEY, COMPOSER_STATE_REVISION_KEY, ...toolReplacement.obsolete] : []),
        ...(removed.some(key => LIBRARY_VIEW_SUMMARY_SOURCES.includes(key)) ? [LIBRARY_VIEW_SUMMARY_KEY] : []),
        ...(removed.includes('composerSessions') ? ['composerSessionSummaries', 'assistantChatViews', COMPOSER_DRAFTS_KEY] : []),
        ...(touchesCaseLibrary(removed) ? [CASE_LIBRARY_REVISION_KEY] : [])
      ])]);
    }),
    // Read/modify/write is serialized with every set/remove using this backend.
    // The transform must not call a nested write on this same interface.
    update: (keys, transform) => lock(async () => {
      await assertWritable(backend);
      const update = await transform(await read(keys));
      if (!update || typeof update !== "object" || Array.isArray(update)) throw new Error("资料更新内容无效。");
      await writeWithSummary(update);
    }),
    subscribe: listener => {
      if (!changes) throw new Error("资料变化通知不可用。");
      const handler = (values, area) => {
        if (area !== 'local') return;
        values = Object.fromEntries(Object.entries(values).filter(([key]) => !isBrowseKey(key)));
        // Staged records and auxiliary deletions do not change the indexed library. Every actual
        // case commit includes the revision; only those records may update a page's visible list.
        if (!Object.hasOwn(values, CASE_LIBRARY_REVISION_KEY)) values = Object.fromEntries(Object.entries(values)
          .filter(([key]) => !isCaseRecordKey(key)));
        if (Object.keys(values).length) listener(translateCaseChanges(values));
      };
      changes.addListener(handler);
      return () => changes.removeListener(handler);
    }
  });
}

let boundStorage;
// Lazy construction keeps imported domain helpers usable outside Chrome. The
// Chrome object is captured once, not looked up again after an async request.
export function getLibraryStorage() {
  boundStorage ??= createLibraryStorage({
    backend: chrome.storage.local,
    changes: chrome.storage.onChanged,
    lock: operation => navigator.locks.request("promptdirector-library-metadata-write", operation),
    assertWritable: assertLibraryWritable
  });
  return boundStorage;
}

export function createLibraryCommitter({ storage, syncedKeys, syncMetaKey, markDirty, isSyncApplying }) {
  const commit = async (update, options = {}) => {
    const done = startPhase("background", "write");
    try {
      return await commitLibraryUpdate(update, options);
    } finally {
      done({ bytes: () => jsonBytes(update) });
    }
  };
  for (const method of ['updateCase', 'updateCases']) commit[method] = async (entryId, transform, options = {}) => {
    const done = startPhase('background', 'writeCase');
    const sync = !isSyncApplying() && options.markSyncDirty !== false && syncedKeys.has(ENTRIES_KEY);
    try {
      return await storage[method](entryId, transform, sync ? {
        keys: [syncMetaKey], metadata: stored => ({ [syncMetaKey]: markDirty(stored[syncMetaKey], options.dirtyAssetIds) })
      } : {});
    } finally { done(); }
  };
  return commit;
  async function commitLibraryUpdate(update, options) {
    const payload = { ...update };
    const affectsSync = Object.keys(payload).some(key => syncedKeys.has(key));
    const sync = !isSyncApplying() && options.markSyncDirty !== false && affectsSync;
    if (!sync && !options.guard) return storage.set(payload);
    return storage.update([...new Set([...(sync ? [syncMetaKey] : []), ...(options.guard?.keys ?? [])])], stored => {
      options.guard?.check(stored);
      return { ...payload, ...(sync ? { [syncMetaKey]: markDirty(stored[syncMetaKey], options.dirtyAssetIds) } : {}) };
    });
  }
}