evomeme 0.1.9 → 0.1.10-beta.13

package/dist/canvas-public/core/api.js

@@ -0,0 +1,32 @@
+import { t, errorText } from '../language/index.js'
+export async function api(path, options) {
+  const headers = new Headers(options?.headers)
+  if (options?.method === 'POST') headers.set('Prefer', 'respond-async')
+  const res = await fetch(path, { ...options, headers })
+  const data = await res.json().catch(() => ({}))
+  if (!res.ok) {
+    const detail = data.detail
+    const message = Array.isArray(detail)
+      ? detail.map((d) => d.msg || JSON.stringify(d)).join('; ')
+      : detail || data.message || res.statusText || t("core.api.text001")
+    const error = new Error(errorText(data.error?.message || message))
+    error.errorInfo = data.error
+    error.status = res.status
+    error.data = data
+    throw error
+  }
+  if (res.status === 202 && data.task_id) {
+    for (;;) {
+      const task = await api(`/api/tasks/${encodeURIComponent(data.task_id)}`)
+      if (task.status === 'SUCCEEDED') return task.result || {}
+      if (['FAILED', 'NEEDS_ATTENTION'].includes(task.status)) {
+        const error = new Error(errorText(task.errorInfo?.message || task.error || t("core.api.text002")))
+        error.errorInfo = task.errorInfo
+        throw error
+      }
+      // INTERRUPTED is recoverable; the scheduler continues polling the saved backend job.
+      await new Promise(resolve => setTimeout(resolve, 750))
+    }
+  }
+  return data
+}

package/dist/canvas-public/core/feature-registry.js

@@ -0,0 +1,29 @@
+// This module knows contracts, never concrete business features.
+const definitions = new Map()
+const types = new Map()
+
+export function registerFeature(definition) {
+  if (!definition?.id) throw new Error('Feature id is required')
+  if (definitions.has(definition.id)) throw new Error(`Duplicate feature: ${definition.id}`)
+  definitions.set(definition.id, definition)
+  for (const alias of Object.keys(definition.aliases || {})) definitions.set(alias, definition)
+  if (definition.node?.type && definition.node.type !== 'feature_dialog') {
+    if (types.has(definition.node.type)) throw new Error(`Duplicate node type: ${definition.node.type}`)
+    types.set(definition.node.type, definition)
+  }
+  return definition
+}
+
+export function getFeature(value) {
+  if (typeof value === 'string') return definitions.get(value) || types.get(value) || null
+  return (value?.type === 'feature_dialog' ? definitions.get(value.featureId) : types.get(value?.type)) || null
+}
+
+export function listFeatures() { return [...new Set(definitions.values())] }
+
+export function visitFields(sections, visit, ancestors = []) {
+  for (const field of sections || []) {
+    if (field.path) visit(field, ancestors)
+    if (field.fields) visitFields(field.fields, visit, [...ancestors, field])
+  }
+}

package/dist/canvas-public/core/feature-state.js

