Files
crawler-plugin/frontend-vue/src/shared/utils/api-secret-store.ts
T
huangzd1997 e265c188f7 fix(appearance-patent): 代理缺失回填与任务前置提示
- 本地代理回填兼容旧版全局 proxy_url,补报成功后重拉服务端快照
- 创建任务前检查服务端代理,缺失时弹窗拦截并引导配置
- 商标查询失败的真实原因写入结果原因列,不再只显示查询失败
2026-10-25 21:28:26 +08:00

636 lines
24 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* 用户密钥前端存取:服务端为准 + 本地缓存。
*
* - 服务端(/api/user-secrets)是唯一权威:按登录用户绑定,客户端只缓存元数据与最近输入的值;
* - `getStoredApiSecret` / `getStoredApiSecretSnapshot` 保持同步读语义(提交任务瞬间立即取用),
* 读取顺序:内存 → 本地镜像 → 旧版 v1 记录(`brand:api-secret:{uid}:{moduleKey}`);
* - 本地镜像(localStorage)在浏览器形态只存脱敏值与状态位,明文只活在本页内存;
* 桌面形态(有 window.pywebview.api 原生存储)维持原有整条镜像,不动既有流程;
* - 保存/清空/检测走异步接口;服务端拉取失败一律软失败(返回 unknown,不阻断使用);
* - 旧版本地密钥在首次加载时自动迁移到服务端(只填空缺、不覆盖)。
*/
import {
checkMyApiSecret,
deleteMyApiSecret,
fetchMyApiSecrets,
fetchProxyBalance,
migrateMyApiSecrets,
putMyApiSecret,
type ApiSecretCheckStatus,
type ApiSecretModuleKey,
type UserApiSecretCheckResult,
type UserApiSecretItem,
} from '../api/types/modules/user-secret.ts'
export type { ApiSecretModuleKey, ApiSecretCheckStatus }
export type { UserApiSecretCheckResult }
/** 门禁状态:complete=可放行 / incomplete=需拦截引导配置 / unknown=未知(软失败,放行)。 */
export type ApiSecretLoadState = 'complete' | 'incomplete' | 'unknown'
export interface ApiSecretSnapshot {
/**
* 本地明文(来自用户输入或旧记录迁移),只存内存 Map;
* 浏览器形态的磁盘镜像不含此字段,服务端不回传明文,换机/刷新后可能为空。
*/
value: string
/** 服务端脱敏值(权威展示,如 sk-a****1234)。 */
masked: string
exists: boolean
/** 是否由后台代填并锁定:锁定时客户端不可修改或清空(当前仅代理模块)。 */
locked: boolean
checkStatus: ApiSecretCheckStatus
checkCode: string
checkMessage: string
checkLatencyMs: number | null
checkedAt: number | null
updatedAt: number | null
}
/** 代理状态:由服务端单独下发(不在 items 内、不参与门禁);锁定时带完整地址。 */
export interface ServerProxySnapshot extends ApiSecretSnapshot {
/** 后台锁定的完整代理地址(未锁定时为空串)。 */
full: string
}
/** 商标检测前置代理检查结果:unknown 表示服务端读不到,按软失败放行(与密钥门禁同口径)。 */
export interface BrandCheckProxyStatus {
ok: boolean
state: 'server' | 'missing' | 'unknown'
}
interface ApiSecretCacheEntry extends ApiSecretSnapshot {
schema: 2
}
const MIRROR_PREFIX = 'brand:api-secret-cache'
const LEGACY_PREFIX = 'brand:api-secret'
const LEGACY_MODULE_KEYS = ['appearance-patent', 'appearance-patent-token', 'similar-asin']
const MIGRATED_FLAG_PREFIX = 'brand:api-secret-migrated'
const DEFAULT_REQUIRED_MODULES: ApiSecretModuleKey[] = ['appearance-patent', 'similar-asin']
const FETCH_TIMEOUT_MS = 4000
const memory = new Map<string, ApiSecretCacheEntry>()
const listeners = new Set<() => void>()
export interface ApiSecretModuleInfo {
moduleKey: string
moduleLabel: string
}
const DEFAULT_MODULE_INFOS: ApiSecretModuleInfo[] = [
{ moduleKey: 'appearance-patent', moduleLabel: '外观专利密钥' },
{ moduleKey: 'similar-asin', moduleLabel: '货源查询密钥' },
]
let moduleInfos: ApiSecretModuleInfo[] = [...DEFAULT_MODULE_INFOS]
let requiredModules: string[] = [...DEFAULT_REQUIRED_MODULES]
let bundleLoaded = false
let inflightLoad: Promise<ApiSecretLoadState> | null = null
/** 服务端代理状态(后台锁定/检测展示用);未成功加载过为 null。 */
let serverProxy: ServerProxySnapshot | null = null
function currentUid(): string {
if (typeof window === 'undefined') return '0'
return window.localStorage.getItem('uid') || '0'
}
function buildMirrorKey(moduleKey: string) {
return `${MIRROR_PREFIX}:${currentUid()}:${moduleKey}`
}
function buildLegacyKey(moduleKey: string) {
return `${LEGACY_PREFIX}:${currentUid()}:${moduleKey}`
}
/**
* 形态判定:桌面客户端(pywebview)会注入 window.pywebview.api 并提供原生 app.json 存储,
* 其本地明文缓存是既有任务链路依赖(重启后仍能取用);纯浏览器形态没有原生存储,
* localStorage 是同页脚本可直接读到的明文落点,必须收紧。
*
* 这里刻意用内联的 window 断言而不是 import hasPywebview():静态引入 bridges/pywebview
* 会把 web-fallback → http 拉进 node 测试环境(本模块被单测直接 import)。
*/
function isNativeDesktopStorage(): boolean {
if (typeof window === 'undefined') return false
return Boolean((window as unknown as { pywebview?: { api?: unknown } }).pywebview?.api)
}
function emptyEntry(): ApiSecretCacheEntry {
return {
schema: 2,
value: '',
masked: '',
exists: false,
locked: false,
checkStatus: 'unknown',
checkCode: '',
checkMessage: '',
checkLatencyMs: null,
checkedAt: null,
updatedAt: null,
}
}
function normalizeCheckStatus(value: unknown): ApiSecretCheckStatus {
switch (value) {
case 'passed':
case 'failed':
case 'error':
case 'unknown':
return value
default:
return 'unknown'
}
}
function readMirror(moduleKey: string): ApiSecretCacheEntry | null {
if (typeof window === 'undefined') return null
try {
const raw = window.localStorage.getItem(buildMirrorKey(moduleKey))
if (!raw) return null
const parsed = JSON.parse(raw) as Partial<ApiSecretCacheEntry>
if (parsed.schema !== 2) return null
const entry: ApiSecretCacheEntry = {
schema: 2,
value: typeof parsed.value === 'string' ? parsed.value : '',
masked: typeof parsed.masked === 'string' ? parsed.masked : '',
exists: Boolean(parsed.exists),
locked: Boolean(parsed.locked),
checkStatus: normalizeCheckStatus(parsed.checkStatus),
checkCode: typeof parsed.checkCode === 'string' ? parsed.checkCode : '',
checkMessage: typeof parsed.checkMessage === 'string' ? parsed.checkMessage : '',
checkLatencyMs: typeof parsed.checkLatencyMs === 'number' ? parsed.checkLatencyMs : null,
checkedAt: typeof parsed.checkedAt === 'number' ? parsed.checkedAt : null,
updatedAt: typeof parsed.updatedAt === 'number' ? parsed.updatedAt : null,
}
// 浏览器形态:历史版本可能已把明文写进磁盘,读到就顺手抹掉(明文只留内存)
if (entry.value && !isNativeDesktopStorage()) {
entry.value = ''
writeMirror(moduleKey, entry)
}
return entry
} catch {
return null
}
}
/** 磁盘镜像写入:浏览器形态只写脱敏值与状态位,明文不落地;桌面形态维持既有整条镜像。 */
function writeMirror(moduleKey: string, entry: ApiSecretCacheEntry) {
if (typeof window === 'undefined') return
const persisted: ApiSecretCacheEntry = isNativeDesktopStorage() ? entry : { ...entry, value: '' }
try {
window.localStorage.setItem(buildMirrorKey(moduleKey), JSON.stringify(persisted))
} catch {
/* 本地镜像写入失败不影响主流程 */
}
}
function removeMirror(moduleKey: string) {
if (typeof window === 'undefined') return
try {
window.localStorage.removeItem(buildMirrorKey(moduleKey))
} catch {
/* 忽略 */
}
}
/** 读取旧版 v1 明文(sessionStorage 优先,兼容历史 session 保留策略)。 */
function readLegacyPlainValue(moduleKey: string): string {
if (typeof window === 'undefined') return ''
for (const storage of [window.sessionStorage, window.localStorage]) {
try {
const raw = storage.getItem(buildLegacyKey(moduleKey))
if (!raw) continue
const parsed = JSON.parse(raw) as { value?: unknown }
if (typeof parsed?.value === 'string' && parsed.value.trim()) {
return parsed.value.trim()
}
} catch {
/* 忽略损坏的历史记录 */
}
}
return ''
}
function clearLegacyKeys() {
if (typeof window === 'undefined') return
for (const moduleKey of [...LEGACY_MODULE_KEYS, 'common']) {
for (const storage of [window.sessionStorage, window.localStorage]) {
try {
storage.removeItem(buildLegacyKey(moduleKey))
} catch {
/* 忽略 */
}
}
}
}
function migratedFlagKey() {
return `${MIGRATED_FLAG_PREFIX}:${currentUid()}:v1`
}
function readEntry(moduleKey: string): ApiSecretCacheEntry {
const cached = memory.get(moduleKey)
if (cached) return cached
const fromMirror = readMirror(moduleKey)
if (fromMirror) {
memory.set(moduleKey, fromMirror)
return fromMirror
}
const legacyValue = readLegacyPlainValue(moduleKey)
if (legacyValue) {
const entry = emptyEntry()
entry.value = legacyValue
memory.set(moduleKey, entry)
return entry
}
return emptyEntry()
}
function updateEntry(moduleKey: string, patch: Partial<ApiSecretCacheEntry>) {
const next: ApiSecretCacheEntry = { ...readEntry(moduleKey), ...patch, schema: 2 }
memory.set(moduleKey, next)
writeMirror(moduleKey, next)
notify()
}
function notify() {
for (const listener of listeners) {
try {
listener()
} catch {
/* 单个监听器异常不影响其他订阅者 */
}
}
}
function toMillis(value: string | null): number | null {
if (!value) return null
const parsed = Date.parse(value)
return Number.isNaN(parsed) ? null : parsed
}
function applyServerItem(moduleKey: string, item: UserApiSecretItem) {
const current = readEntry(moduleKey)
const next: ApiSecretCacheEntry = {
schema: 2,
// 明文仅来自本地输入/迁移,服务端不下发
value: current.value,
masked: item.masked || '',
exists: Boolean(item.exists),
locked: Boolean(item.locked),
checkStatus: normalizeCheckStatus(item.checkStatus),
checkCode: item.checkCode || '',
checkMessage: item.checkMessage || '',
checkLatencyMs: typeof item.checkLatencyMs === 'number' ? item.checkLatencyMs : null,
checkedAt: toMillis(item.checkedAt),
updatedAt: toMillis(item.updatedAt),
}
memory.set(moduleKey, next)
writeMirror(moduleKey, next)
if (item.moduleLabel && !moduleInfos.some((info) => info.moduleKey === moduleKey)) {
moduleInfos = [...moduleInfos, { moduleKey, moduleLabel: item.moduleLabel }]
}
}
/** 界面展示用的模块清单(默认两个,服务端返回新模块时自动追加)。 */
export function listApiSecretModules(): ApiSecretModuleInfo[] {
return [...moduleInfos]
}
/** 完整性:全部必填模块均检测通过;error(无法判定)视为放行,防上游抖动锁死客户端。 */
export function computeApiSecretsComplete(): boolean {
for (const moduleKey of requiredModules) {
const entry = memory.get(moduleKey) || readEntry(moduleKey)
if (!entry.exists) return false
if (entry.checkStatus !== 'passed' && entry.checkStatus !== 'error') return false
}
return requiredModules.length > 0
}
/** 门禁状态:从未成功拉到服务端数据 → unknown(软失败放行)。 */
export function getApiSecretGateState(): ApiSecretLoadState {
if (!bundleLoaded) return 'unknown'
return computeApiSecretsComplete() ? 'complete' : 'incomplete'
}
/** 同步读明文(提交任务瞬间调用);未加载时降级读本地镜像/旧记录。 */
export function getStoredApiSecret(moduleKey: ApiSecretModuleKey): string {
return readEntry(moduleKey).value
}
/** 同步读完整快照(含服务端脱敏值/检测状态)。 */
export function getStoredApiSecretSnapshot(moduleKey: ApiSecretModuleKey): ApiSecretSnapshot {
const entry = readEntry(moduleKey)
const { schema: _schema, ...snapshot } = entry
return snapshot
}
/** 同步读服务端代理状态(含后台锁定标记与锁定时的完整地址)。 */
export function getServerProxySnapshot(): ServerProxySnapshot | null {
return serverProxy
}
/**
* 创建商标检测任务前的代理检查:服务端没有代理时先尝试把本地代理补报上去,
* 仍没有就返回 missing 交给页面弹窗拦截。服务端读不到(unknown)不拦——
* 那种情况下任务创建本身会报错,不能把网络抖动误判成"未配置代理"。
*/
export async function ensureBrandCheckProxy(): Promise<BrandCheckProxyStatus> {
const state = await loadApiSecrets({ force: true })
if (getServerProxySnapshot()?.exists) {
return { ok: true, state: 'server' }
}
if (state === 'unknown') {
return { ok: true, state: 'unknown' }
}
return { ok: false, state: 'missing' }
}
export function subscribeApiSecrets(listener: () => void): () => void {
listeners.add(listener)
return () => {
listeners.delete(listener)
}
}
/** 加载服务端密钥包;force=true 绕过 in-flight 复用但串行等待(登录后重拉用)。 */
export function loadApiSecrets(options: { force?: boolean } = {}): Promise<ApiSecretLoadState> {
if (inflightLoad && !options.force) {
return inflightLoad
}
const previous = inflightLoad
const task = (async (): Promise<ApiSecretLoadState> => {
if (previous && options.force) {
// 等上一轮结束,避免并发覆盖
await previous.catch(() => undefined)
}
return doLoad()
})().finally(() => {
if (inflightLoad === task) {
inflightLoad = null
}
})
inflightLoad = task
return task
}
/** 复用同一次 in-flight 加载(路由守卫调用)。 */
export function ensureApiSecretsLoaded(): Promise<ApiSecretLoadState> {
if (bundleLoaded || inflightLoad) {
return inflightLoad || Promise.resolve(getApiSecretGateState())
}
return loadApiSecrets()
}
async function doLoad(): Promise<ApiSecretLoadState> {
try {
const bundle = await fetchMyApiSecrets()
if (Array.isArray(bundle?.requiredModules) && bundle.requiredModules.length) {
requiredModules = bundle.requiredModules
}
for (const item of bundle?.items || []) {
if (item?.moduleKey) {
applyServerItem(item.moduleKey, item)
}
}
serverProxy = toServerProxy(bundle?.proxy)
if (serverProxy?.locked && serverProxy.full) {
// 后台锁定代理:把后台值对齐到本地配置(客户端任务链读本地),先比对、幂等、失败静默
await syncLockedProxyToLocal(serverProxy.full)
}
bundleLoaded = true
notify()
const migrated = await tryMigrateLocalSecrets(bundle?.items || [])
if (migrated > 0) {
const refreshed = await fetchMyApiSecrets()
for (const item of refreshed?.items || []) {
if (item?.moduleKey) {
applyServerItem(item.moduleKey, item)
}
}
notify()
}
const backfilled = await tryBackfillProxyToServer()
if (backfilled) {
// 补报已写入服务端:重拉一次让 serverProxy 反映新状态,
// 否则任务提交前的代理检查会拿到上一轮的空快照。
const refreshed = await fetchMyApiSecrets()
serverProxy = toServerProxy(refreshed?.proxy)
notify()
}
return computeApiSecretsComplete() ? 'complete' : 'incomplete'
} catch (error) {
console.warn('[api-secret] 服务端密钥拉取失败,本次按未知处理(不阻断使用):', error)
return 'unknown'
}
}
/** 旧本地密钥一次性迁移:仅当服务端空缺且有本地明文时上报;失败静默,下次加载重试。 */
async function tryMigrateLocalSecrets(serverItems: UserApiSecretItem[]): Promise<number> {
if (typeof window === 'undefined') return 0
try {
if (window.localStorage.getItem(migratedFlagKey()) === '1') {
clearLegacyKeys()
return 0
}
const serverHas = new Map(serverItems.map((item) => [item.moduleKey, Boolean(item.exists)]))
const pending: Array<{ moduleKey: string; value: string }> = []
for (const moduleKey of DEFAULT_REQUIRED_MODULES) {
if (serverHas.get(moduleKey)) continue
const legacyValue = readLegacyPlainValue(moduleKey)
if (legacyValue) {
pending.push({ moduleKey, value: legacyValue })
}
}
if (!pending.length) {
window.localStorage.setItem(migratedFlagKey(), '1')
clearLegacyKeys()
return 0
}
const result = await migrateMyApiSecrets(pending)
const migrated = Number(result?.migrated || 0)
// 迁移成功后本地保留明文(供提交任务直接使用),只清理旧记录与标记
for (const item of pending) {
const entry = readEntry(item.moduleKey)
updateEntry(item.moduleKey, { value: entry.value || item.value })
}
window.localStorage.setItem(migratedFlagKey(), '1')
clearLegacyKeys()
console.log(`[api-secret] 本地密钥迁移完成,写入 ${migrated} 条`)
return migrated
} catch (error) {
console.warn('[api-secret] 本地密钥迁移失败,将在下次加载时重试:', error)
return 0
}
}
/**
* 本地代理配置补报服务端(只写空缺、不覆盖;后台密钥管理观测/检测用)。
* 未登录、无本地代理时静默跳过;失败静默,下次加载重试。
*
* @returns 是否真的补报了一条(migrated > 0);调用方据此决定要不要重拉服务端快照。
*/
async function tryBackfillProxyToServer(): Promise<boolean> {
try {
if (currentUid() === '0') return false
const config = await readConfigForBackfill()
if (!config) return false
const url = readLocalProxyUrl(config)
if (!url) return false
const result = await migrateMyApiSecrets([{ moduleKey: 'proxy', value: url }])
return Number(result?.migrated || 0) > 0
} catch (error) {
console.warn('[api-secret] 代理配置补报失败(下次加载重试):', error)
return false
}
}
/**
* 读代理补报所需的本地配置:桌面真实桥优先(与 syncLockedProxyToLocal 同口径),
* 纯浏览器再走降级桥。静态 import 会把 web-fallback 的 @ 别名依赖拖进 node 用例,
* 所以降级那条只在需要时才动态加载。
*/
async function readConfigForBackfill(): Promise<Record<string, unknown> | null> {
if (typeof window === 'undefined') return null
const direct = window.pywebview?.api
if (direct?.read_config) {
return (await direct.read_config()) as Record<string, unknown> | null
}
// 无 DOM 的 node 用例不是浏览器环境:降级桥模块带着 @ 别名依赖,加载只会留下噪声报错
if (typeof document === 'undefined') return null
const { getPywebviewApi } = await import('../bridges/pywebview.ts')
const api = getPywebviewApi()
if (!api?.read_config) return null
return (await api.read_config()) as Record<string, unknown> | null
}
/**
* 读取当前登录用户的本地代理地址:proxy_users[uid] 优先,用户项为空时回退全局 proxy_url。
* 回退口径与客户端任务链 `resolve_current_proxy` 一致——老版本把代理存在全局 proxy_url,
* 若这里只认 proxy_users[uid],这些账号的代理永远补报不到服务端,外观专利任务会在
* 商标维度整批判失败(2026-10-25 账号 1210 的 32300/32309 就是这么来的)。
*/
function readLocalProxyUrl(config: Record<string, unknown> | null | undefined): string {
if (!config) return ''
const uid = currentUid()
if (uid !== '0') {
const users = (config.proxy_users ?? {}) as Record<string, unknown>
const own = (users[uid] ?? {}) as Record<string, unknown>
const ownUrl = typeof own.proxy_url === 'string' ? own.proxy_url.trim() : ''
if (ownUrl) return ownUrl
}
return typeof config.proxy_url === 'string' ? config.proxy_url.trim() : ''
}
function toServerProxy(proxy: UserApiSecretItem | null | undefined): ServerProxySnapshot | null {
if (!proxy) return null
return {
value: '',
masked: proxy.masked || '',
exists: Boolean(proxy.exists),
locked: Boolean(proxy.locked),
full: typeof proxy.full === 'string' ? proxy.full.trim() : '',
checkStatus: normalizeCheckStatus(proxy.checkStatus),
checkCode: proxy.checkCode || '',
checkMessage: proxy.checkMessage || '',
checkLatencyMs: typeof proxy.checkLatencyMs === 'number' ? proxy.checkLatencyMs : null,
checkedAt: toMillis(proxy.checkedAt),
updatedAt: toMillis(proxy.updatedAt),
}
}
/**
* 后台代填并锁定的代理:把完整地址写入本地 app.json(proxy_users[uid],未登录回退全局),
* 让客户端各任务链与后台值保持一致。先读后比对、幂等;失败静默,下次加载重试。
* 只走桌面端真实桥(window.pywebview):Web 降级桥的配置与桌面 app.json 无关。
*/
async function syncLockedProxyToLocal(full: string): Promise<void> {
try {
if (typeof window === 'undefined') return
const api = window.pywebview?.api
if (!api?.read_config || !api?.save_config) return
const config = (await api.read_config()) as Record<string, unknown> | null
if (readLocalProxyUrl(config) === full) return
const uid = currentUid()
if (uid === '0') {
const mode = Number(config?.proxy_mode) === 2 ? 2 : 1
await api.save_config({ proxy_url: full, proxy_mode: mode })
return
}
const users = (config?.proxy_users ?? {}) as Record<string, unknown>
const own = (users[uid] ?? {}) as Record<string, unknown>
// save_config 对 proxy_users 只做 uid 级合并(保留其他用户),故同一对象内要带齐原有模式
const mode = Number(own.proxy_mode) === 2 ? 2 : 1
await api.save_config({ proxy_users: { [uid]: { proxy_url: full, proxy_mode: mode } } })
} catch (error) {
console.warn('[api-secret] 锁定代理写入本地配置失败(下次加载重试):', error)
}
}
/** 保存密钥到服务端;成功后刷新本地缓存(失败不写本地,避免本地有值服务端没有的假象)。 */
export async function saveApiSecret(moduleKey: ApiSecretModuleKey, value: string): Promise<ApiSecretSnapshot> {
const trimmed = value.trim()
if (!trimmed) {
throw new Error('密钥不能为空')
}
const item = await putMyApiSecret(moduleKey, trimmed)
applyServerItem(moduleKey, item)
updateEntry(moduleKey, { value: trimmed, exists: true })
bundleLoaded = true
return getStoredApiSecretSnapshot(moduleKey)
}
export async function clearApiSecret(moduleKey: ApiSecretModuleKey): Promise<void> {
await deleteMyApiSecret(moduleKey)
removeMirror(moduleKey)
memory.delete(moduleKey)
notify()
}
/** 检测连通性:value 非空时只检测输入值(不落库);为空时检测服务端已存值并刷新本地状态。 */
export async function checkApiSecret(
moduleKey: ApiSecretModuleKey,
value?: string,
): Promise<UserApiSecretCheckResult> {
const override = value?.trim()
const result = await checkMyApiSecret(moduleKey, override || undefined)
if (!override) {
updateEntry(moduleKey, {
checkStatus: normalizeCheckStatus(result.checkStatus),
checkCode: result.checkCode || '',
checkMessage: result.checkMessage || '',
checkLatencyMs: typeof result.checkLatencyMs === 'number' ? result.checkLatencyMs : null,
checkedAt: toMillis(result.checkedAt) ?? Date.now(),
})
}
return result
}
/** 服务端余量查询(jikip 套餐 IP 余量 / 账户余额)。 */
export async function fetchProxyBalanceSafely() {
return fetchProxyBalance()
}
/** 登出清理:内存与镜像一并清空(旧 v1 记录保留,供下次登录迁移)。 */
export function clearApiSecretCache(): void {
for (const moduleKey of [...DEFAULT_REQUIRED_MODULES]) {
removeMirror(moduleKey)
}
memory.clear()
bundleLoaded = false
inflightLoad = null
serverProxy = null
}
/** 供测试与调试:模块级状态快照。 */
export function __debugApiSecretState() {
return {
requiredModules: [...requiredModules],
bundleLoaded,
entries: Object.fromEntries(memory.entries()),
}
}