@wangxiaocuo/dsh-session-trash 0.5.1 → 0.6.1

package/lib/fsops.js

@@ -209,6 +209,25 @@ export function isSafeTrashId(trashId) {
   )
 }
 
+/**
+ * Whether a session identity may name one child directory inside a trash
+ * object. Session ids are `session-<uuid>` or a bare uuid today, so the
+ * accepted alphabet is deliberately conservative.
+ *
+ * @param {unknown} sessionId candidate member identity.
+ * @returns {boolean} whether the identity is one safe path segment.
+ */
+export function isSafeMemberId(sessionId) {
+  return (
+    typeof sessionId === 'string' &&
+    sessionId !== '' &&
+    sessionId.length <= 256 &&
+    /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(sessionId) &&
+    sessionId !== '.' &&
+    sessionId !== '..'
+  )
+}
+
 /**
  * Reject a path that is not one safe segment below its parent.
  *

package/lib/http.js

@@ -274,6 +274,11 @@ export function registerApi({ ctx, eligibility, stateService, trashService, clea
     if (config.debug) {
       logger.debug(`preflight ${sessionId} -> ${verdict.eligible ? 'eligible' : verdict.code}`)
     }
+    if (verdict.eligible === true) {
+      const members = Array.isArray(verdict.members) ? verdict.members : []
+      sendJson(res, 200, { eligible: true, descendants: Math.max(0, members.length - 1) })
+      return
+    }
     sendJson(res, 200, verdict)
   })
 

package/lib/inventory.js

@@ -1,12 +1,20 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
-import { entryKind, isSafeDirectoryPath, isSafeTrashId, samePath } from './fsops.js'
+import { mapLimit } from './concurrency.js'
+import { entryKind, isSafeDirectoryPath, isSafeMemberId, isSafeTrashId, samePath } from './fsops.js'
+import { memberList } from './members.js'
+
+/** Maximum concurrent object directories inspected during a scan. */
+const SCAN_CONCURRENCY = 4
 
 /** Every state the durable index understands. */
 export const ENTRY_STATES = new Set(['trashing', 'trashed', 'restoring', 'purging', 'missing'])
 
 /** Sidecar schema version understood by this release. */