@@ -0,0 +1,228 @@
+import { state } from './state.js'
+import { getFeature, visitFields } from './feature-registry.js'
+
+const listeners = new Map()
+const buckets = Object.create(null)
+const entries = new Map()
+const inlineInitialized = new WeakSet()
+const clone = (value) => value === undefined ? undefined : structuredClone(value)
+const safePath = (path) => String(path).split('.').filter((key) => {
+  if (['__proto__', 'prototype', 'constructor'].includes(key)) throw new Error('Invalid field path')
+  return true
+})
+
+export function getField(object, path) {
+  return safePath(path).reduce((value, key) => value?.[key], object)
+}
+
+export function setField(object, path, value) {
+  const keys = safePath(path)
+  const key = keys.pop()
+  const target = keys.reduce((parent, part) => (parent[part] ??= {}), object)
+  target[key] = value
+}
+
+export function featureDefaults(definition) {
+  const result = {}
+  visitFields(definition.fields, (field) => {
+    if ('default' in field) setField(result, field.path, clone(typeof field.default === 'function' ? field.default() : field.default))
+  })
+  return result
+}
+
+function stateBucket(definition) {
+  return buckets[definition.id] ??= {}
+}
+
+function decodeField(field, raw, fallback) {
+  if (raw === undefined || raw === null && fallback !== null) return clone(fallback)
+  if (field.decode) return field.decode(clone(raw))
+  if (field.reference) {
+    if (Array.isArray(fallback)) return Array.isArray(raw) ? raw.filter((ref) => ref?.id).map(clone) : []
+    return raw?.id ? clone(raw) : null
+  }
+  if (field.type === 'boolean') return typeof raw === 'boolean' ? raw : clone(fallback)
+  if (field.type === 'color') return /^#[0-9a-f]{6}$/i.test(raw) ? raw.toLowerCase() : clone(fallback)
+  if (['text', 'textarea'].includes(field.type)) return String(raw ?? '')
+  return clone(raw)
+}
+
+export function ensureFeatureState(itemOrId, definition = null) {
+  const item = typeof itemOrId === 'string'
+    ? state.layoutItems.find((candidate) => candidate.id === itemOrId) || { id: itemOrId, type: definition?.node?.type }
+    : itemOrId
+  definition ||= getFeature(item)
+  if (!item?.id || !definition) throw new Error('Unknown feature state')
+  entries.set(item.id, { item, definition })
+  if (definition.inline) {
+    const target = state.layoutItems.find((entry) => entry.id === item.id) || item
+    if (!inlineInitialized.has(target)) {
+      const defaults = featureDefaults(definition)
+      visitFields(definition.fields, (field) => {
+        if (getField(target, field.path) === undefined) setField(target, field.path, getField(defaults, field.path))
+      })
+      target.busy = false
+      target.messages = []
+      inlineInitialized.add(target)
+    }
+    return target
+  }
+  const bucket = stateBucket(definition)
+  if (!bucket[item.id]) {
+    const saved = definition.storage ? item[definition.storage] : item
+    const data = definition.migrate ? definition.migrate(clone(saved || {}), item) : saved || {}
+    const params = featureDefaults(definition)
+    visitFields(definition.fields, (field) => {
+      const value = getField(data, field.storagePath || field.path)
+      setField(params, field.path, decodeField(field, value, getField(params, field.path)))
+    })
+    bucket[item.id] = { ...params, ...definition.runtimeDefaults?.(), busy: false, messages: [] }
+  }
+  const result = bucket[item.id]
+  if (item.error && result.persistedError !== item.error) {
+    result.messages.push({ role: 'assistant', error: String(item.error) })
+    result.persistedError = item.error
+  }
+  return result
+}
+
+// Only accepted external snapshots hydrate existing state; ordinary reads never replace nested objects.
+export function restoreFeatureState(item) {
+  const definition = getFeature(item)
+  if (!definition) return
+  const params = ensureFeatureState(item, definition)
+  const saved = definition.inline ? item : item[definition.storage] || {}
+  const data = definition.migrate ? definition.migrate(clone(saved), item) : saved
+  const defaults = featureDefaults(definition)
+  const mergeValue = (current, next) => {
+    if (current && next && Object.getPrototypeOf(current) === Object.prototype && Object.getPrototypeOf(next) === Object.prototype) {
+      for (const key of Object.keys(current)) if (!(key in next)) delete current[key]
+      for (const [key, value] of Object.entries(next)) current[key] = mergeValue(current[key], value)
+      return current
+    }
+    return clone(next)
+  }
+  visitFields(definition.fields, (field) => {
+    const raw = getField(data, field.storagePath || field.path)
+    const next = decodeField(field, raw, getField(defaults, field.path))
+    setField(params, field.path, mergeValue(getField(params, field.path), next))
+  })
+  notifyFeatureState(item.id)
+}
+
+export function notifyFeatureState(id) {
+  for (const update of [...(listeners.get(id) || [])]) update()
+}
+
+export function markFeatureIdle(item, error = '') {
+  if (!getFeature(item)) return
+  const params = ensureFeatureState(item)
+  params.busy = false
+  const detail = String(error || '').trim()
+  if (detail && params.messages.at(-1)?.error !== detail) params.messages.push({ role: 'assistant', error: detail })
+  notifyFeatureState(item.id)
+}
+
+export function updateFeatureField(item, path, value, definition = getFeature(item)) {
+  const params = ensureFeatureState(item, definition)
+  setField(params, path, value)
+  definition.changed?.(params, path)
+  notifyFeatureState(item.id)
+  return params
+}
+
+export function subscribeFeatureState(id, update) {
+  if (!listeners.has(id)) listeners.set(id, new Set())
+  listeners.get(id).add(update)
+  return () => {
+    listeners.get(id)?.delete(update)
+    if (!listeners.get(id)?.size) listeners.delete(id)
+  }
+}
+
+export function serializeFeatureState(item, definition = getFeature(item)) {
+  const params = ensureFeatureState(item, definition)
+  // Preserve unknown historical parameters, never serialize runtime caches.
+  const saved = definition.storage ? clone(item[definition.storage] || {}) : {}
+  visitFields(definition.fields, (field) => {
+    if (field.persist === false) return
+    const value = getField(params, field.path)
+    if (value !== undefined) setField(saved, field.storagePath || field.path, field.encode ? field.encode(value) : clone(value))
+  })
+  return saved
+}
+
+export function discardFeatureState(item) {
+  const definition = getFeature(item)
+  if (definition) delete stateBucket(definition)[item.id]
+  listeners.delete(item.id)
+  entries.delete(item.id)
+}
+
+export function peekFeatureState(id) {
+  const entry = entries.get(id)
+  if (!entry) return null
+  return entry.definition.inline ? state.layoutItems.find((item) => item.id === id) || entry.item : stateBucket(entry.definition)[id]
+}
+
+export function featureStateEntries() { return [...entries.values()] }
+
+export function resetFeatureStates() {
+  for (const key of Object.keys(buckets)) delete buckets[key]
+  listeners.clear()
+  entries.clear()
+}
+
+export function removeFeatureReferences(item, removedIds) {
+  const definition = getFeature(item)
+  if (!definition) return false
+  const params = ensureFeatureState(item)
+  let changed = false
+  visitFields(definition.fields, (field) => {
+    if (!field.reference) return
+    const value = getField(params, field.path)
+    if (Array.isArray(value)) {
+      const next = value.filter((ref) => !removedIds.has(ref?.id))
+      if (next.length !== value.length) { setField(params, field.path, next); changed = true }
+    } else if (removedIds.has(value?.id)) { setField(params, field.path, null); changed = true }
+  })
+  if (changed) notifyFeatureState(item.id)
+  return changed
+}
+
+export function featureDependencies(item) {
+  const definition = getFeature(item)
+  if (!definition) return []
+  if (definition.dependencies) return definition.dependencies(item, ensureFeatureState(item))
+  const params = ensureFeatureState(item)
+  const ids = []
+  visitFields(definition.fields, (field, parents) => {
+    if (!field.reference || !fieldActive(field, parents, params)) return
+    const value = getField(params, field.path)
+    for (const reference of Array.isArray(value) ? value : [value]) if (reference?.id) ids.push(reference.id)
+  })
+  return ids
+}
+
+export function fieldActive(field, parents, params) {
+  return [...parents, field].every((entry) =>
+    (!entry.visible || entry.visible(params)) && !(typeof entry.disabled === 'function' ? entry.disabled(params) : entry.disabled) &&
+    (!entry.enablePath || getField(params, entry.enablePath) === true))
+}
+
+export function validateFeature(definition, params) {
+  const errors = []
+  visitFields(definition.fields, (field, parents) => {
+    if (!fieldActive(field, parents, params)) return
+    const value = getField(params, field.path)
+    const required = typeof field.required === 'function' ? field.required(params) : field.required
+    const empty = value == null || (typeof value === 'string' && !value.trim()) || (Array.isArray(value) && !value.length)
+    if (required && (empty || field.reference && !Array.isArray(value) && !value?.id)) errors.push(field)
+    if (!empty && ['number', 'integer'].includes(field.type)) {
+      const number = Number(value)
+      if (!Number.isFinite(number) || (field.type === 'integer' && !Number.isInteger(number)) ||
+        (field.min != null && number < field.min) || (field.max != null && number > field.max)) errors.push(field)
+    }
+  })
+  return { fields: errors, message: definition.validate?.(params) || '' }
+}

