@dimina-kit/devtools 0.3.2-dev.20260524104239 → 0.3.2-dev.20260525152421

package/dist/main/index.bundle.js

@@ -1,5 +1,12 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/main/app/bootstrap.ts
-import { app as app2 } from "electron";
+import { app as app2, protocol } from "electron";
 
 // src/shared/constants.ts
 var DEFAULT_CDP_PORT = 9222;
@@ -63,6 +70,24 @@ function applyTheme(theme) {
 }
 
 // src/main/app/bootstrap.ts
+var difileSchemeRegistered = false;
+function registerDifileScheme() {
+  if (difileSchemeRegistered) return;
+  difileSchemeRegistered = true;
+  protocol.registerSchemesAsPrivileged([
+    {
+      scheme: "difile",
+      privileges: {
+        standard: true,
+        secure: true,
+        supportFetchAPI: true,
+        stream: true,
+        bypassCSP: true,
+        corsEnabled: true
+      }
+    }
+  ]);
+}
 function setupCdpPort() {
   if (app2.commandLine.getSwitchValue("remote-debugging-port")) return;
   const envPort = process.env.DIMINA_DEBUG_PORT;
@@ -79,9 +104,9 @@ function setupCdpPort() {
 }
 
 // src/main/app/app.ts
-import { app as app13, BrowserWindow as BrowserWindow4, nativeImage } from "electron";
-import fs7 from "fs";
-import path12 from "path";
+import { app as app13, BrowserWindow as BrowserWindow4, nativeImage, session as session2 } from "electron";
+import fs9 from "fs";
+import path14 from "path";
 
 // src/main/utils/paths.ts
 import fs2 from "fs";
@@ -1094,11 +1119,11 @@ function createWorkspaceService(ctx) {
   }
   async function disposeSession() {
     if (!currentSession) return;
-    const session2 = currentSession;
+    const session3 = currentSession;
     currentSession = null;
     try {
       await Promise.race([
-        session2.close(),
+        session3.close(),
         new Promise(
           (_, reject) => setTimeout(() => reject(new Error("session close timed out")), 5e3)
         )
@@ -1107,8 +1132,8 @@ function createWorkspaceService(ctx) {
       console.error("[workspace] session close failed:", err);
     }
   }
-  function applyRefererFromSession(session2) {
-    const appInfo = session2.appInfo;
+  function applyRefererFromSession(session3) {
+    const appInfo = session3.appInfo;
     if (appInfo && typeof appInfo.appId === "string" && appInfo.appId.length > 0) {
       setSimulatorServicewechatReferer(
         appInfo.appId,
@@ -1139,9 +1164,9 @@ function createWorkspaceService(ctx) {
       }
       sendStatus("compiling", "\u6B63\u5728\u7F16\u8BD1...");
       const { compile } = loadWorkbenchSettings();
-      let session2;
+      let session3;
       try {
-        session2 = await ctx.adapter.openProject({
+        session3 = await ctx.adapter.openProject({
           projectPath,
           sourcemap: true,
           watch: compile.watch,
@@ -1153,17 +1178,17 @@ function createWorkspaceService(ctx) {
         sendStatus("error", String(err));
         return { success: false, error: String(err) };
       }
-      currentSession = session2;
+      currentSession = session3;
       currentProjectPath = projectPath;
       bestEffort("updateLastOpened", () => {
         if (provider.updateLastOpened) provider.updateLastOpened(projectPath);
       });
       bestEffort("sendStatus", () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210"));
-      bestEffort("applyReferer", () => applyRefererFromSession(session2));
+      bestEffort("applyReferer", () => applyRefererFromSession(session3));
       return {
         success: true,
-        port: session2.port,
-        appInfo: session2.appInfo
+        port: session3.port,
+        appInfo: session3.appInfo
       };
     },
     async closeProject() {
@@ -3532,6 +3557,528 @@ async function clearElementInspection() {
   }
 }
 
+// src/main/services/simulator-temp-files/store.ts
+function registerTempFile(store, path16, mime, bytes) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
+  store.delete(path16);
+  store.set(path16, { bytes: buf, mime });
+}
+function revokeTempFile(store, path16) {
+  store.delete(path16);
+}
+function revokeAllTempFiles(store) {
+  store.clear();
+}
+
+// src/simulator/vpath.ts
+var _os = typeof __require !== "undefined" ? __require("os") : null;
+var _path = typeof __require !== "undefined" ? __require("path") : null;
+var DIFILE_PREFIX = "difile://";
+function sandboxBase() {
+  const env = typeof process !== "undefined" && process.env && process.env.DIMINA_HOME || "";
+  if (env) {
+    return _path.join(env, "files");
+  }
+  const home = _os ? _os.homedir() : "/tmp";
+  return _path.join(home, ".dimina", "files");
+}
+function resolveVPath(url) {
+  if (typeof url !== "string") return null;
+  if (!url.startsWith(DIFILE_PREFIX)) return null;
+  const raw = url.slice(DIFILE_PREFIX.length);
+  if (raw.length === 0) return null;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(raw);
+  } catch {
+    return null;
+  }
+  if (decoded.includes("\0")) return null;
+  decoded = decoded.replace(/^[/\\]+/, "");
+  if (decoded.length === 0) return null;
+  const segments = decoded.split(/[/\\]+/);
+  if (segments.some((s) => s === ".." || s === ".")) return null;
+  let kind;
+  let writable;
+  if (decoded.startsWith("_tmp/")) {
+    kind = "tmp";
+    writable = false;
+  } else if (decoded.startsWith("_store/")) {
+    kind = "store";
+    writable = false;
+  } else {
+    kind = "usr";
+    writable = true;
+  }
+  if (kind === "tmp") {
+    return { kind, writable };
+  }
+  const base = sandboxBase();
+  const joined = _path.join(base, decoded);
+  const normalized = _path.normalize(joined);
+  if (normalized !== base && !normalized.startsWith(base + _path.sep)) return null;
+  return { kind, writable, realPath: normalized };
+}
+
+// src/main/services/simulator-temp-files/disk.ts
+import fs7 from "node:fs/promises";
+import path12 from "node:path";
+var EXT_MIME = {
+  ".txt": "text/plain",
+  ".log": "text/plain",
+  ".md": "text/markdown",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".mp4": "video/mp4",
+  ".m4v": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip"
+};
+function sniffMime(head) {
+  if (head.length >= 8 && head[0] === 137 && head[1] === 80 && head[2] === 78 && head[3] === 71 && head[4] === 13 && head[5] === 10 && head[6] === 26 && head[7] === 10) {
+    return "image/png";
+  }
+  if (head.length >= 3 && head[0] === 255 && head[1] === 216 && head[2] === 255) {
+    return "image/jpeg";
+  }
+  if (head.length >= 6 && head[0] === 71 && head[1] === 73 && head[2] === 70 && head[3] === 56 && (head[4] === 55 || head[4] === 57) && head[5] === 97) {
+    return "image/gif";
+  }
+  if (head.length >= 12 && head[0] === 82 && head[1] === 73 && head[2] === 70 && head[3] === 70 && head[8] === 87 && head[9] === 69 && head[10] === 66 && head[11] === 80) {
+    return "image/webp";
+  }
+  if (head.length >= 12 && head[4] === 102 && head[5] === 116 && head[6] === 121 && head[7] === 112) {
+    return "video/mp4";
+  }
+  if (head.length >= 4 && head[0] === 37 && head[1] === 80 && head[2] === 68 && head[3] === 70) {
+    return "application/pdf";
+  }
+  if (head.length >= 2 && head[0] === 66 && head[1] === 77) {
+    return "image/bmp";
+  }
+  if (head.length >= 4 && head[0] === 80 && head[1] === 75 && head[2] === 3 && head[3] === 4) {
+    return "application/zip";
+  }
+  if (head.length >= 3 && head[0] === 73 && head[1] === 68 && head[2] === 51) {
+    return "audio/mpeg";
+  }
+  if (head.length >= 4 && head[0] === 79 && head[1] === 103 && head[2] === 103 && head[3] === 83) {
+    return "audio/ogg";
+  }
+  return null;
+}
+function extMime(realPath) {
+  const ext = path12.extname(realPath).toLowerCase();
+  if (!ext) return null;
+  return EXT_MIME[ext] ?? null;
+}
+function detectMime(realPath, head) {
+  const sniffed = sniffMime(head);
+  if (sniffed) return sniffed;
+  const byExt = extMime(realPath);
+  if (byExt) return byExt;
+  return "application/octet-stream";
+}
+function etagOf(mtimeMs, size) {
+  return `W/"${Math.floor(mtimeMs)}-${size}"`;
+}
+async function readDiskFile(realPath, opts) {
+  const handle = await fs7.open(realPath, "r");
+  try {
+    const st = await handle.stat();
+    const totalSize = st.size;
+    const mtimeMs = st.mtimeMs;
+    const range = opts?.range;
+    let sliceStart = 0;
+    let sliceLen = totalSize;
+    if (range) {
+      const { start, end } = range;
+      if (!Number.isFinite(start) || !Number.isFinite(end)) {
+        throw new RangeError(`invalid range: ${start}-${end}`);
+      }
+      if (start < 0) throw new RangeError(`range start out of bounds: ${start}`);
+      if (start > end) throw new RangeError(`range start > end: ${start} > ${end}`);
+      if (start >= totalSize) {
+        throw new RangeError(`range start beyond file size: ${start} >= ${totalSize}`);
+      }
+      const clampedEnd = Math.min(end, totalSize - 1);
+      sliceStart = start;
+      sliceLen = clampedEnd - start + 1;
+    }
+    const head = Buffer.alloc(Math.min(12, totalSize));
+    if (head.length > 0) {
+      await handle.read(head, 0, head.length, 0);
+    }
+    let bytes;
+    if (!range) {
+      bytes = Buffer.alloc(totalSize);
+      if (totalSize > 0) {
+        if (totalSize <= head.length) {
+          head.copy(bytes, 0, 0, totalSize);
+        } else {
+          head.copy(bytes, 0, 0, head.length);
+          await handle.read(bytes, head.length, totalSize - head.length, head.length);
+        }
+      }
+    } else {
+      bytes = Buffer.alloc(sliceLen);
+      if (sliceLen > 0) {
+        await handle.read(bytes, 0, sliceLen, sliceStart);
+      }
+    }
+    return {
+      bytes,
+      mime: detectMime(realPath, head),
+      etag: etagOf(mtimeMs, totalSize),
+      totalSize
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function writeDiskFile(realPath, bytes) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
+  await fs7.mkdir(path12.dirname(realPath), { recursive: true });
+  await fs7.writeFile(realPath, buf);
+}
+async function readDiskDir(realPath) {
+  const entries = await fs7.readdir(realPath);
+  return entries;
+}
+async function statDiskFile(realPath) {
+  const st = await fs7.stat(realPath);
+  return {
+    size: st.size,
+    mtime: Math.floor(st.mtimeMs),
+    mode: st.mode,
+    isFile: st.isFile(),
+    isDirectory: st.isDirectory()
+  };
+}
+
+// src/main/services/simulator-temp-files/request-handler.ts
+var CACHE_CONTROL = "public, max-age=31536000, immutable";
+function getHeader(headers, name) {
+  if (!headers) return void 0;
+  const lc = name.toLowerCase();
+  for (const k of Object.keys(headers)) {
+    if (k.toLowerCase() === lc) return headers[k];
+  }
+  return void 0;
+}
+function etagsMatch(a, b) {
+  if (!a) return false;
+  const stripped = (s) => s.startsWith("W/") ? s.slice(2) : s;
+  return stripped(a.trim()) === stripped(b);
+}
+function parseRange(header, totalSize) {
+  if (!header) return null;
+  const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+  if (!m) return null;
+  const startStr = m[1];
+  const endStr = m[2];
+  if (startStr === "" && endStr === "") return null;
+  if (startStr === "") {
+    const n = Number(endStr);
+    if (!Number.isFinite(n) || n <= 0) return null;
+    const start2 = Math.max(0, totalSize - n);
+    return { start: start2, end: totalSize - 1 };
+  }
+  const start = Number(startStr);
+  if (!Number.isFinite(start) || start < 0) return null;
+  const end = endStr === "" ? totalSize - 1 : Number(endStr);
+  if (!Number.isFinite(end)) return null;
+  return { start, end };
+}
+function notFound() {
+  return new Response(null, { status: 404 });
+}
+function notModified(etag) {
+  return new Response(null, {
+    status: 304,
+    headers: {
+      ETag: etag,
+      "Cache-Control": CACHE_CONTROL,
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function bufferToBody(bytes) {
+  const out = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(out).set(bytes);
+  return out;
+}
+function tempBody(bytes, mime) {
+  return new Response(bufferToBody(bytes), {
+    status: 200,
+    headers: {
+      "Content-Type": mime,
+      "Cache-Control": CACHE_CONTROL,
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+async function handleDifileRequest(ctx, req) {
+  const v = resolveVPath(req.url);
+  if (!v) return notFound();
+  if (v.kind === "tmp") {
+    const record = ctx.tempStore.get(req.url);
+    if (!record) return notFound();
+    return tempBody(record.bytes, record.mime || "application/octet-stream");
+  }
+  if (!v.realPath) return notFound();
+  try {
+    const probe = await readDiskFile(v.realPath);
+    const etag = probe.etag;
+    const totalSize = probe.totalSize;
+    const mime = probe.mime;
+    const ifNoneMatch = getHeader(req.headers, "If-None-Match");
+    if (etagsMatch(ifNoneMatch, etag)) {
+      return notModified(etag);
+    }
+    const rangeHeader = getHeader(req.headers, "Range");
+    const range = parseRange(rangeHeader, totalSize);
+    if (range) {
+      if (range.start < 0 || range.start >= totalSize || range.end < range.start) {
+        return new Response(null, {
+          status: 416,
+          headers: {
+            "Content-Range": `bytes */${totalSize}`,
+            "Access-Control-Allow-Origin": "*"
+          }
+        });
+      }
+      const clampedEnd = Math.min(range.end, totalSize - 1);
+      const sliced = await readDiskFile(v.realPath, { range: { start: range.start, end: clampedEnd } });
+      const { bytes } = sliced;
+      const lastByte = range.start + bytes.length - 1;
+      return new Response(bufferToBody(bytes), {
+        status: 206,
+        headers: {
+          "Content-Type": mime,
+          "Content-Length": String(bytes.length),
+          "Content-Range": `bytes ${range.start}-${lastByte}/${totalSize}`,
+          "Cache-Control": CACHE_CONTROL,
+          ETag: etag,
+          "Access-Control-Allow-Origin": "*"
+        }
+      });
+    }
+    return new Response(bufferToBody(probe.bytes), {
+      status: 200,
+      headers: {
+        "Content-Type": mime,
+        "Cache-Control": CACHE_CONTROL,
+        ETag: etag,
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  } catch {
+    return notFound();
+  }
+}
+
+// src/main/services/simulator-temp-files/fs-channels.ts
+import fs8 from "node:fs/promises";
+import path13 from "node:path";
+async function enforceSandbox(realPath) {
+  if (typeof realPath !== "string" || realPath.length === 0) {
+    throw new Error("sandbox: realPath must be a non-empty string");
+  }
+  const base = sandboxBase();
+  const baseReal = await fs8.realpath(base).catch(() => base);
+  const normalized = path13.normalize(realPath);
+  if (normalized !== base && !normalized.startsWith(base + path13.sep)) {
+    throw new Error("sandbox: realPath escapes the user-data base");
+  }
+  let probe = normalized;
+  while (probe !== path13.parse(probe).root) {
+    try {
+      const resolved = await fs8.realpath(probe);
+      if (resolved !== baseReal && !resolved.startsWith(baseReal + path13.sep)) {
+        throw new Error("sandbox: realPath escapes the user-data base via symlink");
+      }
+      break;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        probe = path13.dirname(probe);
+        continue;
+      }
+      throw err;
+    }
+  }
+  return normalized;
+}
+async function handleFsRead(req) {
+  const safe = await enforceSandbox(req.realPath);
+  const result = await readDiskFile(safe, req.range ? { range: req.range } : void 0);
+  return {
+    bytes: result.bytes,
+    mime: result.mime,
+    etag: result.etag,
+    totalSize: result.totalSize
+  };
+}
+async function handleFsWrite(req) {
+  const safe = await enforceSandbox(req.realPath);
+  await writeDiskFile(safe, req.bytes);
+  return { ok: true };
+}
+async function handleFsStat(req) {
+  const safe = await enforceSandbox(req.realPath);
+  return statDiskFile(safe);
+}
+async function handleFsReaddir(req) {
+  const safe = await enforceSandbox(req.realPath);
+  return readDiskDir(safe);
+}
+async function handleFsUnlink(req) {
+  const safe = await enforceSandbox(req.realPath);
+  await fs8.unlink(safe);
+  return { ok: true };
+}
+async function handleFsMkdir(req) {
+  const safe = await enforceSandbox(req.realPath);
+  await fs8.mkdir(safe, { recursive: !!req.recursive });
+  return { ok: true };
+}
+
+// src/main/services/simulator-temp-files/index.ts
+var MAX_STORE_ENTRIES = 200;
+var PENDING_TIMEOUT_MS = 500;
+function enforceStoreCap(store) {
+  while (store.size > MAX_STORE_ENTRIES) {
+    const next = store.keys().next();
+    if (next.done) break;
+    store.delete(next.value);
+  }
+}
+function setupSimulatorTempFiles(simSession) {
+  const store = /* @__PURE__ */ new Map();
+  const pendingWaiters = /* @__PURE__ */ new Map();
+  let disposed = false;
+  function drainWaiters(path16) {
+    const list = pendingWaiters.get(path16);
+    if (!list) return;
+    pendingWaiters.delete(path16);
+    for (const fn of list) fn();
+  }
+  function drainAllWaiters() {
+    const lists = Array.from(pendingWaiters.values());
+    pendingWaiters.clear();
+    for (const list of lists) for (const fn of list) fn();
+  }
+  const simulatorOnlyPolicy = (sender) => !sender.isDestroyed() && sender.session === simSession;
+  const registry = new IpcRegistry(simulatorOnlyPolicy);
+  registry.on("simulator:temp-file:write", (_event, payload) => {
+    if (disposed) return;
+    const { path: path16, mime, bytes } = payload;
+    registerTempFile(store, path16, mime, bytes);
+    enforceStoreCap(store);
+    drainWaiters(path16);
+  });
+  registry.on("simulator:temp-file:revoke", (_event, payload) => {
+    if (disposed) return;
+    const { path: path16 } = payload;
+    revokeTempFile(store, path16);
+  });
+  registry.on("simulator:temp-file:revoke-all", () => {
+    if (disposed) return;
+    revokeAllTempFiles(store);
+  });
+  try {
+    simSession.protocol.unhandle("difile");
+  } catch {
+  }
+  simSession.protocol.handle("difile", async (req) => {
+    const url = req.url;
+    const headers = {};
+    try {
+      req.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+    } catch {
+    }
+    const ctx = { tempStore: store };
+    let res = await handleDifileRequest(ctx, { url, headers });
+    if (res.status === 404 && !disposed && url.startsWith("difile://_tmp/")) {
+      await new Promise((resolve) => {
+        let timer = null;
+        const notify = () => {
+          if (timer) clearTimeout(timer);
+          resolve();
+        };
+        const list = pendingWaiters.get(url) ?? /* @__PURE__ */ new Set();
+        list.add(notify);
+        pendingWaiters.set(url, list);
+        timer = setTimeout(() => {
+          const cur = pendingWaiters.get(url);
+          if (cur) {
+            cur.delete(notify);
+            if (cur.size === 0) pendingWaiters.delete(url);
+          }
+          resolve();
+        }, PENDING_TIMEOUT_MS);
+      });
+      res = await handleDifileRequest(ctx, { url, headers });
+    }
+    return res;
+  });
+  registry.handle(
+    "simulator:fs:read",
+    (_event, payload) => handleFsRead(payload)
+  );
+  registry.handle(
+    "simulator:fs:write",
+    (_event, payload) => handleFsWrite(payload)
+  );
+  registry.handle(
+    "simulator:fs:stat",
+    (_event, payload) => handleFsStat(payload)
+  );
+  registry.handle(
+    "simulator:fs:readdir",
+    (_event, payload) => handleFsReaddir(payload)
+  );
+  registry.handle(
+    "simulator:fs:unlink",
+    (_event, payload) => handleFsUnlink(payload)
+  );
+  registry.handle(
+    "simulator:fs:mkdir",
+    (_event, payload) => handleFsMkdir(payload)
+  );
+  return toDisposable(async () => {
+    disposed = true;
+    drainAllWaiters();
+    store.clear();
+    try {
+      simSession.protocol.unhandle("difile");
+    } catch {
+    }
+    await registry.dispose();
+  });
+}
+
 // src/main/services/update/update-manager.ts
 import { app as app11, shell as shell3 } from "electron";
 var UpdateManager = class {
@@ -3690,7 +4237,7 @@ async function disposeContext(ctx) {
 function createConfiguredMainWindow(config, rendererDir2) {
   const mainWindow = createMainWindow({
     title: config.appName ?? "Dimina DevTools",
-    indexHtml: path12.join(rendererDir2, "entries/main/index.html"),
+    indexHtml: path14.join(rendererDir2, "entries/main/index.html"),
     width: config.window?.width,
     height: config.window?.height,
     minWidth: config.window?.minWidth,
@@ -3788,7 +4335,7 @@ function enableDevRendererAutoReload(rendererDir2) {
     });
   }
   let reloadTimer = null;
-  const watcher = fs7.watch(rendererDir2, { recursive: true }, () => {
+  const watcher = fs9.watch(rendererDir2, { recursive: true }, () => {
     if (reloadTimer) clearTimeout(reloadTimer);
     reloadTimer = setTimeout(() => {
       for (const win of BrowserWindow4.getAllWindows()) {
@@ -3808,6 +4355,7 @@ function createWorkbenchApp(config = {}) {
   let setupPromise = null;
   let appEventsRegistered = false;
   setupCdpPort();
+  registerDifileScheme();
   async function setup() {
     if (setupPromise) return setupPromise;
     setupPromise = app13.whenReady().then(async () => {
@@ -3818,6 +4366,8 @@ function createWorkbenchApp(config = {}) {
       context.registry.add(registerAppIpc(context));
       context.registry.add(installThemeBackgroundSync());
       registerBuiltinModules(config, context);
+      const simSession = session2.fromPartition("persist:simulator");
+      context.registry.add(setupSimulatorTempFiles(simSession));
       installMenu(config, mainWindow, context);
       const hostIpc = new IpcRegistry(context.senderPolicy);
       context.registry.add(hostIpc);
@@ -3864,8 +4414,8 @@ function createWorkbenchApp(config = {}) {
         // prefixes; this callback lets the storage panel filter the CDP
         // snapshot/event stream to the active appId.
         getActiveAppId: () => {
-          const session2 = context.workspace.getSession();
-          const appInfo = session2?.appInfo;
+          const session3 = context.workspace.getSession();
+          const appInfo = session3?.appInfo;
           return appInfo?.appId ?? null;
         }
       }));
@@ -3890,7 +4440,7 @@ function createWorkbenchApp(config = {}) {
 
 // src/main/windows/settings-window/create.ts
 import { BrowserWindow as BrowserWindow5 } from "electron";
-import path13 from "path";
+import path15 from "path";
 async function createSettingsWindow(parent, rendererDir2) {
   const win = new BrowserWindow5({
     width: 420,
@@ -3908,7 +4458,7 @@ async function createSettingsWindow(parent, rendererDir2) {
     }
   });
   applyNavigationHardening(win.webContents, rendererDir2);
-  await win.loadFile(path13.join(rendererDir2, "entries/workbench-settings/index.html"));
+  await win.loadFile(path15.join(rendererDir2, "entries/workbench-settings/index.html"));
   return win;
 }