-const META_VERSION = 1
+const META_VERSION = 2
+
+/** Maximum directories one trashed item may own. */
+const MAX_MEMBERS = 64
 
 /**
  * @param {unknown} value candidate timestamp.
@@ -16,6 +24,77 @@ function isFiniteNumber(value) {
   return typeof value === 'number' && Number.isFinite(value)
 }
 
+/**
+ * @param {unknown} value candidate metric.
+ * @returns {boolean} whether the value is a usable number or absent.
+ */
+function isMetric(value) {
+  return value === undefined || value === null || isFiniteNumber(value)
+}
+
+/**
+ * Validate one v2 member's absolute paths. The parent's sidecar is validated
+ * field by field so a hand-edited file is rejected instead of guessed at.
+ *
+ * @param {unknown} member candidate member.
+ * @returns {boolean} whether the member names safe, coherent paths.
+ */
+function isValidMemberPaths(member) {
+  if (member === null || typeof member !== 'object' || Array.isArray(member)) return false
+  if (!isSafeMemberId(member.sessionId)) return false
+  if (member.origin !== undefined && member.origin !== null && member.origin !== 'subagent') return false
+  if (member.title !== undefined && typeof member.title !== 'string') return false
+  if (
+    member.formatStatus !== undefined &&
+    member.formatStatus !== 'current' &&
+    member.formatStatus !== 'migration-required'
+  ) {
+    return false
+  }
+  if (!isMetric(member.sizeBytes) || !isMetric(member.fileCount)) return false
+  if (!isSafeDirectoryPath(member.originalSessionDir)) return false
+  if (typeof member.originalLogPath !== 'string' || !path.isAbsolute(member.originalLogPath)) return false
+  if (
+    typeof member.persistenceProjectDirHint !== 'string' ||
+    !path.isAbsolute(member.persistenceProjectDirHint)
+  ) {
+    return false
+  }
+  if (!samePath(path.dirname(path.resolve(member.originalSessionDir)), path.resolve(member.persistenceProjectDirHint))) {
+    return false
+  }
+  if (!samePath(path.dirname(path.resolve(member.originalLogPath)), path.resolve(member.originalSessionDir))) {
+    return false
+  }
+  return true
+}
+
+/**
+ * Validate the v2 member list of one sidecar.
+ *
+ * @param {object} meta candidate sidecar.
+ * @returns {boolean} whether the list is coherent with its parent fields.
+ */
+function isValidMetaMembers(meta) {
+  if (!Array.isArray(meta.members) || meta.members.length === 0 || meta.members.length > MAX_MEMBERS) return false
+  if (!meta.members.every((member) => isValidMemberPaths(member))) return false
+  const seen = new Set()
+  for (const member of meta.members) {
+    if (seen.has(member.sessionId)) return false
+    seen.add(member.sessionId)
+  }
+  const parent = meta.members[0]
+  if (parent.sessionId !== meta.sessionId) return false
+  if (!samePath(path.resolve(parent.originalSessionDir), path.resolve(meta.originalSessionDir))) return false
+  if (!samePath(path.resolve(parent.originalLogPath), path.resolve(meta.originalLogPath))) return false
+  if (
+    !samePath(path.resolve(parent.persistenceProjectDirHint), path.resolve(meta.persistenceProjectDirHint))
+  ) {
+    return false
+  }
+  return true
+}
+
 /**
  * Validate one object sidecar strictly enough to be rebuilt into an index
  * entry. A malformed sidecar is reported as an unindexed object instead of
@@ -27,7 +106,7 @@ function isFiniteNumber(value) {
  */
 export function isValidMeta(meta, trashId) {
   if (meta === null || typeof meta !== 'object' || Array.isArray(meta)) return false
-  if (meta.version !== undefined && meta.version !== META_VERSION) return false
+  if (meta.version !== undefined && meta.version !== META_VERSION && meta.version !== 1) return false
   if (typeof meta.sessionId !== 'string' || meta.sessionId === '' || meta.sessionId.length > 256) return false
   if (meta.trashId !== trashId) return false
   if (!ENTRY_STATES.has(meta.state)) return false
@@ -48,20 +127,58 @@ export function isValidMeta(meta, trashId) {
   ) {
     return false
   }
+  if (meta.version === META_VERSION) return isValidMetaMembers(meta)
   return true
 }
 
+/**
+ * @param {Record<string, unknown>} member raw member fields.
+ * @param {string} fallbackTitle title used when the member carries none.
+ * @returns {object} one normalized v2 member.
+ */
+function toMember(member, fallbackTitle) {
+  return {
+    sessionId: member.sessionId,
+    origin: member.origin === 'subagent' ? 'subagent' : null,
+    title: typeof member.title === 'string' && member.title !== '' ? member.title : fallbackTitle,
+    originalSessionDir: path.resolve(member.originalSessionDir),
+    originalLogPath: path.resolve(member.originalLogPath),
+    persistenceProjectDirHint: path.resolve(member.persistenceProjectDirHint),
+    formatStatus: member.formatStatus === 'migration-required' ? 'migration-required' : 'current',
+    sizeBytes: isFiniteNumber(member.sizeBytes) ? member.sizeBytes : null,
+    fileCount: isFiniteNumber(member.fileCount) ? member.fileCount : null,
+  }
+}
+
 /**
  * @param {Record<string, unknown>} meta valid sidecar.
  * @returns {object} a clean index entry with defaulted optional fields.
  */