package/dist/canvas-public/core/layout.js

@@ -0,0 +1,133 @@
+import { t, errorT } from '../language/index.js'
+import { api } from './api.js'
+import { state } from './state.js'
+
+export function createLayoutController({
+  attachCanvasIdentity,
+  onConflict,
+  serializeLayoutItem,
+  shouldDeferExternalSync,
+  syncExternalChanges,
+}) {
+  let saveQueue = Promise.resolve()
+  let saveSequence = 0
+  let saveEpoch = 0
+  let pendingSaveCount = 0
+  let nextExpectedRevision = 0
+  let submittedItems = []
+
+  function serializeCanvasItems(items) {
+    return JSON.parse(JSON.stringify(items.map((item) =>
+      attachCanvasIdentity(serializeLayoutItem(item), item),
+    )))
+  }
+
+  function canvasDataEqual(left, right) {
+    const canonical = (value) => JSON.stringify(value, (_key, item) =>
+      item && typeof item === 'object' && !Array.isArray(item)
+        ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]]))
+        : item,
+    )
+    return canonical(left) === canonical(right)
+  }
+
+  function canvasNodeContent(item) {
+    const { x, y, width, height, manualSize, ...content } = item
+    return content
+  }
+
+  function status() {
+    return {
+      epoch: saveEpoch,
+      pendingSaveCount,
+      sequence: saveSequence,
+    }
+  }
+
+  function setSubmittedItems(items) {
+    submittedItems = serializeCanvasItems(items)
+  }
+
+  function acceptRevision(value) {
+    const revision = Number(value)
+    if (!Number.isInteger(revision) || revision < 0) return false
+    state.layoutRevision = revision
+    if (pendingSaveCount === 0) nextExpectedRevision = revision
+    return true
+  }
+
+  function reset() {
+    submittedItems = []
+    nextExpectedRevision = 0
+    saveEpoch += 1
+  }
+
+  function saveLayout(items) {
+    const next = serializeCanvasItems(items || state.layoutItems)
+    const sequence = ++saveSequence
+    const baseItems = JSON.parse(JSON.stringify(submittedItems))
+    submittedItems = JSON.parse(JSON.stringify(next))
+    const epoch = saveEpoch
+    const expectedRevision = pendingSaveCount === 0
+      ? state.layoutRevision
+      : nextExpectedRevision
+    nextExpectedRevision = expectedRevision + 1
+    pendingSaveCount += 1
+    // The persistence payload is not the runtime view. Keep metadata and edits made
+    // while this request is in flight; a save acknowledgement must not roll them back.
+    const request = saveQueue.then(async () => {
+      try {
+        if (epoch !== saveEpoch) {
+          const staleError = new Error(errorT("core.layout.text001"))
+          staleError.status = 409
+          throw staleError
+        }
+        const saved = await api('/api/layout', {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ items: next, revision: expectedRevision, base_items: baseItems }),
+        })
+        if (epoch !== saveEpoch) return saved
+        state.layoutRevision = Math.max(Number(saved.revision) || 0, state.layoutRevision)
+        if (
+          sequence === saveSequence &&
+          Array.isArray(saved.items) &&
+          !canvasDataEqual(next, serializeCanvasItems(saved.items))
+        ) {
+          state.externalSyncPending = true
+        }
+        return saved
+      } catch (error) {
+        console.warn('save layout failed', error)
+        const firstFailureInEpoch = epoch === saveEpoch
+        if (firstFailureInEpoch) saveEpoch += 1
+        if (error?.status === 409 && firstFailureInEpoch) {
+          state.error = errorT("core.layout.text001")
+          await onConflict().catch(() => undefined)
+        }
+        throw error
+      } finally {
+        pendingSaveCount = Math.max(0, pendingSaveCount - 1)
+        if (pendingSaveCount === 0) {
+          nextExpectedRevision = state.layoutRevision
+          if (state.externalSyncPending && !shouldDeferExternalSync()) {
+            setTimeout(() => syncExternalChanges(), 0)
+          }
+        }
+      }
+    })
+    saveQueue = request.catch(() => undefined)
+    return request
+  }
+
+  return {
+    acceptRevision,
+    canvasDataEqual,
+    canvasNodeContent,
+    reset,
+    saveLayout,
+    serializeCanvasItems,
+    setSubmittedItems,
+    status,
+  }
+}

