fix(editor): clean up orphaned local asset:// files from IndexedDB

apps/editor/components/scene-loader.tsx

@@ -1,5 +1,6 @@
 'use client'
 
+import { useScene } from '@pascal-app/core'
 // Node registry bootstrap is loaded once at the root via
 // `<ClientBootstrap>` in `app/layout.tsx` — no per-page side-effect
 // import here.
@@ -15,6 +16,7 @@ import Link from 'next/link'
 import { useRouter, useSearchParams } from 'next/navigation'
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { countGraphNodes, isEmptyGraphOverwrite } from '@/lib/empty-graph-guard'
+import { collectNodeAssetUrlList, runLocalAssetGc } from '@/lib/local-asset-gc'
 import { type PersistedSceneGraph, sceneGraphSignature } from '@/lib/scene-signature'
 import { cn } from '@/lib/utils'
 import { BuildTab } from './build-tab'
@@ -125,6 +127,21 @@ export function SceneLoader({ initialScene, meta }: SceneLoaderProps) {
 
   const handleLoad = useCallback(async () => initialScene, [initialScene])
 
+  // Explicit multi-scene GC after this scene is hydrated. Only deletes Files
+  // that no persisted graph still references; skips when the inventory is
+  // incomplete. Live nodes are re-read immediately before sweep (#733).
+  const gcRanRef = useRef(false)
+  useEffect(() => {
+    if (gcRanRef.current) return
+    gcRanRef.current = true
+    void runLocalAssetGc(
+      () => useScene.getState().nodes,
+      collectNodeAssetUrlList(initialScene.nodes as Record<string, unknown>),
+    ).catch(() => {
+      /* enumeration failed — skip GC rather than partial-sweep */
+    })
+  }, [initialScene])
+
   const handleSave = useCallback(
     async (graph: SceneGraph, options?: { keepalive?: boolean }) => {
       const graphJson = sceneGraphSignature(graph)

apps/editor/lib/local-asset-gc.test.ts

@@ -0,0 +1,87 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { collectNodeAssetUrlList, runLocalAssetGc } from './local-asset-gc'
+
+type FetchHandler = (url: string) => Response | Promise<Response>
+
+function mockFetch(handler: FetchHandler): () => void {
+  const original = globalThis.fetch
+  globalThis.fetch = (async (input: RequestInfo | URL) => {
+    const url = typeof input === 'string' ? input : input.toString()
+    return handler(url)
+  }) as typeof fetch
+  return () => {
+    globalThis.fetch = original
+  }
+}
+
+function json(body: unknown, ok = true, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  })
+}
+
+afterEach(() => {
+  // ensure no leftover mock if a test throws
+})
+
+describe('local-asset-gc collectors', () => {
+  test('collectNodeAssetUrlList walks url and src', () => {
+    const urls = collectNodeAssetUrlList({
+      a: { url: 'asset://guide' },
+      b: { src: 'asset://model' },
+      c: { src: 'https://cdn.example.com/x.glb' },
+    })
+    expect(urls.sort()).toEqual(['asset://guide', 'asset://model'])
+  })
+})
+
+describe('runLocalAssetGc safety', () => {
+  test('skips GC when the scene list is truncated at the API limit', async () => {
+    const scenes = Array.from({ length: 500 }, (_, i) => ({ id: `scene-${i}` }))
+    const restore = mockFetch((url) => {
+      if (url.includes('/api/scenes?')) return json({ scenes })
+      return json({ graph: { nodes: {} } })
+    })
+    try {
+      const result = await runLocalAssetGc(() => ({}))
+      expect(result).toBeNull()
+    } finally {
+      restore()
+    }
+  })
+
+  test('skips GC when listing scenes fails', async () => {
+    const restore = mockFetch(() => json({ error: 'no' }, false, 500))
+    try {
+      expect(await runLocalAssetGc(() => ({}))).toBeNull()
+    } finally {
+      restore()
+    }
+  })
+
+  test('re-reads live nodes so mid-GC uploads stay in the keep-set', async () => {
+    // Live graph is empty when GC starts, then gains a guide during the
+    // per-scene fetch — the File must survive the sweep.
+    let live: Record<string, unknown> = {}
+    const lateAsset = 'asset://uploaded-mid-gc'
+    const restore = mockFetch(async (url) => {
+      if (url.includes('/api/scenes?')) {
+        // Simulate latency while the user uploads.
+        live = { guide: { url: lateAsset } }
+        return json({ scenes: [] })
+      }
+      return json({ graph: { nodes: {} } })
+    })
+    try {
+      const result = await runLocalAssetGc(() => live)
+      // Keep-set included the late upload, so sweep ran but did not need to
+      // delete it (result is a count of removals — File itself is not present
+      // in this unit test's IDB; the contract is "keep-set includes live URLs").
+      expect(result).not.toBeNull()
+      expect(collectNodeAssetUrlList(live)).toContain(lateAsset)
+    } finally {
+      restore()
+    }
+  })
+})

apps/editor/lib/local-asset-gc.ts

@@ -0,0 +1,115 @@
+import {
+  collectNodeAssetUrls,
+  collectSceneAssetUrls,
+  sweepLocalAssetsExcept,
+} from '@pascal-app/core'
+
+const LOCAL_STORAGE_SCENE_KEY = 'pascal-editor-scene'
+/** Must match apps/editor/app/api/scenes/route.ts listQuerySchema max. */
+const SCENES_LIST_MAX = 500
+
+type SceneGraphLike = {
+  nodes?: Record<string, unknown>
+}
+
+function collectGraphAssetUrls(graph: SceneGraphLike | null | undefined): string[] {
+  if (!graph?.nodes) return []
+  return collectSceneAssetUrls(graph.nodes as never)
+}
+
+/** Asset URLs still referenced by the browser's localStorage scene, if any. */
+export function collectLocalStorageSceneAssetUrls(): string[] {
+  if (typeof localStorage === 'undefined') return []
+  try {
+    const raw = localStorage.getItem(LOCAL_STORAGE_SCENE_KEY)
+    if (!raw) return []
+    return collectGraphAssetUrls(JSON.parse(raw) as SceneGraphLike)
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Union of asset URLs across every graph this origin can still open.
+ * Returns null when the inventory cannot be proven complete — callers must
+ * skip GC rather than sweep from a partial keep-set.
+ */
+export async function collectAllPersistedAssetUrls(
+  currentNodes: Record<string, unknown>,
+): Promise<string[] | null> {
+  const keep = new Set<string>(collectSceneAssetUrls(currentNodes as never))
+  for (const url of collectLocalStorageSceneAssetUrls()) keep.add(url)
+
+  // Server-side scenes may share the same asset:// handles after duplication.
+  // If listing fails or is truncated we cannot prove the keep-set is complete.
+  let scenesJson: { data?: { scenes?: unknown[] }; scenes?: unknown[] } | null = null
+  try {
+    const res = await fetch(`/api/scenes?limit=${SCENES_LIST_MAX}`)
+    if (!res.ok) return null
+    scenesJson = (await res.json()) as {
+      data?: { scenes?: unknown[] }
+      scenes?: unknown[]
+    }
+  } catch {
+    return null
+  }
+
+  const list = (scenesJson?.data?.scenes ?? scenesJson?.scenes ?? []) as Array<{
+    id?: unknown
+  }>
+  // The API has no cursor/total. A full page means older scenes were dropped
+  // by `limit` — treating it as complete would delete their Files.
+  if (list.length >= SCENES_LIST_MAX) return null
+
+  for (const entry of list) {
+    const id = entry?.id
+    if (typeof id !== 'string' || !id) continue
+    try {
+      const res = await fetch(`/api/scenes/${encodeURIComponent(id)}`)
+      if (!res.ok) return null
+      const body = (await res.json()) as {
+        data?: { graph?: SceneGraphLike; scene?: { graph?: SceneGraphLike } }
+        graph?: SceneGraphLike
+      }
+      const graph = body.data?.graph ?? body.data?.scene?.graph ?? body.graph ?? null
+      for (const url of collectGraphAssetUrls(graph)) keep.add(url)
+    } catch {
+      return null
+    }
+  }
+
+  return [...keep]
+}
+
+/**
+ * Explicit GC: delete IndexedDB Files that no persisted scene references.
+ *
+ * `getLiveNodes` is re-read immediately before sweeping so uploads that
+ * landed while the long per-scene fetch ran stay in the keep-set.
+ * No-ops when the full keep-set cannot be built (never partial-sweeps).
+ */
+export async function runLocalAssetGc(
+  getLiveNodes: () => Record<string, unknown>,
+  extraKeepUrls: Iterable<string> = [],
+): Promise<number | null> {
+  const keep = await collectAllPersistedAssetUrls(getLiveNodes())
+  if (keep === null) return null
+
+  const finalKeep = new Set<string>(keep)
+  for (const url of collectSceneAssetUrls(getLiveNodes() as never)) {
+    finalKeep.add(url)
+  }
+  for (const url of extraKeepUrls) {
+    if (typeof url === 'string' && url.startsWith('asset://')) finalKeep.add(url)
+  }
+  return sweepLocalAssetsExcept(finalKeep)
+}
+
+/** For tests: collect urls from an arbitrary node map. */
+export function collectNodeAssetUrlList(nodes: Record<string, unknown>): string[] {
+  const urls: string[] = []
+  for (const node of Object.values(nodes)) {
+    urls.push(...collectNodeAssetUrls(node as never))
+  }
+  return urls
+}

packages/core/src/index.ts

@@ -97,7 +97,13 @@ export {
   type WallConstructionResolution,
 } from './hooks/spatial-grid/support-host-patch'
 export { useSpatialQuery } from './hooks/spatial-grid/use-spatial-query'
-export { loadAssetUrl, saveAsset } from './lib/asset-storage'
+export {
+  deleteAsset,
+  listLocalAssetUrls,
+  loadAssetUrl,
+  saveAsset,
+  sweepLocalAssetsExcept,
+} from './lib/asset-storage'
 export {
   clampDoorOperationState,
   getDoorRenderOpenAmount,
@@ -106,6 +112,7 @@ export {
   SECTIONAL_GARAGE_RENDER_OPEN_SCALE,
 } from './lib/door-operation'
 export { getDefaultLevelName, getLevelDisplayName } from './lib/level-name'
+export { collectNodeAssetUrls, collectSceneAssetUrls } from './lib/local-asset-lifecycle'
 export {
   areMeasurementPointsCoplanar,
   closestMeasurementFeatureBinding,

packages/core/src/lib/asset-storage.test.ts

@@ -1,6 +1,6 @@
 import 'fake-indexeddb/auto'
 import { afterEach, describe, expect, test } from 'bun:test'
-import { loadAssetUrl, saveAsset } from './asset-storage'
+import { deleteAsset, loadAssetUrl, saveAsset } from './asset-storage'
 
 function file(contents: string, name = 'test.txt'): File {
   return new File([contents], name, { type: 'text/plain' })
@@ -61,3 +61,18 @@ describe('loadAssetUrl', () => {
     expect(await loadAssetUrl('')).toBeNull()
   })
 })
+
+describe('deleteAsset', () => {
+  test('removes the IndexedDB entry so later loads miss', async () => {
+    const url = await saveAsset(file('delete-me'))
+    expect(await loadAssetUrl(url)).not.toBeNull()
+
+    expect(await deleteAsset(url)).toBe(true)
+    expect(await loadAssetUrl(url)).toBeNull()
+  })
+
+  test('ignores non-asset URLs', async () => {
+    expect(await deleteAsset('https://cdn.example.com/a.glb')).toBe(false)
+    expect(await deleteAsset('')).toBe(false)
+  })
+})

packages/core/src/lib/asset-storage.ts

@@ -1,4 +1,4 @@
-import { get, set } from 'idb-keyval'
+import { del, get, keys, set } from 'idb-keyval'
 import { customAlphabet } from 'nanoid'
 
 export const ASSET_PREFIX = 'asset_data:'
@@ -9,6 +9,19 @@ const urlCache = new Map<string, string>()
 // Unlike crypto.randomUUID(), nanoid works outside secure contexts.
 const nanoAssetId = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyz', 16)
 
+function assetIdFromUrl(url: string): string | null {
+  if (!url.startsWith('asset://')) return null
+  return url.replace('asset://', '') || null
+}
+
+function revokeCachedObjectUrl(id: string) {
+  const objectUrl = urlCache.get(id)
+  if (objectUrl) {
+    URL.revokeObjectURL(objectUrl)
+    urlCache.delete(id)
+  }
+}
+
 /**
  * Save a file to IndexedDB and return a custom protocol URL
  */
@@ -31,9 +44,8 @@ export async function loadAssetUrl(url: string): Promise<string | null> {
   }
 
   // Handle our custom asset protocol
-  if (url.startsWith('asset://')) {
-    const id = url.replace('asset://', '')
-
+  const id = assetIdFromUrl(url)
+  if (id) {
     // Check cache first
     if (urlCache.has(id)) {
       return urlCache.get(id)!
@@ -57,3 +69,67 @@ export async function loadAssetUrl(url: string): Promise<string | null> {
   // Legacy data URLs are returned as is
   return url
 }
+
+/**
+ * Delete a locally stored `asset://` file from IndexedDB and drop any cached
+ * object URL. No-op for non-asset URLs.
+ *
+ * Callers must only invoke this when no *persisted* scene still references
+ * the URL — IndexedDB is origin-global and not scoped by project (#733).
+ */
+export async function deleteAsset(url: string): Promise<boolean> {
+  const id = assetIdFromUrl(url)
+  if (!id) return false
+  revokeCachedObjectUrl(id)
+  try {
+    await del(`${ASSET_PREFIX}${id}`)
+    return true
+  } catch (error) {
+    console.error('Failed to delete asset:', error)
+    return false
+  }
+}
+
+/** Every `asset://` id currently stored in IndexedDB. */
+export async function listLocalAssetUrls(): Promise<string[]> {
+  try {
+    const allKeys = await keys()
+    const urls: string[] = []
+    for (const key of allKeys) {
+      if (typeof key === 'string' && key.startsWith(ASSET_PREFIX)) {
+        urls.push(`asset://${key.slice(ASSET_PREFIX.length)}`)
+      }
+    }
+    return urls
+  } catch (error) {
+    console.error('Failed to list local assets:', error)
+    return []
+  }
+}
+
+/**
+ * Explicit garbage collection: delete every local asset URL not in
+ * `keepUrls`.
+ *
+ * `keepUrls` MUST be the union of asset references across **every persisted
+ * graph** the origin can still open (current scene, localStorage scene,
+ * server scenes). A keep-set built from only the active graph will corrupt
+ * other projects that share an `asset://` handle after duplication (#733).
+ */
+export async function sweepLocalAssetsExcept(keepUrls: Iterable<string>): Promise<number> {
+  const keep = new Set<string>()
+  for (const url of keepUrls) {
+    if (typeof url === 'string' && url.startsWith('asset://')) keep.add(url)
+  }
+
+  let removed = 0
+  try {
+    for (const url of await listLocalAssetUrls()) {
+      if (keep.has(url)) continue
+      if (await deleteAsset(url)) removed += 1
+    }
+  } catch (error) {
+    console.error('Failed to sweep local assets:', error)
+  }
+  return removed
+}