-function toEntry(meta) {
+export function toEntry(meta) {
   const originalCwd = typeof meta.originalCwd === 'string' && meta.originalCwd !== '' ? meta.originalCwd : null
+  const title = typeof meta.title === 'string' && meta.title !== '' ? meta.title : meta.sessionId
+  const members =
+    Array.isArray(meta.members) && meta.members.length > 0
+      ? meta.members.map((member) => toMember(member, title))
+      : [
+          toMember(
+            {
+              sessionId: meta.sessionId,
+              originalSessionDir: meta.originalSessionDir,
+              originalLogPath: meta.originalLogPath,
+              persistenceProjectDirHint: meta.persistenceProjectDirHint,
+              formatStatus: meta.formatStatus,
+              sizeBytes: meta.sizeBytes,
+              fileCount: meta.fileCount,
+            },
+            title,
+          ),
+        ]
   return {
     sessionId: meta.sessionId,
     trashId: meta.trashId,
     state: meta.state,
-    title: meta.title,
+    title,
     trashedAt: meta.trashedAt,
     startedAt: meta.startedAt,
     originalCwd,
@@ -75,25 +192,75 @@ function toEntry(meta) {
     formatStatus: meta.formatStatus === 'migration-required' ? 'migration-required' : 'current',
     sizeBytes: isFiniteNumber(meta.sizeBytes) ? meta.sizeBytes : null,
     fileCount: isFiniteNumber(meta.fileCount) ? meta.fileCount : null,
+    members,
     lastError: typeof meta.lastError === 'string' && meta.lastError !== '' ? meta.lastError : null,
   }
 }
 
+/**
+ * Which of one entry's member directories currently exist inside its object.
+ *
+ * @param {import('./store.js').TrashStore} store trash store owning `objects/`.
+ * @param {object} entry index entry, v1 or v2 shaped.
+ * @returns {Promise<{ total: number, present: number, missing: string[] }>} presence summary.
+ */
+export async function memberPresence(store, entry) {
+  const members =
+    Array.isArray(entry.members) && entry.members.length > 0
+      ? entry.members
+      : [{ sessionId: entry.sessionId, originalSessionDir: entry.originalSessionDir }]
+  const missing = []
+  let present = 0
+  for (let index = 0; index < members.length; index += 1) {
+    const member = members[index]
+    let kind = 'missing'
+    try {
+      kind = await entryKind(store.memberPath(entry.trashId, index, member.sessionId))
+    } catch {
+      kind = 'missing'
+    }
+    if (kind === 'directory') present += 1
+    else missing.push(typeof member.sessionId === 'string' ? member.sessionId : entry.sessionId)
+  }
+  return { total: members.length, present, missing }
+}
+
+/**
+ * Whether two member lists name the same directories in the same order, so a
+ * presence probe taken for one can be reused for the other.
+ *
+ * @param {readonly object[]} left first member list.
+ * @param {readonly object[]} right second member list.
+ * @returns {boolean} whether both lists describe the same members.
+ */
+function sameMembers(left, right) {
+  if (left.length !== right.length) return false
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index]?.sessionId !== right[index]?.sessionId) return false
+  }
+  return true
+}
+
 /**
  * Reconcile a rebuilt entry with the object directory observed on disk.
  *
  * @param {object} entry index-shaped entry.
- * @param {boolean} sessionExists whether `objects/<trashId>/session` is a directory.
+ * @param {{ total: number, present: number, missing: string[] }} presence member presence.
  * @param {number} now current timestamp.
  * @returns {object} the entry whose state matches the filesystem.
  */