package/dist/canvas-public/core/operations.js

@@ -0,0 +1,38 @@
+import { state } from './state.js'
+
+export function createOperationManager({ shouldDeferExternalSync, syncExternalChanges }) {
+  function hasActiveOperations(kind) {
+    return kind
+      ? [...state.activeOperations].some((token) => token.startsWith(kind + '_'))
+      : state.activeOperations.size > 0
+  }
+
+  function createCanvasClientId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`
+  }
+
+  function beginActiveOperation(kind, options = {}) {
+    if (kind === 'interactive-edit-save') kind = 'interactive-edit'
+    const token = createCanvasClientId(kind || 'canvas')
+    state.activeOperations.add(token)
+    if (options.allowExternalSync === true) state.progressiveSyncOperations.add(token)
+    return token
+  }
+
+  function endActiveOperation(token) {
+    if (token) {
+      state.activeOperations.delete(token)
+      state.progressiveSyncOperations.delete(token)
+    }
+    if (state.externalSyncPending && !shouldDeferExternalSync()) {
+      setTimeout(() => syncExternalChanges(), 0)
+    }
+  }
+
+  return {
+    beginActiveOperation,
+    createCanvasClientId,
+    endActiveOperation,
+    hasActiveOperations,
+  }
+}

package/dist/canvas-public/core/project.js

@@ -0,0 +1,203 @@
+import { t } from '../language/index.js'
+import { api } from './api.js'
+import { state } from './state.js'
+
+export function createProjectController({
+  resetFeatures,
+  disposeTileMapViews,
+  elements,
+  hideCtxMenu,
+  reload,
+  resetImageSizeSave,
+  resetLayoutController,
+}) {
+  const els = elements
+  function resetSessionState() {
+    resetFeatures()
+    disposeTileMapViews()
+    resetImageSizeSave()
+    state.meta = null
+    state.images = []
+    state.layoutItems = []
+    state.layoutRevision = 0
+    resetLayoutController()
+    state.selectedIds = new Set()
+    state.activeOperations.clear()
+    state.progressiveSyncOperations.clear()
+    state.failedOperationIds.clear()
+    state.pendingUiRecoveries.clear()
+    state.deleting = false
+    state.error = ''
+    state.camera = { x: 0, y: 0, scale: 1 }
+    state.ctxTargetId = null
+    state.ctxCanvasPoint = null
+    state.frameSheetPlayback = {}
+    state.scrollImagePlayback = {}
+    state.imageDims = {}
+    state.videoMeta = {}
+    hideCtxMenu()
+    if (els.world) els.world.innerHTML = ''
+    if (els.inspector) els.inspector.hidden = true
+  }
+  
+  function applyProjectPayload(data) {
+    state.project = data.project || null
+    state.recent = Array.isArray(data.recent) ? data.recent : []
+  }
+  
+  function renderProjectChrome() {
+    if (!els.projectName) return
+    if (state.project) {
+      els.projectName.textContent = state.project.path || state.project.name
+      els.projectName.title = state.project.path || ''
+    } else {
+      els.projectName.textContent = t("core.project.text001")
+      els.projectName.title = ''
+    }
+  }
+  
+  function renderWelcome() {
+    const hasProject = Boolean(state.project)
+    els.welcome.hidden = hasProject
+    els.app.hidden = !hasProject
+    document.body.classList.toggle('has-project', hasProject)
+  
+    if (state.welcomeError) {
+      els.welcomeError.hidden = false
+      els.welcomeError.textContent = state.welcomeError
+    } else {
+      els.welcomeError.hidden = true
+      els.welcomeError.textContent = ''
+    }
+  
+    const recent = state.recent || []
+    if (!hasProject && recent.length) {
+      els.welcomeRecent.hidden = false
+      els.welcomeRecentList.innerHTML = ''
+      for (const item of recent) {
+        const li = document.createElement('li')
+        const btn = document.createElement('button')
+        btn.type = 'button'
+        btn.className = 'recent-item'
+        const name = document.createElement('strong')
+        name.textContent = item.name || item.path
+        const pathEl = document.createElement('span')
+        pathEl.textContent = item.path
+        btn.append(name, pathEl)
+        btn.addEventListener('click', () => openProjectPath(item.path))
+        li.appendChild(btn)
+        els.welcomeRecentList.appendChild(li)
+      }
+    } else {
+      els.welcomeRecent.hidden = true
+      els.welcomeRecentList.innerHTML = ''
+    }
+  
+    const pickingLabel = state.picking ? t("core.project.text002") : t("core.project.text003")
+    els.welcomeOpenBtn.disabled = state.picking
+    els.welcomeOpenBtn.textContent = pickingLabel
+    if (els.switchProjectBtn) {
+      els.switchProjectBtn.disabled = state.picking
+      els.switchProjectBtn.textContent = state.picking ? t("core.project.text004") : t("core.project.text005")
+    }
+    if (state.picking && !state.welcomeError) {
+      els.welcomeError.hidden = false
+      els.welcomeError.textContent = t("core.project.text006")
+      els.welcomeError.style.color = 'var(--muted)'
+    } else if (state.welcomeError) {
+      els.welcomeError.style.color = ''
+    }
+    renderProjectChrome()
+  }
+  
+  async function enterProject() {
+    resetSessionState()
+    renderWelcome()
+    await reload()
+  }
+  
+  async function pickProject() {
+    if (state.picking) return
+    state.picking = true
+    state.welcomeError = ''
+    // 先回到欢迎页，避免系统对话框被挡住时界面毫无反馈
+    const previous = state.project
+    state.project = null
+    renderWelcome()
+    try {
+      const data = await api('/api/project/pick', { method: 'POST' })
+      if (data.cancelled) {
+        state.project = previous
+        applyProjectPayload({ project: previous, recent: data.recent || state.recent })
+        renderWelcome()
+        return
+      }
+      applyProjectPayload(data)
+      if (!state.project) {
+        state.project = previous
+        state.welcomeError = t("core.project.text007")
+        renderWelcome()
+        return
+      }
+      await enterProject()
+    } catch (err) {
+      state.project = previous
+      state.welcomeError = String(err.message || err)
+      renderWelcome()
+    } finally {
+      state.picking = false
+      renderWelcome()
+    }
+  }
+  
+  async function openProjectPath(projectPath) {
+    if (state.picking || !projectPath) return
+    state.picking = true
+    state.welcomeError = ''
+    renderWelcome()
+    try {
+      const data = await api('/api/project/open', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: projectPath }),
+      })
+      applyProjectPayload(data)
+      if (!state.project) {
+        state.welcomeError = t("core.project.text007")
+        renderWelcome()
+        return
+      }
+      await enterProject()
+    } catch (err) {
+      state.welcomeError = String(err.message || err)
+      renderWelcome()
+    } finally {
+      state.picking = false
+      renderWelcome()
+    }
+  }
+  
+  async function boot() {
+    try {
+      const data = await api('/api/project')
+      applyProjectPayload(data)
+      if (!state.project) {
+        renderWelcome()
+        return
+      }
+      await enterProject()
+    } catch (err) {
+      state.welcomeError = String(err.message || err)
+      state.project = null
+      renderWelcome()
+    }
+  }
+
+  return {
+    boot,
+    pickProject,
+    renderProjectChrome,
+    renderWelcome,
+    resetSessionState,
+  }
+}

package/dist/canvas-public/core/state.js

@@ -0,0 +1,27 @@
+export const state = {
+  project: null,
+  recent: [],
+  meta: null,
+  images: [],
+  layoutItems: [],
+  layoutRevision: 0,
+  selectedIds: new Set(),
+  activeOperations: new Set(),
+  progressiveSyncOperations: new Set(),
+  failedOperationIds: new Set(),
+  pendingUiRecoveries: new Map(), // operation id -> replaced input UI snapshot
+  deleting: false,
+  refreshing: false,
+  externalSyncPending: false,
+  picking: false,
+  error: '',
+  welcomeError: '',
+  camera: { x: 0, y: 0, scale: 1 },
+  ctxTargetId: null,
+  ctxCanvasPoint: null,
+  frameSheetPlayback: {}, // canvas item id -> { index, acc }
+  scrollImagePlayback: {}, // canvas item id -> { offset }
+  imageDims: {}, // id -> { w, h } | { loading: true }
+  videoMeta: {}, // id -> { w, h, duration } | { loading: true }
+  inspectorCollapsedSections: new Set(),
+}