-export function deriveEntry(entry, sessionExists, now) {
-  if (!sessionExists) {
+export function deriveEntry(entry, presence, now) {
+  const complete = presence.total > 0 && presence.present === presence.total
+  if (!complete) {
     if (entry.state === 'purging' || entry.state === 'missing') return { ...entry }
+    const lastError =
+      presence.present === 0
+        ? 'The trash copy of this session is missing.'
+        : `The trash copy is missing these member sessions: ${presence.missing.join(', ')}.`
     return {
       ...entry,
       state: 'missing',
-      lastError: 'The trash copy of this session is missing.',
+      lastError,
     }
   }
   if (entry.state === 'missing') {
@@ -115,7 +282,7 @@ export function deriveEntry(entry, sessionExists, now) {
  *
  * @param {import('./store.js').TrashStore} store trash store owning `objects/`.
  * @param {{ warn: Function }} logger diagnostics sink.
- * @returns {Promise<{ objects: { trashId: string, sessionExists: boolean, meta: object | undefined, metaValid: boolean }[], unindexed: number }>} the inventory.
+ * @returns {Promise<{ objects: { trashId: string, sessionExists: boolean, meta: object | undefined, metaValid: boolean, entry?: object, presence?: object }[], unindexed: number }>} the inventory.
  */
 export async function scanObjects(store, logger) {
   let entries
@@ -125,13 +292,8 @@ export async function scanObjects(store, logger) {
     if (error !== null && error !== undefined && error.code === 'ENOENT') return { objects: [], unindexed: 0 }
     throw error
   }
-  const objects = []
-  let unindexed = 0
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !isSafeTrashId(entry.name)) {
-      unindexed += 1
-      continue
-    }
+  const scanned = await mapLimit(entries, SCAN_CONCURRENCY, async (entry) => {
+    if (!entry.isDirectory() || !isSafeTrashId(entry.name)) return { unindexed: 1 }
     const trashId = entry.name
     let meta
     try {
@@ -140,23 +302,36 @@ export async function scanObjects(store, logger) {
       logger.warn(`cannot read the trash metadata for ${trashId}: ${error instanceof Error ? error.message : String(error)}`)
       // Keep the directory in the inventory so reconcile never mistakes an
       // unreadable sidecar for a vanished object directory.
-      objects.push({ trashId, sessionExists: false, meta: undefined, metaValid: false })
-      unindexed += 1
-      continue
+      return { object: { trashId, sessionExists: false, meta: undefined, metaValid: false }, unindexed: 1 }
     }
     const metaValid = meta !== undefined && isValidMeta(meta, trashId)
     if (!metaValid) {
-      objects.push({ trashId, sessionExists: false, meta, metaValid: false })
-      unindexed += 1
-      continue
+      return { object: { trashId, sessionExists: false, meta, metaValid: false }, unindexed: 1 }
     }
-    let sessionExists = false
+    let presence
     try {
-      sessionExists = (await entryKind(store.sessionPath(trashId))) === 'directory'
+      presence = await memberPresence(store, toEntry(meta))
     } catch (error) {
       logger.warn(`cannot inspect the trash copy ${trashId}: ${error instanceof Error ? error.message : String(error)}`)
+      presence = { total: 0, present: 0, missing: [] }
     }
-    objects.push({ trashId, sessionExists, meta, metaValid })
+    return {
+      object: {
+        trashId,
+        sessionExists: presence.total > 0 && presence.present === presence.total,
+        meta,
+        metaValid,
+        entry: toEntry(meta),
+        presence,
+      },
+      unindexed: 0,
+    }
+  })
+  const objects = []
+  let unindexed = 0
+  for (const result of scanned) {
+    unindexed += result.unindexed
+    if (result.object !== undefined) objects.push(result.object)
   }
   return { objects, unindexed }
 }
@@ -167,12 +342,15 @@ export async function scanObjects(store, logger) {
  * directory.
  *
  * @param {{ store: import('./store.js').TrashStore, logger: { warn: Function }, now?: number }} input trash store and diagnostics.
- * @returns {Promise<{ imported: number, markedMissing: number, unindexed: number, changed: number }>} reconcile summary.
+ * @returns {Promise<{ imported: number, markedMissing: number, unindexed: number, changed: number, presence: Map<string, object> }>} reconcile summary plus the presence probe per object.
  */
 export async function reconcileIndex({ store, logger, now = Date.now() }) {
-  if (store.isProtected()) return { imported: 0, markedMissing: 0, unindexed: store.unindexed, changed: 0 }
+  if (store.isProtected()) {
+    return { imported: 0, markedMissing: 0, unindexed: store.unindexed, changed: 0, presence: new Map() }
+  }
   const { objects, unindexed: invalidObjects } = await scanObjects(store, logger)
   const byTrashId = new Map(objects.map((object) => [object.trashId, object]))
+  const presenceByTrashId = new Map()
   const nextEntries = [...store.entries()]
   const indexedTrashIds = new Set(nextEntries.map((entry) => entry.trashId))
   const sessionIds = new Set(nextEntries.map((entry) => entry.sessionId))
@@ -197,7 +375,17 @@ export async function reconcileIndex({ store, logger, now = Date.now() }) {
       changed = true
       continue
     }
-    if (entry.state === 'missing' && object.sessionExists) {
+    // The scan already probed every member directory of this object. Reuse that
+    // answer when the sidecar and the index entry describe the same members;
+    // otherwise probe again rather than trust a mismatched snapshot.
+    const presence =
+      object.presence !== undefined &&
+      object.entry !== undefined &&
+      sameMembers(memberList(object.entry), memberList(entry))
+        ? object.presence
+        : await memberPresence(store, entry)
+    presenceByTrashId.set(object.trashId, presence)
+    if (entry.state === 'missing' && presence.total > 0 && presence.present === presence.total) {
       nextEntries[index] = {
         ...entry,
         state: 'trashed',
@@ -211,15 +399,15 @@ export async function reconcileIndex({ store, logger, now = Date.now() }) {
 
   for (const object of objects) {
     if (indexedTrashIds.has(object.trashId)) continue
-    if (!object.metaValid || object.meta === undefined) continue
-    const entry = toEntry(object.meta)
+    if (!object.metaValid || object.meta === undefined || object.entry === undefined || object.presence === undefined) continue
+    const entry = object.entry
     if (sessionIds.has(entry.sessionId)) {
       // Two object directories claim the same session: keep the indexed one.
       unindexed += 1
       logger.warn(`the trash object ${object.trashId} duplicates the indexed session ${entry.sessionId}`)
       continue
     }
-    const derived = deriveEntry(entry, object.sessionExists, now)
+    const derived = deriveEntry(entry, object.presence, now)
     nextEntries.push(derived)
     indexedTrashIds.add(derived.trashId)
     sessionIds.add(derived.sessionId)
@@ -237,7 +425,7 @@ export async function reconcileIndex({ store, logger, now = Date.now() }) {
     }
   }
   store.unindexed = unindexed
-  return { imported, markedMissing, unindexed, changed: changed ? 1 : 0 }
+  return { imported, markedMissing, unindexed, changed: changed ? 1 : 0, presence: presenceByTrashId }
 }
 
 /**
@@ -254,15 +442,15 @@ export async function rebuildIndex({ store, logger, now = Date.now() }) {
   const seen = new Set()
   let unindexed = invalidObjects
   for (const object of objects) {
-    if (!object.metaValid || object.meta === undefined) continue
-    const entry = toEntry(object.meta)
+    if (!object.metaValid || object.meta === undefined || object.entry === undefined || object.presence === undefined) continue
+    const entry = object.entry
     if (seen.has(entry.sessionId)) {
       unindexed += 1
       logger.warn(`the trash object ${object.trashId} duplicates the rebuilt session ${entry.sessionId}`)
       continue
     }
     seen.add(entry.sessionId)
-    entries.push(deriveEntry(entry, object.sessionExists, now))
+    entries.push(deriveEntry(entry, object.presence, now))
   }
   entries.sort((left, right) => left.startedAt - right.startedAt || left.trashId.localeCompare(right.trashId))
   await store.commit(entries)

package/lib/members.js

@@ -0,0 +1,95 @@
+/**
+ * One trashed item may own several session directories: the visible parent and
+ * every hidden `origin: 'subagent'` descendant. These helpers keep the v1
+ * single-directory shape readable while the durable index uses the v2
+ * `members` array.
+ *
+ * @module dsh-session-trash/members
+ */
+
+/**
+ * @param {unknown} entry index entry (v1 or v2 shape).
+ * @returns {object|null} the parent member, or null when the entry has no directory data.
+ */
+export function parentMember(entry) {
+  if (entry === null || typeof entry !== 'object') return null
+  if (typeof entry.sessionId !== 'string' || entry.sessionId === '') return null
+  return {
+    sessionId: entry.sessionId,
+    origin: null,
+    title: typeof entry.title === 'string' ? entry.title : entry.sessionId,
+    originalSessionDir: entry.originalSessionDir,
+    originalLogPath: entry.originalLogPath,
+    persistenceProjectDirHint: entry.persistenceProjectDirHint,
+    formatStatus: entry.formatStatus,
+    sizeBytes: entry.sizeBytes,
+    fileCount: entry.fileCount,
+  }
+}
+
+/**
+ * @param {unknown} entry index entry (v1 or v2 shape).
+ * @returns {object[]} every owned directory, parent first.
+ */
+export function memberList(entry) {
+  if (entry !== null && typeof entry === 'object' && Array.isArray(entry.members) && entry.members.length > 0) {
+    return entry.members
+  }
+  const parent = parentMember(entry)
+  return parent === null ? [] : [parent]
+}
+
+/**
+ * @param {readonly object[]} members member list.
+ * @returns {{ sizeBytes: number, fileCount: number }} summed measurable totals.
+ */
+export function aggregateMetrics(members) {
+  let sizeBytes = 0
+  let fileCount = 0
+  for (const member of members) {
+    if (typeof member?.sizeBytes === 'number') sizeBytes += member.sizeBytes
+    if (typeof member?.fileCount === 'number') fileCount += member.fileCount
+  }
+  return { sizeBytes, fileCount }
+}
+
+/**
+ * Shape-level validation shared by the durable index and object sidecars.
+ * Path strictness belongs to the sidecar validator.
+ *
+ * @param {unknown} member candidate member.
+ * @returns {boolean} whether the member carries the required v2 identity.
+ */
+export function isValidMemberShape(member) {
+  if (member === null || typeof member !== 'object' || Array.isArray(member)) return false
+  if (typeof member.sessionId !== 'string' || member.sessionId === '' || member.sessionId.length > 256) return false
+  if (member.origin !== undefined && member.origin !== null && member.origin !== 'subagent') return false
+  if (member.title !== undefined && typeof member.title !== 'string') return false
+  if (member.formatStatus !== undefined && member.formatStatus !== 'current' && member.formatStatus !== 'migration-required') {
+    return false
+  }
+  if (member.sizeBytes !== undefined && member.sizeBytes !== null && typeof member.sizeBytes !== 'number') return false
+  if (member.fileCount !== undefined && member.fileCount !== null && typeof member.fileCount !== 'number') return false
+  for (const key of ['originalSessionDir', 'originalLogPath', 'persistenceProjectDirHint']) {
+    if (member[key] !== undefined && member[key] !== null && typeof member[key] !== 'string') return false
+  }
+  return true
+}
+
+/**
+ * Whether the v2 member list is internally consistent with its parent entry.
+ *
+ * @param {unknown} entry index entry carrying `members`.
+ * @returns {boolean} whether the list is acceptable.
+ */
+export function isValidMemberList(entry) {
+  if (entry === null || typeof entry !== 'object') return false
+  if (!Array.isArray(entry.members) || entry.members.length === 0 || entry.members.length > 64) return false
+  const seen = new Set()
+  for (const member of entry.members) {
+    if (!isValidMemberShape(member)) return false
+    if (seen.has(member.sessionId)) return false
+    seen.add(member.sessionId)
+  }
+  return entry.members[0].sessionId === entry.sessionId
+}

package/lib/state.js

@@ -1,29 +1,10 @@
 import fs from 'node:fs/promises'
+import { mapLimit } from './concurrency.js'
+import { memberList } from './members.js'
 
 /** Maximum concurrent filesystem probes while describing entries. */
 const PROBE_CONCURRENCY = 3
 
-/**
- * @param {readonly T[]} items input items.
- * @param {number} limit maximum in-flight operations.
- * @param {(item: T) => Promise<R>} worker per-item operation.
- * @returns {Promise<R[]>} results in input order.
- * @template T, R
- */
-async function mapLimit(items, limit, worker) {
-  const results = new Array(items.length)
-  let next = 0
-  const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
-    while (next < items.length) {
-      const index = next
-      next += 1
-      results[index] = await worker(items[index])
-    }
-  })
-  await Promise.all(runners)
-  return results
-}
-
 /**
  * @param {string | null | undefined} directory candidate workspace directory.
  * @returns {Promise<boolean>} whether the directory exists right now.
@@ -85,6 +66,7 @@ export function createStateService({ store, config, trashRootDisplay, nextSweepA
     const expiresAt =
       typeof entry.trashedAt === 'number' && entry.trashedAt > 0 ? entry.trashedAt + config.retentionDays * 86_400_000 : null
     const trashed = entry.state === 'trashed'
+    const members = memberList(entry)
     return {
       sessionId: entry.sessionId,
       title: entry.title,
@@ -103,6 +85,12 @@ export function createStateService({ store, config, trashRootDisplay, nextSweepA
       canForget: entry.state === 'missing',
       requiresOrphanRestore: cwd !== null && workspaceNowExists === false,
       lastError: entry.lastError ?? null,
+      subagentCount: Math.max(0, members.length - 1),
+      members: members.map((member) => ({
+        sessionId: member.sessionId,
+        origin: member.origin === 'subagent' ? 'subagent' : null,
+        sizeBytes: typeof member.sizeBytes === 'number' ? member.sizeBytes : null,
+      })),
     }
   }