@eclipse-lyra/core 0.0.0

package/dist/standard-layout-BSGa06lP.js

@@ -0,0 +1,4907 @@
+import { l as rootContext, h as contributionRegistry, b as TOPIC_CONTRIBUTEIONS_CHANGED, w as watchSignal, p as partDirtySignal, d as activePartSignal, c as activeEditorSignal, i as createLogger, e as activeSelectionSignal, f as activeTasksSignal, t as toastError, m as toastInfo, o as registerLogHandler, q as unregisterLogHandler, L as LyraWidget, r as registerAll, u as uiContext, n as toastWarning } from "./icon-DN6fp0dg.js";
+import { html, css, nothing, render } from "lit";
+import { n as appSettings, l as TOPIC_SETTINGS_CHANGED, t as persistenceService, E as EDITOR_AREA_MAIN, c as LyraPart, q as extensionRegistry, H as HIDE_DOT_RESOURCE, o as confirmDialog, g as TOOLBAR_BOTTOM_CENTER, v as taskService, b as LyraElement, w as TOPIC_EXTENSIONS_CHANGED, m as appLoaderService, u as promptDialog, p as esmShService, D as DIALOG_CONTRIBUTION_TARGET, x as CLOSE_BUTTON, y as dialogService, d as SIDEBAR_MAIN, h as TOOLBAR_BOTTOM_END, k as TOOLBAR_MAIN_RIGHT, f as SYSTEM_VIEWS, z as constants, L as LyraContainer, i as TOOLBAR_MAIN, j as TOOLBAR_MAIN_CENTER, T as TOOLBAR_BOTTOM, e as SIDEBAR_MAIN_BOTTOM, P as PANEL_BOTTOM, S as SIDEBAR_AUXILIARY } from "./resizable-grid-BRH3MyZK.js";
+import { signal } from "@lit-labs/signals";
+import { subscribe, publish } from "./core/events.js";
+import "./externals/webawesome.js";
+import { state, customElement, property } from "lit/decorators.js";
+import { when } from "lit/directives/when.js";
+import { createRef, ref } from "lit/directives/ref.js";
+import "./nocontent-BhrN6yxJ.js";
+import { unsafeHTML } from "lit/directives/unsafe-html.js";
+import { marked } from "marked";
+class PackageInfoService {
+  constructor() {
+    this.packages = [];
+  }
+  addPackage(packageInfo) {
+    this.packages.push(packageInfo);
+  }
+  hasPackages() {
+    return this.packages.length > 0 && this.packages.some(
+      (pkg) => pkg.dependencies && Object.keys(pkg.dependencies).length > 0
+    );
+  }
+  renderTree() {
+    if (this.packages.length === 0) {
+      return html``;
+    }
+    return html`
+            <wa-tree style="--indent-guide-width: 1px;">
+                ${this.packages.map((pkg) => {
+      const deps = pkg.dependencies || {};
+      const depEntries = Object.entries(deps);
+      if (depEntries.length === 0) {
+        return html``;
+      }
+      return html`
+                        <wa-tree-item expanded>
+                            <span>${pkg.name}</span>
+                            ${depEntries.map(([name, version]) => html`
+                                <wa-tree-item>
+                                    <span>${name} <small>${version}</small></span>
+                                </wa-tree-item>
+                            `)}
+                        </wa-tree-item>
+                    `;
+    })}
+            </wa-tree>
+        `;
+  }
+}
+const packageInfoService = new PackageInfoService();
+rootContext.put("packageInfoService", packageInfoService);
+const SYSTEM_LANGUAGE_BUNDLES = "system.language_bundles";
+const SETTINGS_KEY_LANGUAGE = "language";
+function replaceParameters(text, params) {
+  if (!params) {
+    return text;
+  }
+  return text.replace(/\{(\w+)\}/g, (match, paramKey) => {
+    return params[paramKey] !== void 0 ? params[paramKey] : match;
+  });
+}
+class LazyTranslation extends String {
+  constructor(i18nService2, namespace2, key, params) {
+    super("");
+    this.i18nService = i18nService2;
+    this.namespace = namespace2;
+    this.key = key;
+    this.params = params;
+  }
+  toString() {
+    const currentLanguage = this.i18nService.currentLanguageSignal.get();
+    if (this.cachedValue !== void 0 && this.cachedLanguage === currentLanguage) {
+      return this.cachedValue;
+    }
+    this.cachedValue = this.i18nService.translate(this.namespace, this.key, this.params);
+    this.cachedLanguage = currentLanguage;
+    return this.cachedValue;
+  }
+  valueOf() {
+    return this.toString();
+  }
+  [Symbol.toPrimitive](hint) {
+    if (hint === "number") {
+      const num = Number(this.toString());
+      return isNaN(num) ? 0 : num;
+    }
+    return this.toString();
+  }
+  toJSON() {
+    return this.toString();
+  }
+}
+const _I18nService = class _I18nService {
+  constructor() {
+    this.translationCache = /* @__PURE__ */ new Map();
+    this.currentLanguageSignal = signal(this.getBrowserLanguage());
+    this.languageContributionsSignal = signal([]);
+    this.initialize();
+  }
+  getBrowserLanguage() {
+    const browserLanguage = navigator.language || navigator.languages?.[0] || _I18nService.DEFAULT_LANGUAGE;
+    return browserLanguage.split("-")[0].toLowerCase();
+  }
+  async initializeLanguage() {
+    const settingsLanguage = await appSettings.get(SETTINGS_KEY_LANGUAGE);
+    return settingsLanguage || this.getBrowserLanguage();
+  }
+  async updateLanguageFromSettings() {
+    const language = await this.initializeLanguage();
+    this.currentLanguageSignal.set(language);
+  }
+  getPrimaryLanguage(language) {
+    return language.split("-")[0].toLowerCase();
+  }
+  updateLanguageContributions() {
+    const contributions = contributionRegistry.getContributions(SYSTEM_LANGUAGE_BUNDLES);
+    this.languageContributionsSignal.set(contributions);
+  }
+  createCacheKey(namespace2, language) {
+    return `${namespace2}:${language}`;
+  }
+  mergeTranslationsForLanguage(contributions, namespace2, language) {
+    const cacheKey = this.createCacheKey(namespace2, language);
+    const cached = this.translationCache.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const merged = {};
+    for (const contribution of contributions) {
+      if (contribution.namespace !== namespace2) {
+        continue;
+      }
+      let translations;
+      if (contribution.translations && contribution.language === language) {
+        translations = contribution.translations;
+      } else if (contribution[language] && typeof contribution[language] === "object") {
+        translations = contribution[language];
+      }
+      if (translations) {
+        Object.assign(merged, translations);
+      }
+    }
+    this.translationCache.set(cacheKey, merged);
+    return merged;
+  }
+  invalidateTranslationCache() {
+    this.translationCache.clear();
+  }
+  translate(namespace2, key, params) {
+    const currentLanguage = this.currentLanguageSignal.get();
+    const primaryLanguage = this.getPrimaryLanguage(currentLanguage);
+    const contributions = this.languageContributionsSignal.get();
+    let translation;
+    const currentLangTranslations = this.mergeTranslationsForLanguage(contributions, namespace2, currentLanguage);
+    if (currentLangTranslations[key]) {
+      translation = currentLangTranslations[key];
+    } else {
+      const primaryLangTranslations = currentLanguage !== primaryLanguage ? this.mergeTranslationsForLanguage(contributions, namespace2, primaryLanguage) : currentLangTranslations;
+      if (primaryLangTranslations[key]) {
+        translation = primaryLangTranslations[key];
+      } else if (primaryLanguage !== _I18nService.DEFAULT_LANGUAGE && currentLanguage !== _I18nService.DEFAULT_LANGUAGE) {
+        const defaultLangTranslations = this.mergeTranslationsForLanguage(contributions, namespace2, _I18nService.DEFAULT_LANGUAGE);
+        if (defaultLangTranslations[key]) {
+          translation = defaultLangTranslations[key];
+        }
+      }
+    }
+    if (!translation) {
+      return key;
+    }
+    return replaceParameters(translation, params);
+  }
+  initialize() {
+    subscribe(TOPIC_SETTINGS_CHANGED, async (settings) => {
+      const language = settings?.[SETTINGS_KEY_LANGUAGE] || this.getBrowserLanguage();
+      this.currentLanguageSignal.set(language);
+      this.invalidateTranslationCache();
+    });
+    subscribe(TOPIC_CONTRIBUTEIONS_CHANGED, (event) => {
+      if (event.target === SYSTEM_LANGUAGE_BUNDLES) {
+        this.invalidateTranslationCache();
+        this.updateLanguageContributions();
+      }
+    });
+    this.updateLanguageFromSettings();
+    this.updateLanguageContributions();
+  }
+  i18n(namespace2) {
+    return (key, params) => {
+      return this.translate(namespace2, key, params);
+    };
+  }
+  i18nLazy(namespace2) {
+    return (key, params) => {
+      return new LazyTranslation(this, namespace2, key, params);
+    };
+  }
+};
+_I18nService.DEFAULT_LANGUAGE = "en";
+let I18nService = _I18nService;
+const i18nService = new I18nService();
+rootContext.put("i18nService", i18nService);
+const currentLanguageSignal = i18nService.currentLanguageSignal;
+const languageContributionsSignal = i18nService.languageContributionsSignal;
+const i18n = (namespace2) => i18nService.i18n(namespace2);
+const i18nLazy = (namespace2) => i18nService.i18nLazy(namespace2);
+const TOPIC_WORKSPACE_CHANGED = "events/filesys/workspaceChanged";
+const TOPIC_WORKSPACE_CONNECTED = "events/filesys/workspaceConnected";
+class Resource {
+  constructor() {
+    this.state = {};
+  }
+  getWorkspacePath() {
+    const paths = [];
+    let current = this;
+    let root;
+    while (current) {
+      paths.push(current.getName());
+      const parent = current.getParent();
+      if (!parent) root = current;
+      current = parent;
+    }
+    paths.reverse();
+    const workspace = typeof workspaceService?.getWorkspaceSync === "function" ? workspaceService.getWorkspaceSync() : void 0;
+    if (workspace && root && "isDirectChild" in workspace && typeof workspace.isDirectChild === "function" && workspace.isDirectChild(root)) {
+      const folderName = workspace.getFolderNameForDirectory(root);
+      if (folderName && paths.length > 0) return paths.length > 1 ? folderName + "/" + paths.slice(1).join("/") : folderName;
+    }
+    paths.shift();
+    return paths.join("/");
+  }
+  getWorkspace() {
+    let current = this;
+    while (current) {
+      const parent = current.getParent();
+      if (parent) {
+        current = parent;
+      } else {
+        break;
+      }
+    }
+    return current;
+  }
+}
+var FileContentType = /* @__PURE__ */ ((FileContentType2) => {
+  FileContentType2[FileContentType2["TEXT"] = 0] = "TEXT";
+  FileContentType2[FileContentType2["BINARY"] = 1] = "BINARY";
+  return FileContentType2;
+})(FileContentType || {});
+var FileContentEncoding = /* @__PURE__ */ ((FileContentEncoding2) => {
+  FileContentEncoding2[FileContentEncoding2["BASE64"] = 0] = "BASE64";
+  return FileContentEncoding2;
+})(FileContentEncoding || {});
+class File extends Resource {
+}
+class Directory extends Resource {
+}
+class StringFile extends File {
+  constructor(contents, name) {
+    super();
+    this.contents = contents;
+    this.name = name;
+  }
+  async getContents(_options) {
+    return this.contents;
+  }
+  async saveContents(contents, _options) {
+    this.contents = contents;
+  }
+  async size() {
+    return this.contents.length || null;
+  }
+  async copyTo(_targetPath) {
+    throw Error(`Not supported`);
+  }
+  delete(_name, _recursive) {
+    throw Error(`Not supported`);
+  }
+  async rename(_newName) {
+    throw Error(`Not supported`);
+  }
+  getName() {
+    return this.name;
+  }
+  getParent() {
+    return void 0;
+  }
+}
+class CompositeDirectory extends Directory {
+  constructor(directories, displayName = "/") {
+    super();
+    this.displayName = displayName;
+    this.entriesByName = new Map(directories.map((d) => [d.getName(), d]));
+  }
+  getFolderNameForDirectory(dir) {
+    for (const [name, d] of this.entriesByName) {
+      if (d === dir) return name;
+    }
+    return void 0;
+  }
+  isDirectChild(dir) {
+    return this.getFolderNameForDirectory(dir) !== void 0;
+  }
+  getName() {
+    return this.displayName;
+  }
+  getParent() {
+    return void 0;
+  }
+  async listChildren(_forceRefresh) {
+    return Array.from(this.entriesByName.values());
+  }
+  async getResource(path, options) {
+    if (!path || !path.trim()) {
+      return null;
+    }
+    const idx = path.indexOf("/");
+    const folderName = idx >= 0 ? path.slice(0, idx).trim() : path.trim();
+    const rest = idx >= 0 ? path.slice(idx + 1).trim() : "";
+    const dir = this.entriesByName.get(folderName);
+    if (!dir) {
+      return null;
+    }
+    if (!rest) {
+      return dir;
+    }
+    return dir.getResource(rest, options);
+  }
+  touch() {
+    for (const dir of this.entriesByName.values()) {
+      dir.touch();
+    }
+  }
+  async delete(_name, _recursive) {
+    throw new Error("Delete not supported on workspace root");
+  }
+  async copyTo(_targetPath) {
+    throw new Error("Copy not supported on workspace root");
+  }
+  async rename(_newName) {
+    throw new Error("Rename not supported on workspace root");
+  }
+  getFolderByName(name) {
+    return this.entriesByName.get(name);
+  }
+}
+const LEGACY_WORKSPACE_KEY = "workspace_data";
+const _WorkspaceService = class _WorkspaceService {
+  constructor() {
+    this._currentWorkspace = void 0;
+    this.folders = [];
+    this.contributions = /* @__PURE__ */ new Map();
+    let resolveInit;
+    this.initPromise = new Promise((resolve) => {
+      resolveInit = resolve;
+    });
+    this.loadPersistedWorkspace(resolveInit);
+  }
+  getWorkspaceSync() {
+    return this._currentWorkspace;
+  }
+  registerContribution(contribution) {
+    this.contributions.set(contribution.type, contribution);
+    console.log(`Workspace contribution registered: ${contribution.name} (${contribution.type})`);
+  }
+  getContributions() {
+    return Array.from(this.contributions.values());
+  }
+  async loadPersistedWorkspace(resolveInit) {
+    try {
+      const raw = await persistenceService.getObject(LEGACY_WORKSPACE_KEY);
+      if (!raw) {
+        this.workspace = Promise.resolve(void 0);
+        this._currentWorkspace = void 0;
+      }
+      if (raw?.folders && Array.isArray(raw.folders) && raw.folders.length > 0) {
+        const normalized = raw.folders.map((f) => ({ type: f.type, data: f.data }));
+        await this.resolveFolders(normalized);
+        const composite = this.buildComposite();
+        this.workspace = Promise.resolve(composite);
+        this._currentWorkspace = composite ?? void 0;
+        if (composite) {
+          publish(TOPIC_WORKSPACE_CONNECTED, composite);
+        }
+        resolveInit();
+        return;
+      }
+      if (raw && raw.type && raw.data !== void 0) {
+        const contribution = this.contributions.get(raw.type);
+        if (contribution?.restore) {
+          try {
+            const dir = await contribution.restore(raw.data);
+            if (dir) {
+              this.folders = [{ type: raw.type, data: raw.data, directory: dir }];
+              const comp = this.buildComposite();
+              this.workspace = Promise.resolve(comp);
+              this._currentWorkspace = comp ?? void 0;
+              this.currentType = raw.type;
+              await this.persistFolders();
+              publish(TOPIC_WORKSPACE_CONNECTED, comp);
+            }
+          } catch (error) {
+            console.error("Failed to restore legacy workspace:", error);
+          }
+        }
+      }
+      if (!this.workspace) {
+        this.workspace = Promise.resolve(void 0);
+        this._currentWorkspace = void 0;
+      }
+      resolveInit();
+    } finally {
+      if (this.folders.length === 0) {
+        try {
+          await this.connectFolder({ indexeddb: true, name: _WorkspaceService.DEFAULT_INDEXEDDB_FOLDER_NAME });
+        } catch (e) {
+          console.warn("Failed to connect default IndexedDB folder", e);
+        }
+      }
+    }
+  }
+  async resolveFolders(persisted) {
+    this.folders = [];
+    for (const folder of persisted) {
+      const contribution = this.contributions.get(folder.type);
+      if (!contribution?.restore) {
+        continue;
+      }
+      try {
+        const dir = await contribution.restore(folder.data);
+        if (dir) {
+          this.folders.push({ type: folder.type, data: folder.data, directory: dir });
+        }
+      } catch (error) {
+        console.warn(`Failed to restore folder (${folder.type}):`, error);
+      }
+    }
+  }
+  buildComposite() {
+    if (this.folders.length === 0) {
+      return void 0;
+    }
+    return new CompositeDirectory(this.folders.map((f) => f.directory));
+  }
+  async persistFolders() {
+    const toPersist = this.folders.length > 0 ? { folders: this.folders.map((f) => ({ type: f.type, data: f.data })) } : null;
+    await persistenceService.persistObject(LEGACY_WORKSPACE_KEY, toPersist);
+    await persistenceService.persistObject("workspace", null);
+  }
+  async getFolders() {
+    await this.initPromise;
+    return this.folders.map((f) => ({ name: f.directory.getName(), type: f.type }));
+  }
+  async getFolderInfoForDirectory(directory) {
+    await this.initPromise;
+    const folder = this.folders.find((f) => f.directory === directory);
+    if (!folder) {
+      return void 0;
+    }
+    const name = folder.data && typeof folder.data === "object" && folder.data.name || folder.directory.getName();
+    const contribution = this.contributions.get(folder.type);
+    const backendName = contribution?.name ?? folder.type;
+    return { name, type: folder.type, backendName };
+  }
+  /**
+   * Update persisted metadata for a workspace root directory.
+   * Currently used to keep display names of roots (e.g. IndexedDB) in sync
+   * with their in-memory Directory instances.
+   */
+  async updateFolderName(directory, name) {
+    await this.initPromise;
+    const folder = this.folders.find((f) => f.directory === directory);
+    if (!folder) {
+      return;
+    }
+    if (folder.data && typeof folder.data === "object") {
+      folder.data = { ...folder.data, name };
+    } else {
+      folder.data = { name };
+    }
+    await this.persistFolders();
+    const composite = this.buildComposite();
+    this.workspace = Promise.resolve(composite);
+    this._currentWorkspace = composite ?? void 0;
+    publish(TOPIC_WORKSPACE_CONNECTED, composite);
+  }
+  async connectFolder(input) {
+    await this.initPromise;
+    const contribution = Array.from(this.contributions.values()).find((c) => c.canHandle(input));
+    if (!contribution) {
+      throw new Error("No workspace contribution can handle this input");
+    }
+    const directory = await contribution.connect(input);
+    const data = contribution.persist ? await contribution.persist(directory) : input;
+    this.folders.push({ type: contribution.type, data, directory });
+    await this.persistFolders();
+    this.currentType = this.folders.length === 1 ? contribution.type : void 0;
+    const composite = this.buildComposite();
+    this.workspace = Promise.resolve(composite);
+    this._currentWorkspace = composite;
+    publish(TOPIC_WORKSPACE_CONNECTED, composite);
+    return composite;
+  }
+  async disconnectFolder(directory) {
+    await this.initPromise;
+    const idx = this.folders.findIndex((f) => f.directory === directory);
+    if (idx < 0) {
+      return;
+    }
+    this.folders.splice(idx, 1);
+    await this.persistFolders();
+    if (this.folders.length > 0) {
+      this.currentType = this.folders[0].type;
+    } else {
+      this.currentType = void 0;
+    }
+    const composite = this.buildComposite();
+    this.workspace = Promise.resolve(composite);
+    this._currentWorkspace = composite ?? void 0;
+    publish(TOPIC_WORKSPACE_CONNECTED, composite);
+  }
+  async connectWorkspace(input) {
+    return this.connectFolder(input);
+  }
+  async getWorkspace() {
+    await this.initPromise;
+    if (!this.workspace) {
+      throw new Error("No workspace connected.");
+    }
+    return await this.workspace;
+  }
+  isConnected() {
+    return this.folders.length > 0;
+  }
+  getWorkspaceType() {
+    return this.currentType;
+  }
+  async disconnectWorkspace() {
+    await this.initPromise;
+    this.workspace = Promise.resolve(void 0);
+    this._currentWorkspace = void 0;
+    this.folders = [];
+    this.currentType = void 0;
+    await this.persistFolders();
+    publish(TOPIC_WORKSPACE_CONNECTED, void 0);
+  }
+};
+_WorkspaceService.DEFAULT_INDEXEDDB_FOLDER_NAME = "My Folder";
+let WorkspaceService = _WorkspaceService;
+const workspaceService = new WorkspaceService();
+rootContext.put("workspaceService", workspaceService);
+class FileSysFileHandleResource extends File {
+  constructor(fileHandle, parent) {
+    super();
+    this.fileHandle = fileHandle;
+    this.parent = parent;
+  }
+  getName() {
+    return this.fileHandle.name;
+  }
+  getParent() {
+    return this.parent;
+  }
+  async delete() {
+    return this.getParent().delete(this.getName());
+  }
+  async getContents(options) {
+    const file = await this.fileHandle.getFile();
+    if (!options || options?.contentType == FileContentType.TEXT) {
+      return await file.text();
+    }
+    if (options?.encoding == FileContentEncoding.BASE64 || options?.uri) {
+      return URL.createObjectURL(file);
+    }
+    if (options?.blob) {
+      return file;
+    }
+    return file.stream();
+  }
+  async size() {
+    try {
+      const file = await this.fileHandle.getFile();
+      return file.size;
+    } catch {
+      return null;
+    }
+  }
+  async saveContents(contents, _options) {
+    const writable = await this.fileHandle.createWritable();
+    if (contents && typeof contents.pipeTo === "function") {
+      await contents.pipeTo(writable);
+    } else {
+      const writer = writable.getWriter();
+      try {
+        await writer.write(contents);
+      } finally {
+        await writer.close();
+      }
+    }
+  }
+  async copyTo(targetPath) {
+    const contents = await this.getContents({ blob: true });
+    const targetFile = await this.getWorkspace().getResource(targetPath, { create: true });
+    await targetFile.saveContents(contents);
+  }
+  async rename(newName) {
+    const parent = this.getParent();
+    if (!parent) {
+      throw new Error("Cannot rename root resource");
+    }
+    if (this.getName() === newName) {
+      return;
+    }
+    if (!("move" in this.fileHandle) || typeof this.fileHandle.move !== "function") {
+      throw new Error("File rename not supported in this browser. Please use a browser with File System Access API move() support.");
+    }
+    try {
+      await this.fileHandle.move(newName);
+    } catch (error) {
+      if (error.name === "NotAllowedError" || error.message?.includes("not allowed") || error.message?.includes("user agent")) {
+        throw new Error("File rename failed: The operation took too long and user activation expired. Please try again.");
+      }
+      throw error;
+    }
+    await parent.listChildren(true);
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+}
+class FileSysDirHandleResource extends Directory {
+  constructor(dirHandle, parent) {
+    super();
+    this.dirHandle = dirHandle;
+    this.parent = parent;
+  }
+  getHandle() {
+    return this.dirHandle;
+  }
+  getParent() {
+    return this.parent;
+  }
+  getName() {
+    return this.dirHandle.name;
+  }
+  async listChildren(forceRefresh = false) {
+    if (forceRefresh || !this.files) {
+      if (this.loadingPromise) {
+        return this.loadingPromise;
+      }
+      this.loadingPromise = (async () => {
+        try {
+          const files = {};
+          try {
+            for await (const entry of this.dirHandle.values()) {
+              const isFile = entry.kind === "file";
+              const child = isFile ? new FileSysFileHandleResource(entry, this) : new FileSysDirHandleResource(entry, this);
+              files[child.getName()] = child;
+            }
+          } catch (error) {
+            if (error.name === "NotFoundError") {
+              this.files = {};
+              return [];
+            }
+            throw error;
+          }
+          this.files = files;
+          return Object.values(this.files);
+        } finally {
+          this.loadingPromise = void 0;
+        }
+      })();
+      return this.loadingPromise;
+    }
+    return Object.values(this.files);
+  }
+  async getResource(path, options) {
+    if (!path) {
+      throw new Error("No path provided");
+    }
+    const segments = path.split("/");
+    let currentResource = this;
+    let workspaceChanged = false;
+    try {
+      for (let i = 0; i < segments.length; i++) {
+        let segment = segments[i];
+        if (segment) {
+          segment = segment.trim();
+        }
+        if (!segment) {
+          break;
+        }
+        if (currentResource instanceof FileSysDirHandleResource) {
+          await currentResource.listChildren();
+          if (!currentResource.files) {
+            return null;
+          }
+          const next = currentResource.files[segment];
+          if (!next) {
+            if (options?.create) {
+              workspaceChanged = true;
+              if (i < segments.length - 1) {
+                try {
+                  const newDirHandle = await currentResource.dirHandle.getDirectoryHandle(segment, { create: true });
+                  const nextResource = new FileSysDirHandleResource(newDirHandle, currentResource);
+                  currentResource.files[segment] = nextResource;
+                  currentResource = nextResource;
+                  if (currentResource instanceof FileSysDirHandleResource) {
+                    await currentResource.listChildren();
+                  }
+                  continue;
+                } catch (error) {
+                  if (error.name === "NotFoundError") {
+                    throw new Error(`Directory not found or not accessible: ${segments.slice(0, i + 1).join("/")}`);
+                  }
+                  throw error;
+                }
+              } else {
+                try {
+                  const newFileHandle = await currentResource.dirHandle.getFileHandle(segment, { create: true });
+                  const nextResource = new FileSysFileHandleResource(newFileHandle, currentResource);
+                  currentResource.files[segment] = nextResource;
+                  return nextResource;
+                } catch (error) {
+                  if (error.name === "NotFoundError") {
+                    throw new Error(`File not found or not accessible: ${segments.join("/")}`);
+                  }
+                  throw error;
+                }
+              }
+            } else {
+              return null;
+            }
+          } else {
+            currentResource = next;
+          }
+        }
+      }
+    } finally {
+      if (workspaceChanged) {
+        publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+      }
+    }
+    return currentResource;
+  }
+  touch() {
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+  async delete(name, recursive = true) {
+    if (!name) {
+      const parent = this.getParent();
+      if (parent instanceof FileSysDirHandleResource) {
+        await parent.listChildren();
+        if (parent.files) {
+          delete parent.files[this.getName()];
+        }
+      }
+      this.files = void 0;
+      this.loadingPromise = void 0;
+      return parent?.delete(this.getName());
+    }
+    return this.dirHandle.removeEntry(name, {
+      recursive
+    }).then(async () => {
+      if (this.files) {
+        delete this.files[name];
+      }
+      publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+    });
+  }
+  async copyTo(targetPath) {
+    for (const resource of await this.listChildren()) {
+      const targetResourceName = [targetPath, resource.getName()].join("/");
+      await resource.copyTo(targetResourceName);
+    }
+  }
+  async rename(newName) {
+    const parent = this.getParent();
+    if (!parent) {
+      throw new Error("Cannot rename workspace root");
+    }
+    if (this.getName() === newName) {
+      return;
+    }
+    if (!("move" in this.dirHandle) || typeof this.dirHandle.move !== "function") {
+      throw new Error("Directory rename not supported in this browser. Please use a browser with File System Access API move() support.");
+    }
+    try {
+      await this.dirHandle.move(newName);
+    } catch (error) {
+      if (error.name === "NotAllowedError" || error.message?.includes("not allowed") || error.message?.includes("user agent")) {
+        throw new Error("Directory rename failed: The operation took too long and user activation expired. Please try again.");
+      }
+      throw error;
+    }
+    await parent.listChildren(true);
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+}
+workspaceService.registerContribution({
+  type: "filesystem",
+  name: "fs",
+  canHandle(input) {
+    return input && "kind" in input && input.kind === "directory";
+  },
+  async connect(input) {
+    return new FileSysDirHandleResource(input);
+  },
+  async restore(data) {
+    if (data && "kind" in data && data.kind === "directory") {
+      return new FileSysDirHandleResource(data, void 0);
+    }
+    return void 0;
+  },
+  async persist(workspace) {
+    if (workspace instanceof FileSysDirHandleResource) {
+      return workspace.getHandle();
+    }
+    return null;
+  }
+});
+const fsAccess = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FileSysDirHandleResource,
+  FileSysFileHandleResource
+}, Symbol.toStringTag, { value: "Module" }));
+const OPFS_DISPLAY_NAME = ".opfs";
+async function getOPFSRoot() {
+  if (typeof navigator === "undefined" || !navigator.storage?.getDirectory) {
+    throw new Error("OPFS is not available in this environment");
+  }
+  return await navigator.storage.getDirectory();
+}
+class OPFSRootDirectory extends Directory {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  getName() {
+    return OPFS_DISPLAY_NAME;
+  }
+  getParent() {
+    return this.inner.getParent();
+  }
+  async listChildren(forceRefresh) {
+    return this.inner.listChildren(forceRefresh);
+  }
+  async getResource(path, options) {
+    return this.inner.getResource(path, options);
+  }
+  touch() {
+    this.inner.touch();
+  }
+  async delete(name, recursive) {
+    return this.inner.delete(name, recursive);
+  }
+  async copyTo(targetPath) {
+    return this.inner.copyTo(targetPath);
+  }
+  async rename(newName) {
+    return this.inner.rename(newName);
+  }
+}
+workspaceService.registerContribution({
+  type: "opfs",
+  name: "opfs",
+  canHandle(input) {
+    return input && typeof input === "object" && input.opfs === true;
+  },
+  async connect(_input) {
+    const root = await getOPFSRoot();
+    const fsModule = await Promise.resolve().then(() => fsAccess);
+    const FileSysDirHandleResource2 = fsModule.FileSysDirHandleResource;
+    const inner = new FileSysDirHandleResource2(root);
+    return new OPFSRootDirectory(inner);
+  },
+  async restore(data) {
+    if (data && typeof data === "object" && data.opfs === true) {
+      const root = await getOPFSRoot();
+      const fsModule = await Promise.resolve().then(() => fsAccess);
+      const FileSysDirHandleResource2 = fsModule.FileSysDirHandleResource;
+      const inner = new FileSysDirHandleResource2(root);
+      return new OPFSRootDirectory(inner);
+    }
+    return void 0;
+  },
+  async persist(workspace) {
+    if (workspace instanceof OPFSRootDirectory) {
+      return { opfs: true };
+    }
+    return null;
+  }
+});
+const IDB_WORKSPACE_DB_NAME = "eclipse-lyra-workspace-idb";
+const IDB_WORKSPACE_STORE_NAME = "files";
+let idbWorkspacePromise = null;
+async function getWorkspaceIDB() {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB is not available in this environment");
+  }
+  if (!idbWorkspacePromise) {
+    idbWorkspacePromise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(IDB_WORKSPACE_DB_NAME, 1);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (e) => {
+        const db = e.target.result;
+        if (!db.objectStoreNames.contains(IDB_WORKSPACE_STORE_NAME)) {
+          db.createObjectStore(IDB_WORKSPACE_STORE_NAME);
+        }
+      };
+    });
+  }
+  return idbWorkspacePromise;
+}
+async function getNextIndexedDBName() {
+  const baseName = "IndexedDB";
+  const folders = await workspaceService.getFolders();
+  const existingNames = new Set(
+    folders.filter((f) => f.type === "indexeddb").map((f) => f.name)
+  );
+  if (!existingNames.has(baseName)) {
+    return baseName;
+  }
+  let index = 1;
+  while (existingNames.has(`${baseName} (${index})`)) {
+    index += 1;
+  }
+  return `${baseName} (${index})`;
+}
+function normalizePath(path) {
+  if (!path) return "";
+  return path.split("/").filter(Boolean).join("/");
+}
+function joinPath(base, name) {
+  const cleanBase = normalizePath(base);
+  const cleanName = normalizePath(name);
+  if (!cleanBase) return cleanName;
+  if (!cleanName) return cleanBase;
+  return `${cleanBase}/${cleanName}`;
+}
+function storageKey(rootId, path) {
+  const norm = normalizePath(path);
+  return norm ? `${rootId}/${norm}` : rootId;
+}
+function storagePrefix(rootId, path) {
+  const norm = normalizePath(path);
+  return norm ? `${rootId}/${norm}/` : `${rootId}/`;
+}
+async function idbGet(rootId, path) {
+  const db = await getWorkspaceIDB();
+  const tx = db.transaction(IDB_WORKSPACE_STORE_NAME, "readonly");
+  const store = tx.objectStore(IDB_WORKSPACE_STORE_NAME);
+  const key = path ? storageKey(rootId, path) : rootId;
+  return await new Promise((resolve, reject) => {
+    const req = store.get(key);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbPut(rootId, path, entry) {
+  const db = await getWorkspaceIDB();
+  const tx = db.transaction(IDB_WORKSPACE_STORE_NAME, "readwrite");
+  const store = tx.objectStore(IDB_WORKSPACE_STORE_NAME);
+  const key = path ? storageKey(rootId, path) : rootId;
+  await new Promise((resolve, reject) => {
+    const req = store.put(entry, key);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbDelete(rootId, path) {
+  const db = await getWorkspaceIDB();
+  const tx = db.transaction(IDB_WORKSPACE_STORE_NAME, "readwrite");
+  const store = tx.objectStore(IDB_WORKSPACE_STORE_NAME);
+  const key = path ? storageKey(rootId, path) : rootId;
+  await new Promise((resolve, reject) => {
+    const req = store.delete(key);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbDeleteTree(rootId, rootPath) {
+  const db = await getWorkspaceIDB();
+  const tx = db.transaction(IDB_WORKSPACE_STORE_NAME, "readwrite");
+  const store = tx.objectStore(IDB_WORKSPACE_STORE_NAME);
+  const prefix = storageKey(rootId, rootPath);
+  const prefixWithSlash = prefix + "/";
+  const cursorReq = store.openCursor();
+  await new Promise((resolve, reject) => {
+    cursorReq.onerror = () => reject(cursorReq.error);
+    cursorReq.onsuccess = (ev) => {
+      const cursor = ev.target.result;
+      if (!cursor) {
+        resolve();
+        return;
+      }
+      const key = String(cursor.key);
+      if (key === prefix || key.startsWith(prefixWithSlash)) {
+        cursor.delete();
+      }
+      cursor.continue();
+    };
+  });
+}
+async function idbRenameTree(rootId, oldPath, newPath) {
+  const db = await getWorkspaceIDB();
+  const tx = db.transaction(IDB_WORKSPACE_STORE_NAME, "readwrite");
+  const store = tx.objectStore(IDB_WORKSPACE_STORE_NAME);
+  const oldPrefix = storageKey(rootId, oldPath);
+  const newPrefix = storageKey(rootId, newPath);
+  const cursorReq = store.openCursor();
+  const operations = [];
+  await new Promise((resolve, reject) => {
+    cursorReq.onerror = () => reject(cursorReq.error);
+    cursorReq.onsuccess = (ev) => {
+      const cursor = ev.target.result;
+      if (!cursor) {
+        resolve();
+        return;
+      }
+      const key = String(cursor.key);
+      if (key === oldPrefix || key.startsWith(oldPrefix + "/")) {
+        const suffix = key.slice(oldPrefix.length);
+        const newKey = newPrefix + suffix;
+        const value = cursor.value;
+        operations.push(() => {
+          cursor.delete();
+          store.put(value, newKey);
+        });
+      }
+      cursor.continue();
+    };
+  });
+  for (const op of operations) {
+    op();
+  }
+}
+async function idbListChildrenOfDir(rootId, dirPath) {
+  const db = await getWorkspaceIDB();
+  const tx = db.transaction(IDB_WORKSPACE_STORE_NAME, "readonly");
+  const store = tx.objectStore(IDB_WORKSPACE_STORE_NAME);
+  const prefix = storagePrefix(rootId, dirPath);
+  const cursorReq = store.openCursor();
+  const dirNames = /* @__PURE__ */ new Set();
+  const fileEntries = /* @__PURE__ */ new Map();
+  await new Promise((resolve, reject) => {
+    cursorReq.onerror = () => reject(cursorReq.error);
+    cursorReq.onsuccess = (ev) => {
+      const cursor = ev.target.result;
+      if (!cursor) {
+        resolve();
+        return;
+      }
+      const key = String(cursor.key);
+      const entry = cursor.value;
+      if (!key.startsWith(prefix)) {
+        cursor.continue();
+        return;
+      }
+      const rest = key.slice(prefix.length);
+      if (!rest) {
+        cursor.continue();
+        return;
+      }
+      const idx = rest.indexOf("/");
+      const childName = idx === -1 ? rest : rest.slice(0, idx);
+      if (idx === -1) {
+        if (entry.type === "dir") {
+          dirNames.add(childName);
+        } else {
+          fileEntries.set(childName, entry);
+        }
+      } else {
+        dirNames.add(childName);
+      }
+      cursor.continue();
+    };
+  });
+  const result = [];
+  for (const name of dirNames) {
+    result.push({ name, entry: { type: "dir" }, type: "dir" });
+  }
+  for (const [name, entry] of fileEntries) {
+    if (!dirNames.has(name)) {
+      result.push({ name, entry, type: "file" });
+    }
+  }
+  return result;
+}
+function getRootIdFromParent(parent) {
+  return parent instanceof IDBDirectoryResource ? parent.getRootId() : "";
+}
+class IDBFileResource extends File {
+  constructor(path, parent) {
+    super();
+    this.path = normalizePath(path);
+    this.parent = parent;
+  }
+  getName() {
+    const parts = this.path.split("/");
+    return parts[parts.length - 1] || "";
+  }
+  getParent() {
+    return this.parent;
+  }
+  getRootId() {
+    return getRootIdFromParent(this.parent);
+  }
+  async delete() {
+    await idbDelete(this.getRootId(), this.path);
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+  async getContents(options) {
+    const entry = await idbGet(this.getRootId(), this.path);
+    let raw = entry?.content;
+    if (typeof raw === "string") {
+      const migratedBlob = new Blob([raw], { type: entry?.mimeType || "text/plain" });
+      raw = migratedBlob;
+      if (entry) {
+        entry.content = migratedBlob;
+        await idbPut(this.getRootId(), this.path, entry);
+      }
+    }
+    if (!options || options.contentType === FileContentType.TEXT) {
+      if (!raw) {
+        return "";
+      }
+      return await raw.text();
+    }
+    let blob;
+    if (raw) {
+      blob = raw;
+    } else {
+      blob = new Blob([], { type: entry?.mimeType });
+    }
+    if (options.blob) {
+      return blob;
+    }
+    if (options.uri) {
+      return URL.createObjectURL(blob);
+    }
+    return blob.stream();
+  }
+  async saveContents(contents, _options) {
+    let blob;
+    let mimeType;
+    if (contents instanceof Blob) {
+      blob = contents;
+      mimeType = contents.type || void 0;
+    } else if (typeof contents === "string") {
+      mimeType = "text/plain";
+      blob = new Blob([contents], { type: mimeType });
+    } else {
+      const text = String(contents ?? "");
+      mimeType = "text/plain";
+      blob = new Blob([text], { type: mimeType });
+    }
+    await idbPut(this.getRootId(), this.path, { type: "file", content: blob, mimeType });
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+  async size() {
+    const entry = await idbGet(this.getRootId(), this.path);
+    const content = entry?.content;
+    if (!content) return null;
+    return content.size;
+  }
+  async copyTo(targetPath) {
+    const contents = await this.getContents({ blob: true });
+    const targetFile = await this.getWorkspace().getResource(targetPath, { create: true });
+    if (!targetFile) {
+      throw new Error(`Failed to create target file: ${targetPath}`);
+    }
+    await targetFile.saveContents(contents);
+  }
+  async rename(newName) {
+    if (this.getName() === newName) {
+      return;
+    }
+    const parentDir = this.getParent();
+    const parentPath = parentDir instanceof IDBDirectoryResource ? parentDir.getPath() : "";
+    const newPath = joinPath(parentPath, newName);
+    const rootId = this.getRootId();
+    const entry = await idbGet(rootId, this.path);
+    if (!entry) {
+      throw new Error("File not found in IndexedDB");
+    }
+    await idbDelete(rootId, this.path);
+    await idbPut(rootId, newPath, entry);
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+}
+class IDBDirectoryResource extends Directory {
+  constructor(path, parent) {
+    super();
+    this.path = normalizePath(path);
+    this.parent = parent;
+  }
+  getPath() {
+    return this.path;
+  }
+  getName() {
+    if (!this.path) {
+      return "";
+    }
+    const parts = this.path.split("/");
+    return parts[parts.length - 1];
+  }
+  getParent() {
+    return this.parent;
+  }
+  getRoot() {
+    const p = this.getParent();
+    if (!p) return this;
+    return p.getRoot();
+  }
+  getRootId() {
+    const r = this.getRoot();
+    return r instanceof IDBRootDirectory ? r.getRootId() : "";
+  }
+  async listChildren(_forceRefresh) {
+    const childrenInfo = await idbListChildrenOfDir(this.getRootId(), this.path);
+    const result = [];
+    for (const child of childrenInfo) {
+      const childPath = joinPath(this.path, child.name);
+      if (child.type === "dir") {
+        result.push(new IDBDirectoryResource(childPath, this));
+      } else {
+        result.push(new IDBFileResource(childPath, this));
+      }
+    }
+    return result;
+  }
+  async getResource(path, options) {
+    if (!path) {
+      throw new Error("No path provided");
+    }
+    const segments = path.split("/").filter((s) => s.trim());
+    let currentDir = this;
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      const isLast = i === segments.length - 1;
+      const currentPath = currentDir.getPath();
+      const candidatePath = joinPath(currentPath, segment);
+      const rootId = this.getRootId();
+      const entry = await idbGet(rootId, candidatePath);
+      if (!entry) {
+        if (!options?.create) {
+          return null;
+        }
+        if (isLast) {
+          await idbPut(rootId, candidatePath, { type: "file", content: new Blob([]) });
+          publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+          return new IDBFileResource(candidatePath, currentDir);
+        }
+        await idbPut(rootId, candidatePath, { type: "dir" });
+        currentDir = new IDBDirectoryResource(candidatePath, currentDir);
+        continue;
+      }
+      if (isLast) {
+        if (entry.type === "dir") {
+          return new IDBDirectoryResource(candidatePath, currentDir);
+        }
+        return new IDBFileResource(candidatePath, currentDir);
+      }
+      if (entry.type !== "dir") {
+        return null;
+      }
+      currentDir = new IDBDirectoryResource(candidatePath, currentDir);
+    }
+    return currentDir;
+  }
+  touch() {
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+  async delete(name, _recursive = true) {
+    if (!name) {
+      const parent = this.getParent();
+      if (parent instanceof IDBDirectoryResource) {
+        await parent.delete(this.getName());
+        return;
+      }
+      return;
+    }
+    const targetPath = joinPath(this.path, name);
+    await idbDeleteTree(this.getRootId(), targetPath);
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+  async copyTo(targetPath) {
+    for (const resource of await this.listChildren(false)) {
+      const childTarget = [targetPath, resource.getName()].join("/");
+      await resource.copyTo(childTarget);
+    }
+  }
+  async rename(newName) {
+    if (this.getName() === newName) {
+      return;
+    }
+    const parentDir = this.getParent();
+    if (!(parentDir instanceof IDBDirectoryResource)) {
+      throw new Error("Cannot rename IndexedDB root directory");
+    }
+    const oldPath = this.getPath();
+    const newPath = joinPath(parentDir.getPath(), newName);
+    await idbRenameTree(this.getRootId(), oldPath, newPath);
+    publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
+  }
+}
+class IDBRootDirectory extends IDBDirectoryResource {
+  constructor(displayName, rootId) {
+    super("");
+    this.displayName = displayName || "IndexedDB";
+    this.rootId = rootId;
+  }
+  getRootId() {
+    return this.rootId;
+  }
+  getName() {
+    return this.displayName;
+  }
+  getParent() {
+    return void 0;
+  }
+  async rename(_newName) {
+    const name = String(_newName ?? "").trim();
+    if (!name || name === this.displayName) {
+      return;
+    }
+    this.displayName = name;
+    await workspaceService.updateFolderName(this, name);
+  }
+}
+function generateRootId() {
+  return typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : "default-" + Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+workspaceService.registerContribution({
+  type: "indexeddb",
+  name: "idb",
+  canHandle(input) {
+    return input && typeof input === "object" && input.indexeddb === true;
+  },
+  async connect(input) {
+    await getWorkspaceIDB();
+    const explicitName = input.name && String(input.name).trim();
+    const name = explicitName && explicitName.length > 0 ? explicitName : await getNextIndexedDBName();
+    const rootId = generateRootId();
+    return new IDBRootDirectory(name, rootId);
+  },
+  async restore(data) {
+    if (data && typeof data === "object" && data.indexeddb === true && data.rootId) {
+      await getWorkspaceIDB();
+      const name = data.name && String(data.name).trim() || "IndexedDB";
+      return new IDBRootDirectory(name, String(data.rootId));
+    }
+    return void 0;
+  },
+  async persist(workspace) {
+    if (workspace instanceof IDBRootDirectory) {
+      return { indexeddb: true, name: workspace.getName(), rootId: workspace.getRootId() };
+    }
+    return null;
+  }
+});
+class EditorRegistry {
+  constructor() {
+    this.editorInputHandlers = [];
+    this.listenersAttached = false;
+    this.cachedIconContributions = null;
+    subscribe(TOPIC_WORKSPACE_CONNECTED, () => {
+    });
+    subscribe(TOPIC_CONTRIBUTEIONS_CHANGED, (event) => {
+      if (event.target === "system.icons") {
+        this.cachedIconContributions = null;
+      }
+    });
+  }
+  getSortedIconContributions() {
+    if (this.cachedIconContributions !== null) {
+      return this.cachedIconContributions;
+    }
+    const contributions = contributionRegistry.getContributions("system.icons");
+    this.cachedIconContributions = [...contributions].sort((a, b) => {
+      const priorityA = a.priority ?? 0;
+      const priorityB = b.priority ?? 0;
+      if (priorityB !== priorityA) {
+        return priorityB - priorityA;
+      }
+      return a.label.localeCompare(b.label);
+    });
+    return this.cachedIconContributions;
+  }
+  setupEventListeners(editorArea) {
+    if (this.listenersAttached) {
+      return;
+    }
+    this.listenersAttached = true;
+    const handler = (event) => {
+      const tabPanel = event.detail;
+      if (tabPanel) {
+        const parts = Array.from(tabPanel.querySelectorAll(`*`)).filter((element) => element instanceof LyraPart);
+        parts.forEach((part) => {
+          activePartSignal.set(part);
+          if (part.isEditor) {
+            activeEditorSignal.set(part);
+          }
+        });
+      }
+    };
+    editorArea.addEventListener("tab-shown", handler);
+    const closed = (event) => {
+      const tabPanel = event.detail;
+      const parts = Array.from(tabPanel.querySelectorAll(`*`)).filter((element) => element instanceof LyraPart);
+      parts.forEach((part) => {
+        if (activePartSignal.get() == part) {
+          activePartSignal.set(null);
+        }
+        if (activeEditorSignal.get() == part) {
+          activeEditorSignal.set(null);
+        }
+      });
+    };
+    editorArea.addEventListener("tab-closed", closed);
+    const dirtyHandler = (targetPart) => {
+      const tabPanel = targetPart.closest("wa-tab-panel");
+      const name = tabPanel.getAttribute("name");
+      editorArea.markDirty(name, targetPart.isDirty());
+    };
+    this.signalCleanup = watchSignal(partDirtySignal, dirtyHandler);
+  }
+  registerEditorInputHandler(editorInputHandler) {
+    this.editorInputHandlers.push({
+      definition: editorInputHandler,
+      initialized: false
+    });
+    this.editorInputHandlers.sort((a, b) => {
+      const rankA = a.definition.ranking ?? 0;
+      const rankB = b.definition.ranking ?? 0;
+      return rankB - rankA;
+    });
+  }
+  async ensureHandlerInitialized(entry) {
+    const handler = entry.definition;
+    if (!handler.lazyInit || entry.initialized) {
+      return;
+    }
+    if (!entry.lazyInitPromise) {
+      entry.lazyInitPromise = Promise.resolve(handler.lazyInit()).then(() => {
+        entry.initialized = true;
+        entry.lazyInitPromise = void 0;
+      }).catch((error) => {
+        entry.lazyInitPromise = void 0;
+        throw error;
+      });
+    }
+    await entry.lazyInitPromise;
+  }
+  getEditorOptionsForInput(input) {
+    const seen = /* @__PURE__ */ new Set();
+    const options = [];
+    for (const entry of this.editorInputHandlers) {
+      const handler = entry.definition;
+      if (!handler.canHandle(input) || seen.has(handler.editorId)) continue;
+      seen.add(handler.editorId);
+      options.push({
+        editorId: handler.editorId,
+        title: handler.label,
+        icon: handler.icon
+      });
+    }
+    return options;
+  }
+  async handleInput(input, preferredEditorId) {
+    if (preferredEditorId !== void 0) {
+      const entry = this.editorInputHandlers.find(
+        (e) => e.definition.editorId === preferredEditorId
+      );
+      if (entry) {
+        await this.ensureHandlerInitialized(entry);
+        const result = await entry.definition.handle(input);
+        if (result) result.editorId = entry.definition.editorId;
+        return result;
+      }
+      return void 0;
+    }
+    for (let i = 0; i < this.editorInputHandlers.length; i++) {
+      const entry = this.editorInputHandlers[i];
+      const editorInputHandler = entry.definition;
+      if (editorInputHandler.canHandle(input)) {
+        await this.ensureHandlerInitialized(entry);
+        const result = await editorInputHandler.handle(input);
+        if (result) result.editorId = editorInputHandler.editorId;
+        return result;
+      }
+    }
+  }
+  getEditorArea() {
+    return document.querySelector(`lyra-tabs#${EDITOR_AREA_MAIN}`);
+  }
+  async loadEditor(editorInput, preferredEditorId) {
+    if (!editorInput) {
+      return;
+    }
+    if (!("widgetFactory" in editorInput)) {
+      editorInput = await this.handleInput(editorInput, preferredEditorId);
+    }
+    if (!editorInput || !("widgetFactory" in editorInput)) {
+      return;
+    }
+    const editorId = editorInput.editorId ?? preferredEditorId;
+    if (editorId) editorInput.editorId = editorId;
+    await this.openTab({
+      name: editorInput.key,
+      editorId,
+      label: editorInput.title,
+      icon: editorInput.icon,
+      closable: true,
+      noOverflow: editorInput.noOverflow,
+      component: editorInput.widgetFactory
+    });
+  }
+  async openTab(tabContribution) {
+    const editorArea = this.getEditorArea();
+    if (!editorArea) {
+      console.error("Editor area not found. The split pane system may not be initialized yet.");
+      return;
+    }
+    this.setupEventListeners(editorArea);
+    if (editorArea.has(tabContribution.name)) {
+      editorArea.activate(tabContribution.name);
+      return;
+    }
+    editorArea.open(tabContribution);
+  }
+  getFileIcon(fileNameOrType) {
+    const extension = fileNameOrType.includes(".") ? fileNameOrType.split(".").pop()?.toLowerCase() || "" : fileNameOrType.toLowerCase();
+    const sortedContributions = this.getSortedIconContributions();
+    if (sortedContributions.length === 0) {
+      return "file";
+    }
+    for (const contribution of sortedContributions) {
+      if (contribution.mappings && contribution.mappings[extension]) {
+        return contribution.mappings[extension];
+      }
+    }
+    return "file";
+  }
+}
+const editorRegistry = new EditorRegistry();
+rootContext.put("editorRegistry", editorRegistry);
+contributionRegistry.registerContribution("system.icons", {
+  label: "Default File Icons",
+  mappings: {
+    "pdf": "file-pdf",
+    "md": "book",
+    "txt": "file-lines",
+    "ts": "code",
+    "tsx": "code",
+    "js": "code",
+    "jsx": "code",
+    "json": "file-code",
+    "geojson": "file-code",
+    "py": "python",
+    "html": "code",
+    "htm": "code",
+    "css": "code",
+    "scss": "code",
+    "sass": "code",
+    "xml": "file-code",
+    "yaml": "file-code",
+    "yml": "file-code",
+    "sql": "database",
+    "kml": "file-code",
+    "gpx": "file-code",
+    "jpg": "image",
+    "jpeg": "image",
+    "png": "image",
+    "gif": "image",
+    "svg": "image",
+    "webp": "image",
+    "bmp": "image",
+    "ico": "image"
+  },
+  priority: 0
+});
+const logger$2 = createLogger("MarketplaceRegistry");
+const TOPIC_MARKETPLACE_CHANGED = "events/marketplaceregistry/changed";
+const KEY_CATALOG_URLS = "marketplace.catalogUrls";
+class MarketplaceRegistry {
+  constructor() {
+    this.catalogUrls = [];
+    this.loadingPromises = /* @__PURE__ */ new Map();
+    this.loadCatalogUrls().then(() => {
+      this.refreshCatalogs().catch((err) => {
+        logger$2.error(`Failed to refresh catalogs on init: ${err.message}`);
+      });
+    });
+  }
+  async loadCatalogUrls() {
+    try {
+      const urls = await appSettings.get(KEY_CATALOG_URLS);
+      this.catalogUrls = Array.isArray(urls) ? urls : [];
+      logger$2.debug(`Loaded ${this.catalogUrls.length} catalog URLs`);
+    } catch (error) {
+      logger$2.error(`Failed to load catalog URLs: ${error}`);
+      this.catalogUrls = [];
+    }
+  }
+  async saveCatalogUrls() {
+    await appSettings.set(KEY_CATALOG_URLS, this.catalogUrls);
+    publish(TOPIC_MARKETPLACE_CHANGED, { type: "catalogs", urls: this.catalogUrls });
+  }
+  async addCatalogUrl(url) {
+    if (!this.isValidUrl(url)) {
+      throw new Error(`Invalid catalog URL: ${url}`);
+    }
+    if (this.catalogUrls.includes(url)) {
+      logger$2.debug(`Catalog URL already exists: ${url}`);
+      return;
+    }
+    this.catalogUrls.push(url);
+    await this.saveCatalogUrls();
+    logger$2.info(`Added catalog URL: ${url}`);
+    try {
+      await this.refreshCatalogs();
+    } catch (error) {
+      logger$2.warn(`Failed to refresh catalogs immediately after adding: ${error}`);
+    }
+  }
+  async removeCatalogUrl(url) {
+    const index = this.catalogUrls.indexOf(url);
+    if (index === -1) {
+      return;
+    }
+    this.catalogUrls.splice(index, 1);
+    await this.saveCatalogUrls();
+    logger$2.info(`Removed catalog URL: ${url}`);
+  }
+  getCatalogUrls() {
+    return [...this.catalogUrls];
+  }
+  isValidUrl(url) {
+    try {
+      const parsed = new URL(url);
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }
+  async fetchCatalog(url) {
+    const existingPromise = this.loadingPromises.get(url);
+    if (existingPromise) {
+      return existingPromise;
+    }
+    const fetchPromise = (async () => {
+      try {
+        logger$2.debug(`Fetching catalog from: ${url}`);
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            "Accept": "application/json"
+          }
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (!data.extensions || !Array.isArray(data.extensions)) {
+          throw new Error("Invalid catalog format: extensions array is required");
+        }
+        const catalog = {
+          name: data.name,
+          description: data.description,
+          extensions: data.extensions || []
+        };
+        const extCount = catalog.extensions?.length || 0;
+        logger$2.debug(`Successfully fetched catalog from ${url}: ${extCount} extensions`);
+        return catalog;
+      } catch (error) {
+        logger$2.error(`Failed to fetch catalog from ${url}: ${error}`);
+        throw error;
+      } finally {
+        this.loadingPromises.delete(url);
+      }
+    })();
+    this.loadingPromises.set(url, fetchPromise);
+    return fetchPromise;
+  }
+  async refreshCatalogs() {
+    logger$2.info(`Refreshing ${this.catalogUrls.length} catalogs...`);
+    const promises = this.catalogUrls.map(
+      (url) => this.fetchCatalog(url).catch((error) => {
+        logger$2.warn(`Failed to refresh catalog ${url}: ${error.message}`);
+        return null;
+      })
+    );
+    const catalogs = await Promise.allSettled(promises);
+    catalogs.forEach((result, index) => {
+      if (result.status === "fulfilled" && result.value) {
+        const catalog = result.value;
+        if (catalog.extensions) {
+          catalog.extensions.forEach((marketplaceExt) => {
+            if (!extensionRegistry.getExtensions().find((e) => e.id === marketplaceExt.id)) {
+              const extension = {
+                ...marketplaceExt,
+                external: true
+              };
+              extensionRegistry.registerExtension(extension);
+              logger$2.debug(`Registered marketplace extension: ${marketplaceExt.id}`);
+            }
+          });
+        }
+      }
+    });
+    publish(TOPIC_MARKETPLACE_CHANGED, { type: "refreshed" });
+    logger$2.info("Catalog refresh completed");
+  }
+  getMarketplaceExtension(extensionId) {
+    const extension = extensionRegistry.getExtensions().find((e) => e.id === extensionId);
+    if (extension && extension.external) {
+      return extension;
+    }
+    return void 0;
+  }
+  isMarketplaceExtension(extensionId) {
+    const extension = extensionRegistry.getExtensions().find((e) => e.id === extensionId);
+    return extension !== void 0 && extension.external === true;
+  }
+}
+const marketplaceRegistry = new MarketplaceRegistry();
+rootContext.put("marketplaceRegistry", marketplaceRegistry);
+const namespace$6 = "filebrowser";
+const en$6 = { "CONNECT_WORKSPACE": "Connect Workspace...", "REFRESH_RESOURCE": "Refresh resource", "CREATE_NEW": "Create new...", "OPEN": "Open", "FILE": "File", "FOLDER": "Folder", "FILE_EXISTS_OVERWRITE": 'File "{fileName}" already exists. Do you want to overwrite it?', "SELECT_WORKSPACE": "Select a workspace.", "DROP_FILES_HERE": "📁 Drop files here", "OPEN_WITH": "Open with..." };
+const de$6 = { "CONNECT_WORKSPACE": "Arbeitsbereich verbinden...", "REFRESH_RESOURCE": "Ressource aktualisieren", "CREATE_NEW": "Neu erstellen...", "OPEN": "Öffnen", "FILE": "Datei", "FOLDER": "Ordner", "FILE_EXISTS_OVERWRITE": 'Die Datei "{fileName}" existiert bereits. Möchten Sie sie überschreiben?', "SELECT_WORKSPACE": "Wählen Sie einen Arbeitsbereich aus.", "DROP_FILES_HERE": "📁 Dateien hier ablegen", "OPEN_WITH": "Öffnen mit..." };
+const filebrowserBundle = {
+  namespace: namespace$6,
+  en: en$6,
+  de: de$6
+};
+const namespace$5 = "extensions";
+const en$5 = { "FILTER_PLACEHOLDER": "Filter extensions...", "INSTALLED": "Installed", "AVAILABLE": "Available", "NO_MATCHES": 'No extensions match "{filterText}"', "EXTERNAL_EXTENSION": "External Extension", "UNINSTALL": "Uninstall (requires restart)", "REQUIRED_HINT": "This extension is required by the current app and cannot be uninstalled", "INSTALL": "Install", "EXPERIMENTAL": "This is an experimental extension!", "VERSION": "Version:", "AUTHOR": "Author:", "DEPENDENCIES": "Dependencies", "NOT_INSTALLED": "Not Installed", "DEPENDENCIES_HINT": "Dependencies are automatically installed when this extension is enabled.", "DISABLE_TITLE": "Disable this extension", "ENABLE_TITLE": "Enable this extension" };
+const de$5 = { "FILTER_PLACEHOLDER": "Erweiterungen filtern...", "INSTALLED": "Installiert", "AVAILABLE": "Verfügbar", "NO_MATCHES": 'Keine Erweiterungen entsprechen "{filterText}"', "EXTERNAL_EXTENSION": "Externe Erweiterung", "UNINSTALL": "Deinstallieren (Neustart erforderlich)", "REQUIRED_HINT": "Diese Erweiterung ist für die aktuelle App erforderlich und kann nicht deinstalliert werden", "INSTALL": "Installieren", "EXPERIMENTAL": "Dies ist eine experimentelle Erweiterung!", "VERSION": "Version:", "AUTHOR": "Autor:", "DEPENDENCIES": "Abhängigkeiten", "NOT_INSTALLED": "Nicht installiert", "DEPENDENCIES_HINT": "Abhängigkeiten werden automatisch installiert, wenn diese Erweiterung aktiviert wird.", "DISABLE_TITLE": "Diese Erweiterung deaktivieren", "ENABLE_TITLE": "Diese Erweiterung aktivieren" };
+const extensionsBundle = {
+  namespace: namespace$5,
+  en: en$5,
+  de: de$5
+};
+const namespace$4 = "tasks";
+const en$4 = { "ACTIVE_TASKS": "Active Tasks", "ACTIVE_TASKS_TITLE": "Active tasks: {taskCount}. Click to view details." };
+const de$4 = { "ACTIVE_TASKS": "Aktive Aufgaben", "ACTIVE_TASKS_TITLE": "Aktive Aufgaben: {taskCount}. Klicken Sie, um Details anzuzeigen." };
+const tasksBundle = {
+  namespace: namespace$4,
+  en: en$4,
+  de: de$4
+};
+const namespace$3 = "workspace";
+const en$3 = { "NO_WORKSPACE": "<no workspace>", "LOAD_WORKSPACE": "Load workspace" };
+const de$3 = { "NO_WORKSPACE": "<kein Arbeitsbereich>", "LOAD_WORKSPACE": "Arbeitsbereich laden" };
+const workspaceBundle = {
+  namespace: namespace$3,
+  en: en$3,
+  de: de$3
+};
+const namespace$2 = "fastviews";
+const en$2 = { "FAST_VIEWS": "Fast Views" };
+const de$2 = { "FAST_VIEWS": "Schnellansichten" };
+const fastviewsBundle = {
+  namespace: namespace$2,
+  en: en$2,
+  de: de$2
+};
+const namespace$1 = "logterminal";
+const en$1 = { "ALL_LOGS": "All logs", "ALL": "All", "INFO_LOGS": "Info logs", "INFO": "Info", "WARNING_LOGS": "Warning logs", "WARNINGS": "Warnings", "ERROR_LOGS": "Error logs", "ERRORS": "Errors", "DEBUG_LOGS": "Debug logs", "DEBUG": "Debug", "AUTO_SCROLL_ENABLED": "Auto-scroll enabled", "AUTO_SCROLL_DISABLED": "Auto-scroll disabled", "AUTO_SCROLL": "Auto-scroll", "MANUAL": "Manual", "CLEAR_LOGS": "Clear logs", "CLEAR": "Clear", "NO_LOG_MESSAGES": "No log messages" };
+const de$1 = { "ALL_LOGS": "Alle Protokolle", "ALL": "Alle", "INFO_LOGS": "Info-Protokolle", "INFO": "Info", "WARNING_LOGS": "Warnungsprotokolle", "WARNINGS": "Warnungen", "ERROR_LOGS": "Fehlerprotokolle", "ERRORS": "Fehler", "DEBUG_LOGS": "Debug-Protokolle", "DEBUG": "Debug", "AUTO_SCROLL_ENABLED": "Automatisches Scrollen aktiviert", "AUTO_SCROLL_DISABLED": "Automatisches Scrollen deaktiviert", "AUTO_SCROLL": "Automatisches Scrollen", "MANUAL": "Manuell", "CLEAR_LOGS": "Protokolle löschen", "CLEAR": "Löschen", "NO_LOG_MESSAGES": "Keine Protokollnachrichten" };
+const logterminalBundle = {
+  namespace: namespace$1,
+  en: en$1,
+  de: de$1
+};
+const namespace = "partname";
+const en = { "NO_PART": "<no part>", "ACTIVE_PART": "Active part" };
+const de = { "NO_PART": "<kein Bereich>", "ACTIVE_PART": "Aktiver Bereich" };
+const partnameBundle = {
+  namespace,
+  en,
+  de
+};
+contributionRegistry.registerContribution(
+  SYSTEM_LANGUAGE_BUNDLES,
+  filebrowserBundle
+);
+contributionRegistry.registerContribution(
+  SYSTEM_LANGUAGE_BUNDLES,
+  extensionsBundle
+);
+contributionRegistry.registerContribution(
+  SYSTEM_LANGUAGE_BUNDLES,
+  tasksBundle
+);
+contributionRegistry.registerContribution(
+  SYSTEM_LANGUAGE_BUNDLES,
+  workspaceBundle
+);
+contributionRegistry.registerContribution(
+  SYSTEM_LANGUAGE_BUNDLES,
+  fastviewsBundle
+);
+contributionRegistry.registerContribution(
+  SYSTEM_LANGUAGE_BUNDLES,
+  logterminalBundle
+);
+contributionRegistry.registerContribution(
+  SYSTEM_LANGUAGE_BUNDLES,
+  partnameBundle
+);
+const treeNodeComparator = (c1, c2) => {
+  if (!c1.leaf && c2.leaf) {
+    return -1;
+  }
+  if (c1.leaf && !c2.leaf) {
+    return 1;
+  }
+  return c1.label.localeCompare(c2.label);
+};
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+var __decorateClass$8 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$5(target, key, result);
+  return result;
+};
+const t$5 = i18n("filebrowser");
+const WORKSPACE_CHANGED_DEBOUNCE_MS = 250;
+let LyraFileBrowser = class extends LyraPart {
+  constructor() {
+    super(...arguments);
+    this.fileEditorOptions = [];
+    this.treeRef = createRef();
+    this.loadingNodes = /* @__PURE__ */ new Set();
+  }
+  doBeforeUI() {
+    this.initializeWorkspace();
+    subscribe(TOPIC_CONTRIBUTEIONS_CHANGED, (event) => {
+      if (event.target === "system.icons") {
+        this.requestUpdate();
+      }
+    });
+    this.subscribe(TOPIC_WORKSPACE_CHANGED, (workspaceDir) => this.onWorkspaceChanged(workspaceDir));
+    this.subscribe(TOPIC_WORKSPACE_CONNECTED, (workspaceDir) => this.onWorkspaceConnected(workspaceDir));
+  }
+  disconnectedCallback() {
+    if (this.workspaceChangedDebounceId !== void 0) {
+      clearTimeout(this.workspaceChangedDebounceId);
+      this.workspaceChangedDebounceId = void 0;
+    }
+    this.pendingWorkspaceDir = void 0;
+    super.disconnectedCallback();
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this.setupDragAndDrop();
+  }
+  updated(changedProperties) {
+    super.updated(changedProperties);
+    if (changedProperties.has("workspaceDir") && this.workspaceDir) {
+      this.setupDragAndDrop();
+    }
+  }
+  async initializeWorkspace() {
+    const workspaceDir = await workspaceService.getWorkspace();
+    await this.loadWorkspace(workspaceDir ?? void 0);
+  }
+  renderToolbar() {
+    return html`
+            <lyra-command icon="folder-open" title="${t$5("CONNECT_WORKSPACE")}" dropdown="filebrowser.connections"></lyra-command>
+            <lyra-command cmd="refresh_resource" icon="repeat" title="${t$5("REFRESH_RESOURCE")}"></lyra-command>
+            <lyra-command cmd="touch" icon="plus" title="${t$5("CREATE_NEW")}" dropdown="filebrowser.create"></lyra-command>
+        `;
+  }
+  renderContextMenu() {
+    const selection = activeSelectionSignal.get();
+    const file = selection instanceof File ? selection : null;
+    const hasOpenWith = file && this.fileEditorOptions.length > 0;
+    return html`
+            <lyra-command cmd="open_editor" icon="folder-open">${t$5("OPEN")}</lyra-command>
+            ${hasOpenWith ? html`
+                <wa-dropdown-item>
+                    <lyra-icon name="folder-open" slot="icon"></lyra-icon>
+                    ${t$5("OPEN_WITH")}
+                    ${this.fileEditorOptions.map((opt) => html`
+                        <lyra-command
+                            slot="submenu"
+                            cmd="open_editor"
+                            icon="${opt.icon ?? "file"}"
+                            .params=${{ path: file.getWorkspacePath(), editorId: opt.editorId }}>
+                            ${opt.title}
+                        </lyra-command>
+                    `)}
+                </wa-dropdown-item>
+            ` : nothing}
+            <lyra-command cmd="touch" icon="plus" dropdown="filebrowser.create">${t$5("CREATE_NEW")}</lyra-command>
+        `;
+  }
+  onWorkspaceChanged(workspaceDir) {
+    this.pendingWorkspaceDir = workspaceDir;
+    if (this.workspaceChangedDebounceId !== void 0) {
+      clearTimeout(this.workspaceChangedDebounceId);
+    }
+    this.workspaceChangedDebounceId = setTimeout(() => {
+      this.workspaceChangedDebounceId = void 0;
+      const dir = this.pendingWorkspaceDir;
+      this.pendingWorkspaceDir = void 0;
+      if (dir) this.applyWorkspaceChange(dir);
+      else this.loadWorkspace(void 0, true);
+    }, WORKSPACE_CHANGED_DEBOUNCE_MS);
+  }
+  async applyWorkspaceChange(workspaceDir) {
+    activeSelectionSignal.set(void 0);
+    await this.loadWorkspace(workspaceDir, true);
+    await this.syncTreeSelection();
+  }
+  async onWorkspaceConnected(workspaceDir) {
+    await this.loadWorkspace(workspaceDir, true);
+  }
+  async loadWorkspace(workspaceDir, forceRefresh = false) {
+    this.workspaceDir = workspaceDir;
+    if (!workspaceDir) {
+      this.root = void 0;
+    } else {
+      this.root = await this.resourceToTreeNode(workspaceDir, true, forceRefresh);
+    }
+  }
+  async syncTreeSelection() {
+    await this.updateComplete;
+    const waTree = this.treeRef.value?.querySelector("wa-tree");
+    const selectedItems = waTree?.selectedItems || [];
+    if (selectedItems.length > 0) {
+      activeSelectionSignal.set(selectedItems[0].model?.data);
+    }
+  }
+  async resourceToTreeNode(resource, loadChildren = false, forceRefreshChildren = false) {
+    const isFile = resource instanceof File;
+    const node = {
+      data: resource,
+      label: resource.getName(),
+      leaf: isFile,
+      children: []
+    };
+    if (resource instanceof Directory && !resource.getParent()) {
+      try {
+        const info = await workspaceService.getFolderInfoForDirectory(resource);
+        if (info?.backendName) {
+          node.workspaceTag = info.backendName;
+        }
+      } catch (e) {
+        console.warn("Failed to get workspace info for directory", e);
+      }
+    }
+    if (resource instanceof Directory && loadChildren) {
+      for (const childResource of await resource.listChildren(forceRefreshChildren)) {
+        const child = await this.resourceToTreeNode(childResource, true);
+        node.children.push(child);
+      }
+      node.children.sort(treeNodeComparator);
+    }
+    return node;
+  }
+  createTreeItems(node, expanded = false) {
+    if (!node) {
+      return html``;
+    }
+    const isLazy = !node.leaf && node.children.length === 0;
+    const resource = node.data;
+    const isFile = resource instanceof File;
+    const icon = isFile ? editorRegistry.getFileIcon(resource.getName()) : node.icon || "folder-open";
+    const workspaceTag = node.workspaceTag;
+    return html`
+            <wa-tree-item 
+                draggable=${isFile}
+                @dragstart=${isFile ? this.nobubble((e) => this.onDragStart(e, resource)) : void 0}
+                @dblclick=${this.nobubble(this.onFileDoubleClicked)}
+                @wa-lazy-load=${this.nobubble((e) => this.onLazyLoad(e, node))}
+                .model=${node} 
+                ?expanded=${expanded}
+                ?lazy=${isLazy}>
+                <span class="tree-label">
+                    <wa-icon name=${icon} label="${node.leaf ? t$5("FILE") : t$5("FOLDER")}"></wa-icon>
+                    <span class="tree-label-text">${node.label}</span>
+                    ${!node.leaf && workspaceTag ? html`<wa-badge appearance="outlined" variant="neutral" style="font-size: var(--wa-font-size-xs);">${workspaceTag}</wa-badge>` : null}
+                </span>
+                ${node.children.map((child) => this.createTreeItems(child, false))}
+            </wa-tree-item>`;
+  }
+  onDragStart(e, file) {
+    if (!e.dataTransfer) return;
+    const filePath = file.getWorkspacePath();
+    const fileName = file.getName();
+    e.dataTransfer.effectAllowed = "copy";
+    e.dataTransfer.setData("text/plain", filePath);
+    e.dataTransfer.setData("application/x-workspace-file", filePath);
+    e.dataTransfer.setData("text/uri-list", filePath);
+    if (e.dataTransfer.setDragImage) {
+      const dragImage = document.createElement("div");
+      dragImage.textContent = fileName;
+      dragImage.style.position = "absolute";
+      dragImage.style.top = "-1000px";
+      dragImage.style.padding = "4px 8px";
+      dragImage.style.background = "var(--wa-color-neutral-10)";
+      dragImage.style.border = "1px solid var(--wa-color-neutral-30)";
+      dragImage.style.borderRadius = "4px";
+      document.body.appendChild(dragImage);
+      e.dataTransfer.setDragImage(dragImage, 0, 0);
+      setTimeout(() => document.body.removeChild(dragImage), 0);
+    }
+  }
+  async onLazyLoad(event, node) {
+    const resource = node.data;
+    if (resource instanceof Directory && node.children.length === 0) {
+      await this.loadNodeChildren(node, resource);
+    }
+  }
+  async loadNodeChildren(node, resource) {
+    if (this.loadingNodes.has(node)) {
+      return;
+    }
+    this.loadingNodes.add(node);
+    try {
+      for (const childResource of await resource.listChildren(false)) {
+        if (HIDE_DOT_RESOURCE && childResource.getName().startsWith(".")) ;
+        const child = await this.resourceToTreeNode(childResource, false);
+        node.children.push(child);
+      }
+      node.children.sort(treeNodeComparator);
+      this.requestUpdate();
+    } catch (error) {
+      console.error("Failed to load directory children:", error);
+    } finally {
+      this.loadingNodes.delete(node);
+    }
+  }
+  async onFileDoubleClicked(event) {
+    const node = event.currentTarget.model;
+    const resource = node.data;
+    if (resource instanceof File) {
+      activeSelectionSignal.set(resource);
+      this.executeCommand("open_editor", {});
+    }
+  }
+  onSelectionChanged(event) {
+    const selection = event.detail.selection;
+    if (selection && selection.length > 0) {
+      const node = selection[0].model;
+      const data = node.data;
+      activeSelectionSignal.set(data);
+      if (data instanceof File) {
+        this.fileEditorOptions = editorRegistry.getEditorOptionsForInput(data);
+        this.updateContextMenu();
+      } else {
+        this.fileEditorOptions = [];
+        this.updateContextMenu();
+      }
+    } else {
+      activeSelectionSignal.set(void 0);
+      this.fileEditorOptions = [];
+      this.updateContextMenu();
+    }
+  }
+  setupDragAndDrop() {
+    const treeElement = this.treeRef.value;
+    if (!treeElement) return;
+    const dragOverHandler = (e) => {
+      if (!e.dataTransfer?.types.includes("Files")) return;
+      e.preventDefault();
+      e.dataTransfer.dropEffect = "copy";
+      treeElement.classList.add("drag-over");
+      const target = e.target;
+      const treeItem = target.closest("wa-tree-item");
+      if (treeItem && treeItem !== this.currentDropTarget) {
+        this.currentDropTarget?.classList.remove("drop-target");
+        this.currentDropTarget = treeItem;
+        treeItem.classList.add("drop-target");
+      }
+    };
+    const dragEnterHandler = (e) => {
+      if (!e.dataTransfer?.types.includes("Files")) return;
+      e.preventDefault();
+      treeElement.classList.add("drag-over");
+    };
+    const dragLeaveHandler = (e) => {
+      const rect = treeElement.getBoundingClientRect();
+      const x = e.clientX;
+      const y = e.clientY;
+      if (x <= rect.left || x >= rect.right || y <= rect.top || y >= rect.bottom) {
+        treeElement.classList.remove("drag-over");
+        this.currentDropTarget?.classList.remove("drop-target");
+        this.currentDropTarget = void 0;
+      }
+    };
+    const dropHandler = async (e) => {
+      e.preventDefault();
+      treeElement.classList.remove("drag-over");
+      this.currentDropTarget?.classList.remove("drop-target");
+      this.currentDropTarget = void 0;
+      if (!e.dataTransfer || !this.workspaceDir) return;
+      const files = Array.from(e.dataTransfer.files);
+      if (files.length === 0) return;
+      const targetDir = await this.getDropTarget(e);
+      await this.handleFilesDrop(files, targetDir);
+    };
+    treeElement.removeEventListener("dragover", dragOverHandler);
+    treeElement.removeEventListener("dragenter", dragEnterHandler);
+    treeElement.removeEventListener("dragleave", dragLeaveHandler);
+    treeElement.removeEventListener("drop", dropHandler);
+    treeElement.addEventListener("dragover", dragOverHandler);
+    treeElement.addEventListener("dragenter", dragEnterHandler);
+    treeElement.addEventListener("dragleave", dragLeaveHandler);
+    treeElement.addEventListener("drop", dropHandler);
+  }
+  async getDropTarget(e) {
+    const target = e.target;
+    const treeItem = target.closest("wa-tree-item");
+    if (treeItem) {
+      const node = treeItem.model;
+      const resource = node.data;
+      if (resource instanceof Directory) {
+        return resource;
+      }
+      const parent = resource.getParent();
+      if (parent) {
+        return parent;
+      }
+    }
+    return this.workspaceDir;
+  }
+  async handleFilesDrop(files, targetDir) {
+    const total = files.length;
+    let processed = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const file of files) {
+      try {
+        const targetPath = this.buildTargetPath(targetDir, file.name);
+        const existingFile = await this.workspaceDir.getResource(targetPath);
+        if (existingFile) {
+          const overwrite = await confirmDialog(t$5("FILE_EXISTS_OVERWRITE", { fileName: file.name }));
+          if (!overwrite) {
+            skipped++;
+            continue;
+          }
+        }
+        const workspaceFile = await this.workspaceDir.getResource(
+          targetPath,
+          { create: true }
+        );
+        await workspaceFile.saveContents(file);
+        processed++;
+      } catch (error) {
+        console.error(`Failed to upload ${file.name}:`, error);
+        failed++;
+      }
+    }
+    console.log(`Uploaded ${processed}/${total} files${skipped > 0 ? `, ${skipped} skipped` : ""}${failed > 0 ? `, ${failed} failed` : ""}`);
+    await this.loadWorkspace(this.workspaceDir);
+  }
+  buildTargetPath(targetDir, fileName) {
+    const dirPath = targetDir.getWorkspacePath();
+    return dirPath ? `${dirPath}/${fileName}` : fileName;
+  }
+  render() {
+    return html`
+            <div class="tree" ${ref(this.treeRef)} style="--drop-files-text: '${t$5("DROP_FILES_HERE")}'">
+                ${when(!this.workspaceDir, () => html`
+                    <lyra-no-content message="${t$5("SELECT_WORKSPACE")}"></lyra-no-content>`, () => when(this.root, () => html`
+                <wa-tree @wa-selection-change=${this.nobubble(this.onSelectionChanged)}
+                         style="--indent-guide-width: 1px;">
+                    ${this.root.children.map((child) => this.createTreeItems(child, true))}
+                </wa-tree>`, () => html``))}
+            </div>
+        `;
+  }
+};
+LyraFileBrowser.styles = css`
+        :host {
+        }
+        
+        .tree {
+            height: 100%;
+            position: relative;
+            transition: all 0.2s ease;
+        }
+        
+        .tree.drag-over {
+            background-color: var(--wa-color-brand-fill-quiet);
+            outline: 2px dashed var(--wa-color-brand-border-normal);
+            outline-offset: -4px;
+            border-radius: var(--wa-border-radius-medium);
+        }
+        
+        .tree.drag-over::before {
+            content: var(--drop-files-text);
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: var(--wa-color-brand-fill-loud);
+            color: var(--wa-color-brand-on-loud);
+            padding: var(--wa-spacing-large);
+            border-radius: var(--wa-border-radius-large);
+            font-weight: bold;
+            pointer-events: none;
+            z-index: 1000;
+            opacity: 0.3;
+        }
+
+        .tree-label {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.4rem;
+        }
+
+        .tree-label-text {
+            white-space: nowrap;
+        }
+
+        wa-tree-item.drop-target {
+            background-color: var(--wa-color-brand-fill-loud);
+            color: var(--wa-color-brand-on-loud);
+            border-radius: var(--wa-border-radius-small);
+            outline: 2px solid var(--wa-color-brand-border-loud);
+            outline-offset: -2px;
+        }
+    `;
+__decorateClass$8([
+  state()
+], LyraFileBrowser.prototype, "root", 2);
+__decorateClass$8([
+  state()
+], LyraFileBrowser.prototype, "fileEditorOptions", 2);
+LyraFileBrowser = __decorateClass$8([
+  customElement("lyra-filebrowser")
+], LyraFileBrowser);
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const t$4 = i18n("tasks");
+contributionRegistry.registerContribution(TOOLBAR_BOTTOM_CENTER, {
+  html: "<lyra-tasks></lyra-tasks>"
+});
+let progressDialogContainer = null;
+function getProgressDialogContainer() {
+  if (!progressDialogContainer) {
+    progressDialogContainer = document.createElement("div");
+    progressDialogContainer.id = "progress-dialog-container";
+    document.body.appendChild(progressDialogContainer);
+  }
+  return progressDialogContainer;
+}
+function getDialogElement() {
+  const container = getProgressDialogContainer();
+  return container.querySelector("wa-dialog");
+}
+function showProgressDialog() {
+  updateProgressDialog(true);
+}
+function updateProgressDialog(forceOpen = false) {
+  const container = getProgressDialogContainer();
+  const tasks = taskService.getActiveTasks();
+  const currentTaskCount = tasks.length;
+  if (currentTaskCount === 0) {
+    render(html``, container);
+    return;
+  }
+  const existingDialog = getDialogElement();
+  const isOpen = forceOpen || existingDialog?.open === true;
+  if (!isOpen) {
+    return;
+  }
+  const handleClose = () => {
+    const dialog = getDialogElement();
+    if (dialog) {
+      dialog.open = false;
+    }
+  };
+  const handleAfterHide = () => {
+    render(html``, container);
+  };
+  const template = html`
+        <wa-dialog 
+            label="${t$4("ACTIVE_TASKS")}" 
+            open
+            light-dismiss
+            style="--width: 600px;"
+            @wa-request-close=${handleClose}
+            @wa-after-hide=${handleAfterHide}
+        >
+            <style>
+                .progress-dialog-content {
+                    display: flex;
+                    flex-direction: column;
+                    gap: 1.5rem;
+                }
+                
+                .tasitem {
+                    display: flex;
+                    flex-direction: column;
+                    gap: 0.75rem;
+                    padding: 1rem;
+                    background: var(--wa-color-neutral-10);
+                    border-radius: 8px;
+                    border: 1px solid var(--wa-color-neutral-20);
+                }
+                
+                :host-context(.wa-light) .tasitem {
+                    background: var(--wa-color-neutral-95);
+                    border: 1px solid var(--wa-color-neutral-85);
+                }
+                
+                .tasheader {
+                    display: flex;
+                    align-items: center;
+                    gap: 0.75rem;
+                }
+                
+                .tasname {
+                    font-weight: 600;
+                    font-size: 1rem;
+                    color: var(--wa-color-neutral-90);
+                }
+                
+                :host-context(.wa-light) .tasname {
+                    color: var(--wa-color-neutral-10);
+                }
+                
+                .tasmessage {
+                    font-size: 0.875rem;
+                    color: var(--wa-color-neutral-70);
+                    margin-top: 0.25rem;
+                }
+                
+                :host-context(.wa-light) .tasmessage {
+                    color: var(--wa-color-neutral-30);
+                }
+                
+                .tasprogress {
+                    margin-top: 0.5rem;
+                }
+                
+                wa-progress-bar {
+                    --tracheight: 1.5rem;
+                }
+                
+                wa-progress-bar::part(label) {
+                    text-align: center;
+                    width: 100%;
+                    font-size: 0.875rem;
+                }
+                
+                .no-tasks {
+                    text-align: center;
+                    padding: 2rem;
+                    color: var(--wa-color-neutral-60);
+                }
+                
+                :host-context(.wa-light) .no-tasks {
+                    color: var(--wa-color-neutral-40);
+                }
+            </style>
+            
+            <div class="progress-dialog-content">
+                ${tasks.map((taskProgress) => {
+    const hasProgress = taskProgress.progress >= 0 || taskProgress.totalSteps > 0;
+    const progress = taskProgress.progress >= 0 ? taskProgress.progress : taskProgress.totalSteps > 0 ? Math.round(taskProgress.currentStep / taskProgress.totalSteps * 100) : 0;
+    const showSteps = taskProgress.progress < 0 && taskProgress.totalSteps > 0;
+    return html`
+                        <div class="tasitem">
+                            <div class="tasheader">
+                                <wa-icon name="hourglass" style="color: var(--wa-color-warning-fill-loud);"></wa-icon>
+                                <div style="flex: 1;">
+                                    <div class="tasname">${taskProgress.name}</div>
+                                    ${taskProgress.message ? html`
+                                        <div class="tasmessage">${taskProgress.message}</div>
+                                    ` : ""}
+                                </div>
+                            </div>
+                            <div class="tasprogress">
+                                ${hasProgress ? html`
+                                    <wa-progress-bar value="${progress}">
+                                        ${showSteps ? `${taskProgress.currentStep}/${taskProgress.totalSteps} - ` : ""}${progress}%
+                                    </wa-progress-bar>
+                                ` : html`
+                                    <wa-progress-bar indeterminate></wa-progress-bar>
+                                `}
+                            </div>
+                        </div>
+                    `;
+  })}
+            </div>
+        </wa-dialog>
+    `;
+  render(template, container);
+}
+let LyraTasks = class extends LyraPart {
+  doBeforeUI() {
+    this.watch(activeTasksSignal, () => {
+      updateProgressDialog();
+      this.requestUpdate();
+    });
+  }
+  handleIndicatorClick() {
+    showProgressDialog();
+  }
+  render() {
+    activeTasksSignal.get();
+    const tasks = taskService.getActiveTasks();
+    const taskCount = tasks.length;
+    if (taskCount === 0) {
+      return html``;
+    }
+    return html`
+            <div class="tasindicator" @click=${this.handleIndicatorClick} title="${t$4("ACTIVE_TASKS_TITLE", { taskCount: taskCount.toString() })}">
+                <wa-spinner
+                    style="font-size: 1rem; --indicator-color: var(--wa-color-warning-fill-loud);"
+                    label="${t$4("ACTIVE_TASKS")}"
+                ></wa-spinner>
+                <span class="tascount">${taskCount}</span>
+                <div class="tasbar-wrap"><wa-progress-bar indeterminate></wa-progress-bar></div>
+            </div>
+        `;
+  }
+};
+LyraTasks.styles = css`
+        :host {
+            display: flex;
+            align-items: center;
+        }
+        
+        .tasindicator {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            cursor: pointer;
+            padding: 0.25rem 0.5rem;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        
+        .tasindicator:hover {
+            background: var(--wa-color-neutral-15);
+        }
+        
+        :host-context(.wa-light) .tasindicator:hover {
+            background: var(--wa-color-neutral-85);
+        }
+        
+        .tascount {
+            font-size: 0.875rem;
+            color: var(--wa-color-neutral-70);
+        }
+        
+        :host-context(.wa-light) .tascount {
+            color: var(--wa-color-neutral-30);
+        }
+        
+        .tasbar-wrap {
+            width: 3rem;
+        }
+        
+        .tasbar-wrap wa-progress-bar {
+            --tracheight: 4px;
+        }
+    `;
+LyraTasks = __decorateClass$7([
+  customElement("lyra-tasks")
+], LyraTasks);
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const t$3 = i18n("partname");
+contributionRegistry.registerContribution(TOOLBAR_BOTTOM_CENTER, {
+  html: "<lyra-part-name></lyra-part-name>"
+});
+let LyraPartName = class extends LyraElement {
+  doBeforeUI() {
+    this.watch(activePartSignal, () => {
+      this.requestUpdate();
+    });
+  }
+  getPartName() {
+    const activePart = activePartSignal.get();
+    if (!activePart) {
+      return t$3("NO_PART");
+    }
+    return activePart.tabContribution?.label || activePart.getAttribute("id") || t$3("NO_PART");
+  }
+  render() {
+    const activePart = activePartSignal.get();
+    const partIcon = activePart?.tabContribution?.icon || "box";
+    return html`
+            <wa-button 
+                appearance="plain"
+                size="small"
+                title="${t$3("ACTIVE_PART")}">
+                <lyra-icon slot="start" name="${partIcon}" label="Part"></lyra-icon>
+                ${this.getPartName()}
+            </wa-button>
+        `;
+  }
+};
+LyraPartName = __decorateClass$6([
+  customElement("lyra-part-name")
+], LyraPartName);
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$4(target, key, result);
+  return result;
+};
+const logger$1 = createLogger("LyraExtensions");
+const t$2 = i18n("extensions");
+let LyraExtensions = class extends LyraPart {
+  constructor() {
+    super(...arguments);
+    this.filterText = "";
+    this.showRegisterDialog = false;
+    this.registerExtensionData = {};
+  }
+  doInitUI() {
+    subscribe(TOPIC_EXTENSIONS_CHANGED, () => {
+      this.requestUpdate();
+    });
+  }
+  onExtensionDblClick() {
+  }
+  enable(extension) {
+    extensionRegistry.enable(extension.id, true);
+    this.requestUpdate();
+  }
+  disable(extension) {
+    extensionRegistry.disable(extension.id, true);
+    this.requestUpdate();
+  }
+  isExtensionRequired(extensionId) {
+    const currentApp = appLoaderService.getCurrentApp();
+    if (!currentApp || !currentApp.extensions) {
+      return false;
+    }
+    return currentApp.extensions.includes(extensionId);
+  }
+  selectionChanged(e) {
+    const selection = e.detail.selection || [];
+    if (selection.length > 0 && selection[0].model) {
+      this.selectedExtension = selection[0].model;
+    } else {
+      this.selectedExtension = void 0;
+    }
+  }
+  getFilteredExtensions() {
+    if (!this.filterText.trim()) {
+      return extensionRegistry.getExtensions();
+    }
+    const filter = this.filterText.toLowerCase();
+    return extensionRegistry.getExtensions().filter((ext) => {
+      return String(ext.name).toLowerCase().includes(filter) || (ext.description ? String(ext.description).toLowerCase().includes(filter) : false) || ext.id.toLowerCase().includes(filter);
+    });
+  }
+  getGroupedExtensions() {
+    const filtered = this.getFilteredExtensions();
+    const enabled = [];
+    const available = [];
+    filtered.forEach((ext) => {
+      if (extensionRegistry.isEnabled(ext.id)) {
+        enabled.push(ext);
+      } else {
+        available.push(ext);
+      }
+    });
+    enabled.sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    available.sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    return { enabled, available };
+  }
+  isExternalExtension(extension) {
+    return extension.external === true;
+  }
+  handleFilterInput(e) {
+    this.filterText = e.target.value;
+    this.requestUpdate();
+  }
+  clearFilter() {
+    this.filterText = "";
+    this.requestUpdate();
+  }
+  async handleRegisterExtension() {
+    try {
+      const url = await promptDialog("Enter extension URL or source identifier:", "", false);
+      if (!url) {
+        return;
+      }
+      await taskService.runAsync("Registering extension", async () => {
+        let finalUrl = url;
+        if (esmShService.isGitHubUrl(url)) {
+          finalUrl = esmShService.convertGitHubUrlToSource(url);
+        }
+        const parsed = esmShService.parseSource(finalUrl);
+        if (parsed?.type === "github") {
+          await this.fetchGitHubMetadata(parsed, finalUrl);
+        } else {
+          this.registerExtensionData = {
+            url: finalUrl,
+            id: "",
+            name: "",
+            description: ""
+          };
+          this.showRegisterDialog = true;
+          this.requestUpdate();
+        }
+      });
+    } catch (error) {
+      toastError(`Failed to register extension: ${error}`);
+    }
+  }
+  async fetchGitHubMetadata(parsed, url) {
+    try {
+      const packageJson = await esmShService.fetchGitHubPackageJson(parsed);
+      const owner = parsed.owner;
+      const repo = parsed.repo;
+      const extensionId = packageJson.name || `ext.${owner}-${repo}`;
+      const extensionName = packageJson.name || `${owner}/${repo}`;
+      const description = packageJson.description || "";
+      const version = packageJson.version || "";
+      const author = packageJson.author || (typeof packageJson.author === "string" ? packageJson.author : packageJson.author?.name) || "";
+      this.registerExtensionData = {
+        id: extensionId,
+        name: extensionName,
+        description,
+        url,
+        version,
+        author,
+        icon: "puzzle-piece",
+        external: true
+      };
+      this.showRegisterDialog = true;
+      this.requestUpdate();
+    } catch (error) {
+      logger$1.warn(`Could not fetch package.json, using defaults: ${error}`);
+      this.registerExtensionData = {
+        url,
+        id: "",
+        name: "",
+        description: ""
+      };
+      this.showRegisterDialog = true;
+      this.requestUpdate();
+    }
+  }
+  async confirmRegisterExtension() {
+    if (!this.registerExtensionData.url) {
+      toastError("URL is required");
+      return;
+    }
+    if (!this.registerExtensionData.id) {
+      toastError("Extension ID is required");
+      return;
+    }
+    if (!this.registerExtensionData.name) {
+      toastError("Extension name is required");
+      return;
+    }
+    try {
+      await taskService.runAsync("Registering extension", async () => {
+        const extension = {
+          id: this.registerExtensionData.id,
+          name: this.registerExtensionData.name,
+          description: this.registerExtensionData.description,
+          url: this.registerExtensionData.url,
+          version: this.registerExtensionData.version,
+          author: this.registerExtensionData.author,
+          icon: this.registerExtensionData.icon || "puzzle-piece",
+          external: true
+        };
+        extensionRegistry.registerExtension(extension);
+        await extensionRegistry.loadExtensionFromUrl(this.registerExtensionData.url, extension.id);
+        toastInfo(`Extension ${extension.name} registered successfully`);
+        this.showRegisterDialog = false;
+        this.registerExtensionData = {};
+        this.requestUpdate();
+      });
+    } catch (error) {
+      toastError(`Failed to register extension: ${error}`);
+    }
+  }
+  cancelRegisterExtension() {
+    this.showRegisterDialog = false;
+    this.registerExtensionData = {};
+    this.requestUpdate();
+  }
+  renderToolbar() {
+    return html`
+            <wa-input
+                placeholder="${t$2("FILTER_PLACEHOLDER")}"
+                .value=${this.filterText}
+                @input=${(e) => this.handleFilterInput(e)}
+                @wa-clear=${() => this.clearFilter()}
+                with-clear
+                size="small"
+                style="width: 300px;">
+                <wa-icon slot="start" name="magnifying-glass" label="Filter"></wa-icon>
+            </wa-input>
+            <wa-button 
+                variant="primary" 
+                appearance="plain"
+                @click=${() => this.handleRegisterExtension()}
+                title="Register a new extension">
+                <wa-icon name="plus" label="Add"></wa-icon>
+                Register Extension
+            </wa-button>
+        `;
+  }
+  render() {
+    const grouped = this.getGroupedExtensions();
+    const hasAnyExtensions = grouped.enabled.length > 0 || grouped.available.length > 0;
+    return html`
+            ${when(this.showRegisterDialog, () => html`
+                <wa-dialog 
+                    label="Register Extension"
+                    open
+                    @wa-request-close=${() => this.cancelRegisterExtension()}
+                    style="--wa-dialog-width: 500px;">
+                    <div style="display: flex; flex-direction: column; gap: 1rem; padding: 1rem;">
+                        <wa-input
+                            label="Extension ID *"
+                            .value=${this.registerExtensionData.id || ""}
+                            @input=${(e) => {
+      this.registerExtensionData.id = e.target.value;
+      this.requestUpdate();
+    }}
+                            required
+                            hint="Unique identifier for the extension (e.g., 'ext.my-extension')">
+                        </wa-input>
+                        
+                        <wa-input
+                            label="Name *"
+                            .value=${this.registerExtensionData.name || ""}
+                            @input=${(e) => {
+      this.registerExtensionData.name = e.target.value;
+      this.requestUpdate();
+    }}
+                            required
+                            hint="Display name of the extension">
+                        </wa-input>
+                        
+                        <wa-input
+                            label="Description"
+                            .value=${this.registerExtensionData.description || ""}
+                            @input=${(e) => {
+      this.registerExtensionData.description = e.target.value;
+      this.requestUpdate();
+    }}
+                            hint="Description of what the extension does">
+                        </wa-input>
+                        
+                        <wa-input
+                            label="URL *"
+                            .value=${this.registerExtensionData.url || ""}
+                            @input=${(e) => {
+      this.registerExtensionData.url = e.target.value;
+      this.requestUpdate();
+    }}
+                            required
+                            readonly
+                            hint="Extension source URL or identifier">
+                        </wa-input>
+                        
+                        <div style="display: flex; gap: 0.5rem;">
+                            <wa-input
+                                label="Version"
+                                .value=${this.registerExtensionData.version || ""}
+                                @input=${(e) => {
+      this.registerExtensionData.version = e.target.value;
+      this.requestUpdate();
+    }}
+                                style="flex: 1;"
+                                hint="Extension version">
+                            </wa-input>
+                            
+                            <wa-input
+                                label="Author"
+                                .value=${this.registerExtensionData.author || ""}
+                                @input=${(e) => {
+      this.registerExtensionData.author = e.target.value;
+      this.requestUpdate();
+    }}
+                                style="flex: 1;"
+                                hint="Extension author">
+                            </wa-input>
+                        </div>
+                        
+                        <wa-input
+                            label="Icon"
+                            .value=${this.registerExtensionData.icon || "puzzle-piece"}
+                            @input=${(e) => {
+      this.registerExtensionData.icon = e.target.value;
+      this.requestUpdate();
+    }}
+                            hint="Icon name (FontAwesome icon)">
+                        </wa-input>
+                        
+                        <div style="display: flex; justify-content: flex-end; gap: 0.5rem; margin-top: 1rem;">
+                            <wa-button 
+                                variant="default" 
+                                @click=${() => this.cancelRegisterExtension()}>
+                                Cancel
+                            </wa-button>
+                            <wa-button 
+                                variant="primary" 
+                                @click=${() => this.confirmRegisterExtension()}
+                                ?disabled=${!this.registerExtensionData.id || !this.registerExtensionData.name || !this.registerExtensionData.url}>
+                                Register
+                            </wa-button>
+                        </div>
+                    </div>
+                </wa-dialog>
+            `)}
+            <wa-split-panel position="30" style="height: 100%">
+                <wa-tree 
+                    selection="leaf"
+                    style="--indent-guide-width: 1px;" 
+                    slot="start"
+                    @wa-selection-change="${this.selectionChanged}">
+                    ${hasAnyExtensions ? html`
+                        ${grouped.enabled.length > 0 ? html`
+                            <wa-tree-item expanded>
+                                <span>
+                                    <wa-icon name="check-circle" style="color: var(--wa-color-success-50);"></wa-icon>
+                                    ${t$2("INSTALLED")} (${grouped.enabled.length})
+                                </span>
+                                ${grouped.enabled.map((e) => {
+      const isExternal = this.isExternalExtension(e);
+      return html`
+                                        <wa-tree-item @dblclick=${this.nobubble(this.onExtensionDblClick)} .model=${e}>
+                                            <span><lyra-icon name="${e.icon}"></lyra-icon></span> ${e.name}${isExternal ? html` <span style="opacity: 0.6; font-size: 0.9em; margin-left: 0.5rem;">(External)</span>` : ""}
+                                        </wa-tree-item>
+                                    `;
+    })}
+                            </wa-tree-item>
+                        ` : ""}
+                        ${grouped.available.length > 0 ? html`
+                            <wa-tree-item expanded>
+                                <span>
+                                    <wa-icon name="circle" style="color: var(--wa-color-neutral-50);"></wa-icon>
+                                    ${t$2("AVAILABLE")} (${grouped.available.length})
+                                </span>
+                                ${grouped.available.map((e) => {
+      const isExternal = this.isExternalExtension(e);
+      return html`
+                                        <wa-tree-item @dblclick=${this.nobubble(this.onExtensionDblClick)} .model=${e}>
+                                            <span><lyra-icon name="${e.icon}"></lyra-icon></span> ${e.name}${isExternal ? html` <span style="opacity: 0.6; font-size: 0.9em; margin-left: 0.5rem;">(External)</span>` : ""}
+                                        </wa-tree-item>
+                                    `;
+    })}
+                            </wa-tree-item>
+                        ` : ""}
+                    ` : ""}
+                    ${!hasAnyExtensions ? html`
+                        <div style="padding: 1em; text-align: center; opacity: 0.7;">
+                            ${t$2("NO_MATCHES", { filterText: this.filterText })}
+                        </div>
+                    ` : ""}
+                </wa-tree>
+                <div slot="end" style="padding: 1em;">
+                    ${when(this.selectedExtension, (e) => {
+      const isExternal = this.isExternalExtension(e);
+      const isEnabled = extensionRegistry.isEnabled(e.id);
+      return html`
+                                <h1><lyra-icon name="${e.icon}"></lyra-icon> ${e.name}${isExternal ? " (External)" : ""}</h1>
+                                ${when(isExternal, () => html`
+                                    <div class="marketplace-badge">
+                                        <wa-icon name="store"></wa-icon>
+                                        <span>${t$2("EXTERNAL_EXTENSION")}</span>
+                                    </div>
+                                `)}
+                                <hr>
+                                <div>
+                                    ${when(isEnabled, () => html`
+                                        <wa-button 
+                                            title="${this.isExtensionRequired(e.id) ? t$2("REQUIRED_HINT") : t$2("DISABLE_TITLE")}" 
+                                            @click="${() => this.disable(e)}"
+                                            variant="danger" 
+                                            appearance="plain"
+                                            ?disabled=${this.isExtensionRequired(e.id)}>
+                                            <wa-icon name="xmark" label="Uninstall"></wa-icon>&nbsp;${t$2("UNINSTALL")}
+                                        </wa-button>
+                                        ${when(this.isExtensionRequired(e.id), () => html`
+                                            <div class="required-hint">
+                                                <wa-icon name="info-circle" style="color: var(--wa-color-primary-50);"></wa-icon>
+                                                <span>${t$2("REQUIRED_HINT")}</span>
+                                            </div>
+                                        `)}
+                                    `, () => html`
+                                        <wa-button 
+                                            title="${t$2("ENABLE_TITLE")}" 
+                                            @click="${() => this.enable(e)}"
+                                            variant="brand" 
+                                            appearance="plain">
+                                            <wa-icon name="download" label="Install"></wa-icon>&nbsp;${t$2("INSTALL")}
+                                        </wa-button>
+                                    `)}
+                                </div>
+
+                                ${when(e.experimental, () => html`
+                                    <div style="margin-top: 1em;">
+                                        <wa-button size="small" variant="warning" appearance="plain">
+                                            <wa-icon name="triangle-exclamation" label="Warning"></wa-icon>
+                                        </wa-button>
+                                        <small><i>${t$2("EXPERIMENTAL")}</i></small>
+                                    </div>
+                                `)}
+
+                                ${when(e.version || e.author, () => html`
+                                    <div style="margin-top: 1em; display: flex; flex-direction: column; gap: 0.5rem;">
+                                        ${when(e.version, () => html`
+                                            <div style="display: flex; align-items: center; gap: 0.5rem;">
+                                                <wa-icon name="tag" style="font-size: 0.9em; opacity: 0.7;"></wa-icon>
+                                                <span style="font-size: 0.9em; opacity: 0.8;">${t$2("VERSION")} <strong>${e.version}</strong></span>
+                                            </div>
+                                        `)}
+                                        ${when(e.author, () => html`
+                                            <div style="display: flex; align-items: center; gap: 0.5rem;">
+                                                <wa-icon name="user" style="font-size: 0.9em; opacity: 0.7;"></wa-icon>
+                                                <span style="font-size: 0.9em; opacity: 0.8;">${t$2("AUTHOR")} <strong>${e.author}</strong></span>
+                                            </div>
+                                        `)}
+                                    </div>
+                                `)}
+
+                                <p style="margin-top: 1em;">${e.description}</p>
+
+                                ${when(e.dependencies && e.dependencies.length > 0, () => html`
+                                    <div style="margin-top: 1.5em;">
+                                        <h3 style="margin-bottom: 0.5em;">
+                                            <wa-icon name="puzzle-piece" style="font-size: 0.9em;"></wa-icon>
+                                            ${t$2("DEPENDENCIES")}
+                                        </h3>
+                                        <div class="dependencies-list">
+                                            ${e.dependencies.map((depId) => {
+        const depExt = extensionRegistry.getExtensions().find((ex) => ex.id === depId);
+        const isEnabled2 = extensionRegistry.isEnabled(depId);
+        return html`
+                                                    <div class="dependency-item">
+                                                        <wa-icon 
+                                                            name="${isEnabled2 ? "check-circle" : "circle"}" 
+                                                            style="color: ${isEnabled2 ? "var(--wa-color-success-50)" : "var(--wa-color-neutral-50)"};">
+                                                        </wa-icon>
+                                                        <lyra-icon name="${depExt?.icon || "puzzle-piece"}"></lyra-icon>
+                                                        <span>${depExt?.name || depId}</span>
+                                                        ${!isEnabled2 ? html`
+                                                            <span class="dependency-badge">${t$2("NOT_INSTALLED")}</span>
+                                                        ` : ""}
+                                                    </div>
+                                                `;
+      })}
+                                        </div>
+                                        <small style="opacity: 0.7; display: block; margin-top: 0.5em;">
+                                            <wa-icon name="info-circle" style="font-size: 0.9em;"></wa-icon>
+                                            ${t$2("DEPENDENCIES_HINT")}
+                                        </small>
+                                    </div>
+                                `)}
+                            `;
+    })}
+                </div>
+            </wa-split-panel>
+        `;
+  }
+};
+LyraExtensions.styles = css`
+        :host {
+        }
+
+        wa-tree-item > span {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        wa-tree-item:has(> wa-tree-item) {
+            font-weight: 500;
+        }
+
+        .dependencies-list {
+            display: flex;
+            flex-direction: column;
+            gap: 0.5rem;
+        }
+
+        .dependency-item {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.5rem;
+            border-radius: 4px;
+            background: var(--wa-color-surface-variant);
+        }
+
+        .dependency-item wa-icon:first-child {
+            flex-shrink: 0;
+        }
+
+        .dependency-item icon {
+            flex-shrink: 0;
+        }
+
+        .dependency-item span:not(.dependency-badge) {
+            flex: 1;
+        }
+
+        .dependency-badge {
+            font-size: 0.85rem;
+            padding: 0.25rem 0.5rem;
+            border-radius: 4px;
+            background: var(--wa-color-warning-100);
+            color: var(--wa-color-warning-900);
+        }
+
+        .required-hint {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            margin-top: 0.75rem;
+            padding: 0.5rem;
+            border-radius: 4px;
+            background: var(--wa-color-primary-10);
+            color: var(--wa-color-primary-70);
+            font-size: 0.875rem;
+        }
+
+        .required-hint wa-icon {
+            flex-shrink: 0;
+        }
+
+        .required-hint span {
+            line-height: 1.4;
+        }
+
+        .marketplace-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.375rem 0.875rem;
+            border-radius: 4px;
+            background: var(--wa-color-primary-10);
+            color: var(--wa-color-primary-70);
+            font-size: 0.875rem;
+            font-weight: 500;
+            margin-top: 0.75rem;
+            margin-bottom: 0.5rem;
+            border: 1px solid var(--wa-color-primary-30);
+        }
+    `;
+__decorateClass$5([
+  state()
+], LyraExtensions.prototype, "selectedExtension", 2);
+__decorateClass$5([
+  state()
+], LyraExtensions.prototype, "filterText", 2);
+__decorateClass$5([
+  state()
+], LyraExtensions.prototype, "showRegisterDialog", 2);
+__decorateClass$5([
+  state()
+], LyraExtensions.prototype, "registerExtensionData", 2);
+LyraExtensions = __decorateClass$5([
+  customElement("lyra-extensions")
+], LyraExtensions);
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$3(target, key, result);
+  return result;
+};
+const t$1 = i18n("logterminal");
+let LyraLogTerminal = class extends LyraPart {
+  constructor() {
+    super(...arguments);
+    this.messages = [];
+    this.autoScroll = true;
+    this.filter = "all";
+    this.containerRef = createRef();
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.loadSettings();
+    registerLogHandler(this.log.bind(this));
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    unregisterLogHandler();
+  }
+  log(source, message, level = "info") {
+    const logMessage = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      source,
+      message
+    };
+    this.messages = [...this.messages, logMessage];
+    this.updateToolbar();
+    if (this.autoScroll) {
+      this.updateComplete.then(() => {
+        const container = this.containerRef.value;
+        if (container) {
+          container.scrollTop = container.scrollHeight;
+        }
+      });
+    }
+  }
+  clear() {
+    this.messages = [];
+    this.updateToolbar();
+  }
+  getFilteredMessages() {
+    if (this.filter === "all") {
+      return this.messages;
+    }
+    return this.messages.filter((m) => m.level === this.filter);
+  }
+  formatTimestamp(date) {
+    return date.toLocaleTimeString("en-US", {
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+  }
+  getLevelIcon(level) {
+    switch (level) {
+      case "info":
+        return "circle-info";
+      case "warning":
+        return "triangle-exclamation";
+      case "error":
+        return "circle-xmark";
+      case "debug":
+        return "bug";
+    }
+  }
+  getLevelColor(level) {
+    switch (level) {
+      case "info":
+        return "var(--wa-color-primary-text, #0066cc)";
+      case "warning":
+        return "var(--wa-color-warning-text, #ff9800)";
+      case "error":
+        return "var(--wa-color-danger-text, #dc3545)";
+      case "debug":
+        return "var(--wa-color-neutral-text-subtle, #6c757d)";
+    }
+  }
+  renderToolbar() {
+    const infoCount = this.messages.filter((m) => m.level === "info").length;
+    const warningCount = this.messages.filter((m) => m.level === "warning").length;
+    const errorCount = this.messages.filter((m) => m.level === "error").length;
+    const debugCount = this.messages.filter((m) => m.level === "debug").length;
+    return html`
+            <lyra-command 
+                icon="list"
+                title="${t$1("ALL_LOGS")}"
+                appearance="${this.filter === "all" ? "filled" : "plain"}"
+                variant="${this.filter === "all" ? "brand" : "neutral"}"
+                .action=${() => {
+      this.filter = "all";
+      this.saveSettings();
+      this.updateToolbar();
+    }}>
+                ${t$1("ALL")} (${this.messages.length})
+            </lyra-command>
+
+            <lyra-command 
+                icon="circle-info"
+                title="${t$1("INFO_LOGS")}"
+                appearance="${this.filter === "info" ? "filled" : "plain"}"
+                variant="${this.filter === "info" ? "brand" : "neutral"}"
+                .action=${() => {
+      this.filter = "info";
+      this.saveSettings();
+      this.updateToolbar();
+    }}>
+                ${t$1("INFO")}${infoCount > 0 ? ` (${infoCount})` : ""}
+            </lyra-command>
+
+            <lyra-command 
+                icon="triangle-exclamation"
+                title="${t$1("WARNING_LOGS")}"
+                appearance="${this.filter === "warning" ? "filled" : "plain"}"
+                variant="${this.filter === "warning" ? "brand" : "neutral"}"
+                .action=${() => {
+      this.filter = "warning";
+      this.saveSettings();
+      this.updateToolbar();
+    }}>
+                ${t$1("WARNINGS")}${warningCount > 0 ? ` (${warningCount})` : ""}
+            </lyra-command>
+
+            <lyra-command 
+                icon="circle-xmark"
+                title="${t$1("ERROR_LOGS")}"
+                appearance="${this.filter === "error" ? "filled" : "plain"}"
+                variant="${this.filter === "error" ? "brand" : "neutral"}"
+                .action=${() => {
+      this.filter = "error";
+      this.saveSettings();
+      this.updateToolbar();
+    }}>
+                ${t$1("ERRORS")}${errorCount > 0 ? ` (${errorCount})` : ""}
+            </lyra-command>
+
+            <lyra-command 
+                icon="bug"
+                title="${t$1("DEBUG_LOGS")}"
+                appearance="${this.filter === "debug" ? "filled" : "plain"}"
+                variant="${this.filter === "debug" ? "brand" : "neutral"}"
+                .action=${() => {
+      this.filter = "debug";
+      this.saveSettings();
+      this.updateToolbar();
+    }}>
+                ${t$1("DEBUG")}${debugCount > 0 ? ` (${debugCount})` : ""}
+            </lyra-command>
+
+            <wa-divider orientation="vertical"></wa-divider>
+
+            <lyra-command 
+                icon="arrow-down" 
+                title="${this.autoScroll ? t$1("AUTO_SCROLL_ENABLED") : t$1("AUTO_SCROLL_DISABLED")}"
+                appearance="${this.autoScroll ? "filled" : "plain"}"
+                variant="${this.autoScroll ? "brand" : "neutral"}"
+                .action=${() => {
+      this.autoScroll = !this.autoScroll;
+      this.saveSettings();
+      this.updateToolbar();
+    }}>
+                ${this.autoScroll ? t$1("AUTO_SCROLL") : t$1("MANUAL")}
+            </lyra-command>
+
+            <lyra-command 
+                icon="trash" 
+                title="${t$1("CLEAR_LOGS")}"
+                .action=${() => this.clear()}>
+                ${t$1("CLEAR")}
+            </lyra-command>
+        `;
+  }
+  render() {
+    const filteredMessages = this.getFilteredMessages();
+    return html`
+            <div class="log-terminal">
+                <div class="messages" ${ref(this.containerRef)}>
+                    ${filteredMessages.length === 0 ? html`<div class="empty-state">${t$1("NO_LOG_MESSAGES")}</div>` : filteredMessages.map((msg) => html`
+                            <div class="message" data-level="${msg.level}">
+                                <span class="timestamp">${this.formatTimestamp(msg.timestamp)}</span>
+                                <wa-icon 
+                                    name="${this.getLevelIcon(msg.level)}" 
+                                    label="${msg.level}"
+                                    style="color: ${this.getLevelColor(msg.level)}">
+                                </wa-icon>
+                                <span class="source">[${msg.source}]</span>
+                                <span class="text">${msg.message}</span>
+                            </div>
+                        `)}
+                </div>
+            </div>
+        `;
+  }
+  async loadSettings() {
+    const persisted = await this.getDialogSetting();
+    if (persisted) {
+      if (typeof persisted.filter === "string" && (persisted.filter === "all" || ["info", "warning", "error", "debug"].includes(persisted.filter))) {
+        this.filter = persisted.filter;
+      }
+      if (typeof persisted.autoScroll === "boolean") {
+        this.autoScroll = persisted.autoScroll;
+      }
+      this.updateToolbar();
+    }
+  }
+  async saveSettings() {
+    await this.setDialogSetting({
+      filter: this.filter,
+      autoScroll: this.autoScroll
+    });
+  }
+};
+LyraLogTerminal.styles = css`
+        :host {
+            display: flex;
+            flex-direction: column;
+            height: 100%;
+            width: 100%;
+        }
+
+        .log-terminal {
+            display: flex;
+            flex-direction: column;
+            height: 100%;
+            width: 100%;
+        }
+
+        .messages {
+            flex: 1;
+            overflow-y: auto;
+            padding: 0.5rem;
+            font-family: var(--wa-font-mono);
+            font-size: 0.875rem;
+            line-height: 1.5;
+        }
+
+        .message {
+            display: flex;
+            gap: 0.5rem;
+            padding: 0.25rem 0.5rem;
+            align-items: baseline;
+            border-radius: var(--wa-border-radius-small);
+        }
+
+        .message:hover {
+            background: var(--wa-color-neutral-background-hover);
+        }
+
+        .timestamp {
+            color: var(--wa-color-neutral-text-subtle);
+            font-size: 0.75rem;
+            white-space: nowrap;
+        }
+
+        .source {
+            color: var(--wa-color-primary-text);
+            font-weight: 500;
+            white-space: nowrap;
+        }
+
+        .text {
+            color: var(--wa-color-neutral-text);
+            word-break: breaword;
+        }
+
+        .message[data-level="error"] .text {
+            color: var(--wa-color-danger-text);
+        }
+
+        .message[data-level="warning"] .text {
+            color: var(--wa-color-warning-text);
+        }
+
+        .message[data-level="debug"] .text {
+            color: var(--wa-color-neutral-text-subtle);
+        }
+
+        .empty-state {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: var(--wa-color-neutral-text-subtle);
+            font-style: italic;
+        }
+
+        wa-icon {
+            flex-shrink: 0;
+        }
+    `;
+__decorateClass$4([
+  state()
+], LyraLogTerminal.prototype, "messages", 2);
+__decorateClass$4([
+  state()
+], LyraLogTerminal.prototype, "autoScroll", 2);
+__decorateClass$4([
+  state()
+], LyraLogTerminal.prototype, "filter", 2);
+LyraLogTerminal = __decorateClass$4([
+  customElement("lyra-log-terminal")
+], LyraLogTerminal);
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+const t = i18n("fastviews");
+let LyraFastViews = class extends LyraWidget {
+  constructor() {
+    super(...arguments);
+    this.target = "";
+    this.title = "";
+    this.disabled = false;
+    this.appearance = "plain";
+    this.size = "small";
+    this.placement = "bottom-start";
+    this.tabContributions = [];
+    this.drawerOpen = false;
+    this.drawerSize = "50vw";
+    this.drawerRef = createRef();
+    this.tabsRef = createRef();
+    this.resizeHandleRef = createRef();
+    this.resizing = null;
+  }
+  getDrawerTabsId() {
+    return `fastviews-drawer-tabs-${this.target}`;
+  }
+  handleTabClick(contribution) {
+    if (this.disabled) return;
+    if (this.containerId) {
+      const tabContainer = document.querySelector(`lyra-tabs#${this.containerId}`);
+      if (!tabContainer) {
+        console.error(`fastviews: Tab container with id "${this.containerId}" not found`);
+        return;
+      }
+      tabContainer.open(contribution);
+    } else {
+      this.drawerOpen = true;
+      this.updateComplete.then(() => {
+        const tabsContainer = this.tabsRef.value;
+        if (tabsContainer) {
+          tabsContainer.open(contribution);
+        }
+      });
+    }
+  }
+  handleDrawerHide() {
+    this.drawerOpen = false;
+  }
+  startResize(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    const drawer = this.drawerRef.value;
+    if (!drawer) return;
+    const getDrawerSize = () => {
+      const drawerPanel = drawer.shadowRoot?.querySelector('[part="panel"]');
+      if (drawerPanel && drawerPanel.offsetWidth > 0) {
+        return drawerPanel.offsetWidth;
+      }
+      const computedStyle = window.getComputedStyle(drawer);
+      const sizeValue = computedStyle.getPropertyValue("--size") || this.drawerSize;
+      const match = sizeValue.match(/^(\d+(?:\.\d+)?)(px|vw|vh|%)$/);
+      if (match) {
+        const value = parseFloat(match[1]);
+        const unit = match[2];
+        if (unit === "px") return value;
+        if (unit === "vw") return value / 100 * window.innerWidth;
+        if (unit === "vh") return value / 100 * window.innerHeight;
+        if (unit === "%") return value / 100 * window.innerWidth;
+      }
+      return 0;
+    };
+    let currentSize = getDrawerSize();
+    if (currentSize === 0) {
+      currentSize = window.innerWidth * 0.5;
+    }
+    const handleMouseMove = (moveEvent) => {
+      if (!this.resizing) return;
+      moveEvent.preventDefault();
+      moveEvent.stopPropagation();
+      if (this.resizing.rafId !== null) {
+        cancelAnimationFrame(this.resizing.rafId);
+      }
+      this.resizing.rafId = requestAnimationFrame(() => {
+        if (!this.resizing) return;
+        const delta = this.resizing.startX - moveEvent.clientX;
+        const newSize = Math.round(this.resizing.startSize + delta);
+        const minSize = 200;
+        const maxSize = Math.round(window.innerWidth * 0.9);
+        if (newSize >= minSize && newSize <= maxSize) {
+          this.drawerSize = `${newSize}px`;
+          const drawer2 = this.drawerRef.value;
+          if (drawer2) {
+            drawer2.style.setProperty("--size", this.drawerSize);
+            drawer2.style.setProperty("transition", "none");
+          }
+        }
+        this.resizing.rafId = null;
+      });
+    };
+    const handleMouseUp = () => {
+      if (this.resizing) {
+        if (this.resizing.rafId !== null) {
+          cancelAnimationFrame(this.resizing.rafId);
+          this.resizing.rafId = null;
+        }
+        document.removeEventListener("mousemove", this.resizing.handleMouseMove);
+        document.removeEventListener("mouseup", this.resizing.handleMouseUp);
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+        const drawer2 = this.drawerRef.value;
+        if (drawer2) {
+          drawer2.style.removeProperty("transition");
+        }
+        this.resizing = null;
+      }
+    };
+    this.resizing = {
+      startX: e.clientX,
+      startSize: currentSize,
+      handleMouseMove,
+      handleMouseUp,
+      rafId: null
+    };
+    document.addEventListener("mousemove", handleMouseMove, { passive: false });
+    document.addEventListener("mouseup", handleMouseUp, { passive: false });
+    document.body.style.cursor = "col-resize";
+    document.body.style.userSelect = "none";
+  }
+  doBeforeUI() {
+    if (this.target) {
+      this.loadTabContributions();
+      subscribe(TOPIC_CONTRIBUTEIONS_CHANGED, (event) => {
+        if (this.target && event.target === this.target) {
+          this.loadTabContributions();
+        }
+      });
+    }
+  }
+  loadTabContributions() {
+    if (!this.target) return;
+    const allContributions = contributionRegistry.getContributions(this.target);
+    this.tabContributions = allContributions.filter((c) => "name" in c);
+    this.requestUpdate();
+  }
+  renderTabContribution(contribution) {
+    return html`
+            <wa-dropdown-item 
+                @click=${() => this.handleTabClick(contribution)}>
+                <lyra-icon name="${contribution.icon || ""}" label="${contribution.label}" slot="icon"></lyra-icon>
+                ${contribution.label}
+            </wa-dropdown-item>
+        `;
+  }
+  render() {
+    if (!this.target) {
+      return nothing;
+    }
+    if (this.tabContributions.length === 0) {
+      return nothing;
+    }
+    return html`
+            <wa-dropdown placement=${this.placement}>
+                <wa-button 
+                    slot="trigger"
+                    appearance=${this.appearance}
+                    size=${this.size}
+                    ?disabled=${this.disabled}
+                    with-caret
+                    title=${this.title}>
+                    <lyra-icon slot="start" name="${this.icon}" label="${this.title}"></lyra-icon>
+                    <slot></slot>
+                </wa-button>
+                
+                ${this.title ? html`
+                    <h6 style="padding: var(--wa-space-xs) var(--wa-space-s); margin: 0; color: var(--wa-color-neutral-50); font-size: 0.75rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.05em;">
+                        ${this.title}
+                    </h6>
+                ` : nothing}
+                
+                ${this.tabContributions.map((c) => this.renderTabContribution(c))}
+            </wa-dropdown>
+
+            ${!this.containerId ? html`
+                <wa-drawer 
+                    ${ref(this.drawerRef)}
+                    label="${this.title || t("FAST_VIEWS")}"
+                    placement="end"
+                    ?open=${this.drawerOpen}
+                    @wa-hide=${this.handleDrawerHide}
+                    style="--size: ${this.drawerSize};">
+                    <div 
+                        ${ref(this.resizeHandleRef)}
+                        class="resize-handle"
+                        @mousedown=${this.startResize}>
+                    </div>
+                    <lyra-tabs 
+                        ${ref(this.tabsRef)}
+                        id="${this.getDrawerTabsId()}"
+                        style="width: 100%; height: 100%; display: flex; flex-direction: column;">
+                    </lyra-tabs>
+                </wa-drawer>
+            ` : nothing}
+        `;
+  }
+};
+LyraFastViews.styles = css`
+        :host {
+            display: inline-block;
+        }
+
+        wa-drawer {
+            position: relative;
+        }
+
+        wa-drawer::part(panel) {
+            position: relative;
+        }
+
+        .resize-handle {
+            position: absolute;
+            left: 0;
+            top: 0;
+            bottom: 0;
+            width: 4px;
+            cursor: col-resize;
+            z-index: 1000;
+            background: transparent;
+            transition: background-color 0.2s;
+            user-select: none;
+            touch-action: none;
+        }
+
+        .resize-handle:hover {
+            background: var(--wa-color-brand-fill-loud);
+        }
+
+        .resize-handle:active {
+            background: var(--wa-color-brand-fill-loud);
+        }
+    `;
+__decorateClass$3([
+  property()
+], LyraFastViews.prototype, "target", 2);
+__decorateClass$3([
+  property()
+], LyraFastViews.prototype, "title", 2);
+__decorateClass$3([
+  property()
+], LyraFastViews.prototype, "icon", 2);
+__decorateClass$3([
+  property({ type: Boolean })
+], LyraFastViews.prototype, "disabled", 2);
+__decorateClass$3([
+  property()
+], LyraFastViews.prototype, "appearance", 2);
+__decorateClass$3([
+  property()
+], LyraFastViews.prototype, "size", 2);
+__decorateClass$3([
+  property()
+], LyraFastViews.prototype, "placement", 2);
+__decorateClass$3([
+  property()
+], LyraFastViews.prototype, "containerId", 2);
+__decorateClass$3([
+  state()
+], LyraFastViews.prototype, "tabContributions", 2);
+__decorateClass$3([
+  state()
+], LyraFastViews.prototype, "drawerOpen", 2);
+__decorateClass$3([
+  state()
+], LyraFastViews.prototype, "drawerSize", 2);
+LyraFastViews = __decorateClass$3([
+  customElement("lyra-fastviews")
+], LyraFastViews);
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+function getDialogContainer() {
+  let container = document.getElementById("global-dialog-container");
+  if (!container) {
+    container = document.createElement("div");
+    container.id = "global-dialog-container";
+    document.body.appendChild(container);
+  }
+  return container;
+}
+const getLanguageName = (code) => {
+  try {
+    return new Intl.DisplayNames([code], { type: "language" }).of(code) || code.toUpperCase();
+  } catch {
+    return code.toUpperCase();
+  }
+};
+const getAvailableLanguages = () => {
+  const contributions = languageContributionsSignal.get();
+  const languages = /* @__PURE__ */ new Set();
+  for (const contribution of contributions) {
+    if (contribution.namespace) {
+      const contributionObj = contribution;
+      for (const key in contributionObj) {
+        if (key !== "namespace" && key !== "label" && key !== "language" && key !== "translations" && typeof contributionObj[key] === "object") {
+          languages.add(key);
+        }
+      }
+    }
+  }
+  return Array.from(languages).sort();
+};
+const showLanguageSelectorDialog = async () => {
+  const availableLanguages = getAvailableLanguages();
+  const currentLanguage = currentLanguageSignal.get();
+  return new Promise((resolve) => {
+    const container = getDialogContainer();
+    let isResolved = false;
+    const handleClose = () => {
+      const dialog = container.querySelector("wa-dialog");
+      if (dialog && !isResolved) {
+        dialog.open = false;
+      }
+    };
+    const handleAfterHide = () => {
+      if (isResolved) return;
+      isResolved = true;
+      render(html``, container);
+      resolve();
+    };
+    const selectLanguage = async (language) => {
+      await appSettings.set(SETTINGS_KEY_LANGUAGE, language);
+      handleClose();
+    };
+    const template = html`
+            <wa-dialog 
+                label="Select Language" 
+                open 
+                light-dismiss
+                @wa-request-close=${handleClose}
+                @wa-after-hide=${handleAfterHide}>
+                <style>
+                    .language-list {
+                        display: flex;
+                        flex-direction: column;
+                        gap: 0.5rem;
+                        padding: 1rem;
+                        min-width: 300px;
+                        max-height: 400px;
+                        overflow-y: auto;
+                    }
+                    
+                    .language-item {
+                        display: flex;
+                        align-items: center;
+                        padding: 0.75rem;
+                        border-radius: var(--wa-border-radius-small);
+                        cursor: pointer;
+                        transition: background-color 0.2s;
+                    }
+                    
+                    .language-item:hover {
+                        background-color: var(--wa-color-neutral-fill-quiet);
+                    }
+                    
+                    .language-item.active {
+                        background-color: var(--wa-color-brand-fill-quiet);
+                        font-weight: 600;
+                    }
+                    
+                    .language-code {
+                        font-family: monospace;
+                        margin-right: 0.75rem;
+                        min-width: 3rem;
+                        color: var(--wa-color-neutral-600);
+                    }
+                    
+                    .language-name {
+                        flex: 1;
+                    }
+                </style>
+                
+                <div class="language-list">
+                    ${availableLanguages.map((lang) => html`
+                        <div 
+                            class="language-item ${lang === currentLanguage ? "active" : ""}"
+                            @click=${() => selectLanguage(lang)}>
+                            <span class="language-code">${lang.toUpperCase()}</span>
+                            <span class="language-name">${getLanguageName(lang)}</span>
+                        </div>
+                    `)}
+                </div>
+            </wa-dialog>
+        `;
+    render(template, container);
+  });
+};
+let LyraLanguageSelector = class extends LyraElement {
+  render() {
+    const currentLanguage = currentLanguageSignal.get();
+    const languageName = getLanguageName(currentLanguage);
+    const buttonLabel = `${currentLanguage.toUpperCase()} ${languageName}`;
+    return html`
+            <wa-button 
+                appearance="plain" 
+                size="small"
+                title="Current language: ${languageName}"
+                @click=${() => showLanguageSelectorDialog()}>
+                ${buttonLabel}
+            </wa-button>
+        `;
+  }
+};
+LyraLanguageSelector.styles = css`
+        :host {
+            display: inline-block;
+        }
+    `;
+LyraLanguageSelector = __decorateClass$2([
+  customElement("lyra-language-selector")
+], LyraLanguageSelector);
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+const APP_SWITCHER_DIALOG_ID = "app-switcher";
+contributionRegistry.registerContribution(DIALOG_CONTRIBUTION_TARGET, {
+  id: APP_SWITCHER_DIALOG_ID,
+  label: "Switch Application",
+  buttons: [CLOSE_BUTTON],
+  component: (state2) => {
+    const apps = state2?.apps || [];
+    const currentAppId = state2?.currentAppId;
+    const selectApp = state2?.selectApp;
+    return html`
+            <wa-scroller orientation="vertical" style="min-width: 300px; max-height: 400px; padding: var(--wa-space-m);">
+                <div style="display: flex; flex-direction: column; gap: var(--wa-space-s);">
+                    ${apps.map((app) => html`
+                        <wa-card 
+                            style="cursor: pointer;"
+                            variant=${app.id === currentAppId ? "brand" : "neutral"}
+                            @click=${() => selectApp(app)}>
+                            <div style="display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: var(--wa-space-xs);">
+                                <span style="font-weight: 600;">${app.name}</span>
+                                ${app.version ? html`<wa-badge variant="neutral">v${app.version}</wa-badge>` : ""}
+                            </div>
+                            ${app.description ? html`<p style="margin: 0; font-size: 0.875rem; line-height: 1.4;">${app.description}</p>` : ""}
+                            <div style="font-size: 0.75rem; color: var(--wa-color-neutral-foreground-quiet); font-family: monospace; margin-top: var(--wa-space-xs);">ID: ${app.id}</div>
+                        </wa-card>
+                    `)}
+                </div>
+            </wa-scroller>
+        `;
+  },
+  onButton: async () => true
+});
+const showAppSwitcherDialog = async () => {
+  const apps = appLoaderService.getRegisteredApps();
+  const currentApp = appLoaderService.getCurrentApp();
+  if (apps.length === 0) {
+    return;
+  }
+  const state2 = {
+    apps,
+    currentAppId: currentApp?.id,
+    selectApp: async (app) => {
+      if (app.id === currentApp?.id) {
+        state2.close?.();
+        return;
+      }
+      try {
+        await appLoaderService.setPreferredAppId(app.id);
+        await appLoaderService.loadApp(app.id, document.body);
+      } catch (error) {
+        console.error("Failed to switch app:", error);
+      } finally {
+        state2.close?.();
+      }
+    },
+    close: void 0
+  };
+  await dialogService.open(APP_SWITCHER_DIALOG_ID, state2);
+};
+let LyraAppSwitcher = class extends LyraElement {
+  doBeforeUI() {
+    this.currentApp = appLoaderService.getCurrentApp();
+    const updateCurrentApp = () => {
+      this.currentApp = appLoaderService.getCurrentApp();
+      this.requestUpdate();
+    };
+    window.addEventListener("app-loaded", updateCurrentApp);
+    return () => {
+      window.removeEventListener("app-loaded", updateCurrentApp);
+    };
+  }
+  render() {
+    const apps = appLoaderService.getRegisteredApps();
+    const appName = this.currentApp?.name || "No App";
+    if (apps.length <= 1) {
+      return html``;
+    }
+    return html`
+            <wa-button 
+                appearance="plain" 
+                size="small"
+                title="Current app: ${appName}. Click to switch applications."
+                @click=${() => showAppSwitcherDialog()}>
+                <wa-icon name="grip" style="margin-right: 0.5rem;"></wa-icon>
+                ${appName}
+            </wa-button>
+        `;
+  }
+};
+LyraAppSwitcher.styles = css`
+        :host {
+            display: inline-block;
+        }
+    `;
+__decorateClass$1([
+  state()
+], LyraAppSwitcher.prototype, "currentApp", 2);
+LyraAppSwitcher = __decorateClass$1([
+  customElement("lyra-app-switcher")
+], LyraAppSwitcher);
+contributionRegistry.registerContribution(SIDEBAR_MAIN, {
+  name: "filebrowser",
+  label: "Workspace",
+  icon: "folder-open",
+  component: (id) => html`<lyra-filebrowser id="${id}"></lyra-filebrowser>`
+});
+contributionRegistry.registerContribution("system.fastviews-bottomend", {
+  name: "log-terminal",
+  label: "Log Messages",
+  icon: "list",
+  component: (id) => html`<lyra-log-terminal id="${id}"></lyra-log-terminal>`
+});
+contributionRegistry.registerContribution(TOOLBAR_BOTTOM_END, {
+  label: "Info",
+  icon: "circle-info",
+  command: "show_version_info",
+  showLabel: true
+});
+contributionRegistry.registerContribution(TOOLBAR_BOTTOM_END, {
+  label: `Fast Views`,
+  html: `<lyra-fastviews target="system.fastviews-bottomend" icon="bolt" title="Fast Views"></lyra-fastviews>`
+});
+contributionRegistry.registerContribution(TOOLBAR_BOTTOM_END, {
+  label: "Language",
+  html: () => html`<lyra-language-selector></lyra-language-selector>`
+});
+contributionRegistry.registerContribution(TOOLBAR_MAIN_RIGHT, {
+  label: "App Switcher",
+  html: () => html`<lyra-app-switcher></lyra-app-switcher>`
+});
+const logger = createLogger("MarketplaceCatalogContributions");
+logger.debug("Marketplace catalog URLs are set by the app host via applyAppHostConfig()");
+async function getWorkspaceAndPath(params, requirePath = true) {
+  const workspace = await workspaceService.getWorkspace();
+  if (!workspace) {
+    return null;
+  }
+  const path = params?.path;
+  if (requirePath && !path) {
+    return null;
+  }
+  return { workspace, path: path || "" };
+}
+function isEditorContentProvider(editor) {
+  return editor && typeof editor.getContent === "function" && typeof editor.getSelection === "function" && typeof editor.getSnippet === "function" && typeof editor.getLanguage === "function" && typeof editor.getFilePath === "function";
+}
+function createNullEditorResponse(includeCursorLine = false) {
+  const base = {
+    filePath: null,
+    language: null
+  };
+  if (includeCursorLine) {
+    return { ...base, snippet: null, cursorLine: null };
+  }
+  return base;
+}
+async function getWorkspaceAndFile(params, requirePath = true) {
+  const result = await getWorkspaceAndPath(params, requirePath);
+  if (!result) {
+    return null;
+  }
+  const { workspace, path } = result;
+  if (!path) {
+    return null;
+  }
+  try {
+    const resource = await workspace.getResource(path);
+    if (!resource || !(resource instanceof File)) {
+      return null;
+    }
+    return { workspace, path, file: resource };
+  } catch (err) {
+    return null;
+  }
+}
+registerAll({
+  command: {
+    "id": "disconnect_folder",
+    "name": "Disconnect folder",
+    "description": "Disconnects a folder from the workspace"
+  },
+  handler: {
+    execute: async () => {
+      const selection = activeSelectionSignal.get();
+      if (!(selection instanceof Directory && selection.getParent() === void 0)) {
+        toastError("Select a folder root to disconnect.");
+        return;
+      }
+      try {
+        await workspaceService.disconnectFolder(selection);
+      } catch (err) {
+        toastError(err.message);
+      }
+    }
+  },
+  contribution: {
+    target: "contextmenu:filebrowser",
+    label: "Disconnect folder",
+    icon: "folder-minus",
+    disabled: () => {
+      const selection = activeSelectionSignal.get();
+      return !(selection instanceof Directory && selection.getParent() === void 0);
+    }
+  }
+});
+registerAll({
+  command: {
+    "id": "load_workspace",
+    "name": "Local Folder",
+    "description": "Connect to a local folder using File System Access API",
+    "parameters": []
+  },
+  handler: {
+    execute: async (_context) => {
+      await window.showDirectoryPicker({
+        mode: "readwrite"
+      }).then((dirHandle) => {
+        return workspaceService.connectWorkspace(dirHandle);
+      }).catch((err) => {
+        toastError(err.message);
+      });
+    }
+  },
+  contribution: {
+    target: "filebrowser.connections",
+    label: "Local Folder",
+    icon: "folder-open"
+  }
+});
+registerAll({
+  command: {
+    "id": "connect_opfs",
+    "name": "OPFS",
+    "description": "Connect to Origin Private File System (browser storage)",
+    "parameters": []
+  },
+  handler: {
+    execute: async () => {
+      try {
+        await workspaceService.connectFolder({ opfs: true });
+      } catch (err) {
+        toastError(err.message);
+      }
+    }
+  },
+  contribution: {
+    target: "filebrowser.connections",
+    label: "OPFS (Browser Storage)",
+    icon: "database"
+  }
+});
+registerAll({
+  command: {
+    "id": "connect_indexeddb",
+    "name": "IndexedDB",
+    "description": "Connect to IndexedDB-backed workspace (browser storage)",
+    "parameters": [
+      {
+        "name": "name",
+        "description": "Optional display name for this IndexedDB workspace root",
+        "required": false
+      }
+    ]
+  },
+  handler: {
+    execute: async (context) => {
+      const nameParam = context.params?.["name"];
+      try {
+        await workspaceService.connectFolder({ indexeddb: true, name: nameParam });
+      } catch (err) {
+        toastError(err.message);
+      }
+    }
+  },
+  contribution: {
+    target: "filebrowser.connections",
+    label: "IndexedDB (Browser Storage)",
+    icon: "database"
+  }
+});
+registerAll({
+  command: {
+    "id": "refresh_resource",
+    "name": "Refresh resource",
+    "description": "Refreshes the connected folder of the selected resource, or the whole workspace if nothing is selected",
+    "parameters": []
+  },
+  handler: {
+    execute: async () => {
+      const selection = activeSelectionSignal.get();
+      if (selection) {
+        selection.getWorkspace().touch();
+        return;
+      }
+      const workspace = await workspaceService.getWorkspace();
+      if (!workspace) {
+        toastError("No workspace selected.");
+        return;
+      }
+      workspace.touch();
+    }
+  }
+});
+registerAll({
+  command: {
+    "id": "open_editor",
+    "name": "Open editor",
+    "description": "Opens a file in an editor",
+    "parameters": [
+      {
+        "name": "path",
+        "description": "The path of the file to open within the workspace; if omitted, the active selection is opened",
+        "required": false
+      },
+      {
+        "name": "editorId",
+        "description": "Open with this editor id; if omitted, use default editor",
+        "required": false
+      }
+    ]
+  },
+  handler: {
+    execute: async (context) => {
+      const path = context.params?.["path"];
+      const editorId = context.params?.["editorId"];
+      let file = null;
+      if (path) {
+        const result = await getWorkspaceAndFile({ path });
+        file = result?.file ?? null;
+      } else {
+        const selection = activeSelectionSignal.get();
+        file = selection instanceof File ? selection : null;
+      }
+      if (!file) return;
+      await editorRegistry.loadEditor(file, editorId);
+    }
+  }
+});
+registerAll({
+  command: {
+    "id": "get_active_editor_content",
+    "name": "Get active editor content",
+    "description": "Gets the complete contents of the currently active editor. Returns null if no editor is active or if the editor is not a code editor.",
+    "parameters": [],
+    "output": [
+      {
+        "name": "content",
+        "description": "the complete contents of the active editor, or null if no editor is active"
+      },
+      {
+        "name": "filePath",
+        "description": "the workspace path of the file in the active editor, or null if no editor is active"
+      },
+      {
+        "name": "language",
+        "description": "the programming language of the active editor, or null if no editor is active"
+      }
+    ]
+  },
+  handler: {
+    execute: async (context) => {
+      const activeEditor = context.activeEditor;
+      if (!isEditorContentProvider(activeEditor)) {
+        return { ...createNullEditorResponse(), content: null };
+      }
+      try {
+        return {
+          content: activeEditor.getContent(),
+          filePath: activeEditor.getFilePath(),
+          language: activeEditor.getLanguage()
+        };
+      } catch (err) {
+        return { ...createNullEditorResponse(), content: null };
+      }
+    }
+  }
+});
+registerAll({
+  command: {
+    "id": "get_active_editor_selection",
+    "name": "Get active editor selection",
+    "description": "Gets the currently selected text in the active editor. Returns null if no editor is active, no selection exists, or if the editor is not a code editor.",
+    "parameters": [],
+    "output": [
+      {
+        "name": "selection",
+        "description": "the selected text in the active editor, or null if no selection exists or no editor is active"
+      },
+      {
+        "name": "filePath",
+        "description": "the workspace path of the file in the active editor, or null if no editor is active"
+      },
+      {
+        "name": "language",
+        "description": "the programming language of the active editor, or null if no editor is active"
+      }
+    ]
+  },
+  handler: {
+    execute: async (context) => {
+      const activeEditor = context.activeEditor;
+      if (!isEditorContentProvider(activeEditor)) {
+        return { ...createNullEditorResponse(), selection: null };
+      }
+      try {
+        return {
+          selection: activeEditor.getSelection(),
+          filePath: activeEditor.getFilePath(),
+          language: activeEditor.getLanguage()
+        };
+      } catch (err) {
+        return { ...createNullEditorResponse(), selection: null };
+      }
+    }
+  }
+});
+registerAll({
+  command: {
+    "id": "get_active_editor_snippet",
+    "name": "Get active editor snippet around cursor",
+    "description": "Gets a code snippet from the active editor with n lines before and n lines after the cursor position. Useful for getting context around the cursor without loading the entire file.",
+    "parameters": [
+      {
+        "name": "lines",
+        "description": "number of lines to include before and after the cursor position (default: 5)",
+        "type": "number",
+        "required": false
+      }
+    ],
+    "output": [
+      {
+        "name": "snippet",
+        "description": "the code snippet with n lines before and after the cursor, or null if no editor is active"
+      },
+      {
+        "name": "filePath",
+        "description": "the workspace path of the file in the active editor, or null if no editor is active"
+      },
+      {
+        "name": "language",
+        "description": "the programming language of the active editor, or null if no editor is active"
+      },
+      {
+        "name": "cursorLine",
+        "description": "the line number where the cursor is positioned (1-based), or null if no editor is active"
+      }
+    ]
+  },
+  handler: {
+    execute: async (context) => {
+      const activeEditor = context.activeEditor;
+      if (!isEditorContentProvider(activeEditor)) {
+        return createNullEditorResponse(true);
+      }
+      try {
+        const numLines = context.params?.lines ? parseInt(context.params.lines, 10) : 5;
+        if (isNaN(numLines) || numLines < 0) {
+          return createNullEditorResponse(true);
+        }
+        const snippetResult = activeEditor.getSnippet(numLines);
+        if (!snippetResult) {
+          return createNullEditorResponse(true);
+        }
+        return {
+          snippet: snippetResult.snippet,
+          filePath: activeEditor.getFilePath(),
+          language: activeEditor.getLanguage(),
+          cursorLine: snippetResult.cursorLine
+        };
+      } catch (err) {
+        return createNullEditorResponse(true);
+      }
+    }
+  }
+});
+registerAll({
+  command: {
+    "id": "show_version_info",
+    "name": "Show Version Info",
+    "description": "Shows application version information",
+    "parameters": []
+  },
+  handler: {
+    execute: async (_context) => {
+      const app = appLoaderService.getCurrentApp();
+      if (!app) {
+        toastError("No app loaded");
+        return;
+      }
+      const hasPackages = packageInfoService.hasPackages();
+      const packagesTree = packageInfoService.renderTree();
+      let dialogContainer = null;
+      const getDialogContainer2 = () => {
+        if (!dialogContainer) {
+          dialogContainer = document.getElementById("global-dialog-container") || document.createElement("div");
+          if (!dialogContainer.id) {
+            dialogContainer.id = "global-dialog-container";
+            document.body.appendChild(dialogContainer);
+          }
+        }
+        return dialogContainer;
+      };
+      const cleanup = () => {
+        if (dialogContainer) {
+          render(html``, dialogContainer);
+        }
+      };
+      const renderReleaseContent = (releaseContent) => {
+        const htmlContent = marked.parse(releaseContent, { async: false });
+        return html`${unsafeHTML(htmlContent)}`;
+      };
+      let releases = [];
+      if (app.releaseHistory) {
+        if (typeof app.releaseHistory === "function") {
+          try {
+            releases = await app.releaseHistory();
+          } catch (error) {
+            console.error("Failed to load release history from app:", error);
+            releases = [];
+          }
+        } else {
+          releases = app.releaseHistory;
+        }
+      }
+      app.version === "0.0.0";
+      const currentIndex = releases.length > 0 ? releases.findIndex((r) => r.tag_name === app.version) : -1;
+      const startIndex = currentIndex >= 0 ? currentIndex : 0;
+      let currentReleaseIndex = startIndex;
+      const buildReleaseContent = (index) => {
+        if (releases.length === 0) {
+          return "";
+        }
+        const release = releases[index];
+        const isCurrentVersion = release.tag_name === app.version;
+        let message = `**Version:** ${release.tag_name}`;
+        if (isCurrentVersion) {
+          message += ` (Current)`;
+        }
+        message += `
+
+`;
+        const publishDate = new Date(release.published_at).toLocaleDateString();
+        message += `**Released:** ${publishDate}
+
+`;
+        if (!isCurrentVersion) {
+          const cleanCurrent = app.version.replace(/^v/, "");
+          const cleanRelease = release.tag_name.replace(/^v/, "");
+          const currentParts = cleanCurrent.split(".").map(Number);
+          const releaseParts = cleanRelease.split(".").map(Number);
+          let isNewer = false;
+          for (let i = 0; i < Math.max(currentParts.length, releaseParts.length); i++) {
+            const current = currentParts[i] || 0;
+            const releasePart = releaseParts[i] || 0;
+            if (releasePart > current) {
+              isNewer = true;
+              break;
+            }
+            if (releasePart < current) {
+              break;
+            }
+          }
+          if (isNewer) {
+            message += `⚠️ **Update available - reload page to update**
+
+`;
+          }
+        }
+        if (release.body) {
+          message += `---
+
+${release.body}`;
+        }
+        return message;
+      };
+      const handleClose = () => {
+        cleanup();
+      };
+      const handleAfterHide = () => {
+        cleanup();
+      };
+      const updateDialog = (index) => {
+        const releaseContent = buildReleaseContent(index);
+        const hasNavigation = releases.length > 0;
+        const template = html`
+                    <wa-dialog 
+                        label="About ${app.name} - ${app.version}"
+                        open 
+                        light-dismiss
+                        style="--width: 600px;"
+                        @wa-request-close=${handleClose}
+                        @wa-after-hide=${handleAfterHide}
+                    >
+                        <style>
+                            .dialog-content {
+                                height: 600px;
+                            }
+                            
+                            wa-tree-item > span small {
+                                color: var(--wa-color-neutral-60);
+                                font-size: 0.875em;
+                                margin-left: 0.5rem;
+                            }
+                        </style>
+                        <small>${app.description}</small>
+                        <div class="dialog-content">
+                            <wa-tab-group>
+                                ${releases.length > 0 ? html`
+                                    <wa-tab slot="nav" panel="release">Release History</wa-tab>
+                                    <wa-tab-panel name="release">
+                                        ${renderReleaseContent(releaseContent)}
+                                    </wa-tab-panel>
+                                ` : ""}
+                                
+                                ${hasPackages ? html`
+                                    <wa-tab slot="nav" panel="packages">NPM Packages</wa-tab>
+                                    <wa-tab-panel name="packages">
+                                        ${packagesTree}
+                                    </wa-tab-panel>
+                                ` : ""}
+                            </wa-tab-group>
+                        </div>
+                        <div slot="footer">
+                            ${hasNavigation ? html`
+                                <wa-button 
+                                    variant="default"
+                                    ?disabled=${index === releases.length - 1}
+                                    @click=${() => {
+          if (index < releases.length - 1) {
+            currentReleaseIndex = index + 1;
+            updateDialog(currentReleaseIndex);
+          }
+        }}
+                                >
+                                    ← Previous
+                                </wa-button>
+                                <wa-button 
+                                    variant="default"
+                                    ?disabled=${index === 0}
+                                    @click=${() => {
+          if (index > 0) {
+            currentReleaseIndex = index - 1;
+            updateDialog(currentReleaseIndex);
+          }
+        }}
+                                >
+                                    Next →
+                                </wa-button>
+                            ` : ""}
+                            <wa-button variant="primary" data-dialog="close">Close</wa-button>
+                        </div>
+                    </wa-dialog>
+                `;
+        render(template, getDialogContainer2());
+      };
+      updateDialog(startIndex);
+      return new Promise((resolve) => {
+        const checkClosed = () => {
+          if (!dialogContainer?.querySelector("wa-dialog[open]")) {
+            resolve();
+          } else {
+            setTimeout(checkClosed, 100);
+          }
+        };
+        checkClosed();
+      });
+    }
+  }
+});
+registerAll({
+  command: {
+    "id": "save",
+    "name": "Save editor",
+    "description": "Saves the active/focused editor",
+    "keyBinding": "CTRL+S",
+    "parameters": []
+  },
+  handler: {
+    execute: async (_context) => {
+      const part = activeEditorSignal.get() || activePartSignal.get();
+      if (part && part.isDirty()) {
+        part.save();
+      }
+    }
+  },
+  contribution: {
+    target: "toolbar:.system.editors",
+    icon: "floppy-disk",
+    label: "Save active editor",
+    slot: "start",
+    disabled: () => {
+      const part = activePartSignal.get();
+      return !part || !part.isDirty();
+    }
+  }
+});
+const THEME_SETTINGS_KEY = "theme";
+async function applyTheme(themeClass) {
+  const root = document.documentElement;
+  root.classList.remove("wa-dark", "wa-light");
+  root.classList.add(themeClass);
+}
+async function loadTheme() {
+  const theme = await appSettings.get(THEME_SETTINGS_KEY);
+  await applyTheme(theme || "wa-dark");
+}
+async function saveTheme(themeClass) {
+  await appSettings.set(THEME_SETTINGS_KEY, themeClass);
+}
+registerAll({
+  command: {
+    "id": "switch_theme",
+    "name": "Switch theme",
+    "description": "Switches between dark and light theme",
+    "parameters": []
+  },
+  handler: {
+    execute: async (_context) => {
+      const isDark = document.documentElement.classList.contains("wa-dark");
+      const newTheme = isDark ? "wa-light" : "wa-dark";
+      await applyTheme(newTheme);
+      await saveTheme(newTheme);
+    }
+  },
+  contribution: {
+    target: TOOLBAR_MAIN_RIGHT,
+    icon: "circle-half-stroke",
+    label: "Theme Switcher"
+  }
+});
+loadTheme().catch((err) => {
+  console.error("Failed to load theme preference:", err);
+});
+registerAll({
+  command: {
+    "id": "fullscreen",
+    "name": "Toggle fullscreen",
+    "description": "Toggles fullscreen mode",
+    "parameters": []
+  },
+  handler: {
+    execute: async (_context) => {
+      if (document.fullscreenElement === document.body) {
+        await document.exitFullscreen();
+      } else {
+        await document.body.requestFullscreen();
+      }
+    }
+  },
+  contribution: {
+    target: TOOLBAR_MAIN_RIGHT,
+    icon: "expand",
+    label: "Fullscreen"
+  }
+});
+registerAll({
+  command: {
+    "id": "open_extensions",
+    "name": "Open Extensions",
+    "description": "Opens the extensions registry",
+    "parameters": []
+  },
+  handler: {
+    execute: (_context) => {
+      const editorInput = {
+        title: "Extensions",
+        data: {},
+        key: "system.extensions",
+        icon: "puzzle-piece",
+        state: {},
+        noOverflow: true,
+        widgetFactory: () => html`<lyra-extensions></lyra-extensions>`
+      };
+      editorRegistry.loadEditor(editorInput, "extensions-editor").then();
+    }
+  },
+  contribution: {
+    target: TOOLBAR_MAIN_RIGHT,
+    icon: "puzzle-piece",
+    label: "Open Extensions"
+  }
+});
+registerAll({
+  command: {
+    "id": "list_extensions",
+    "name": "List extensions",
+    "description": "Lists all available extensions with their status (enabled/disabled)",
+    "parameters": [],
+    "output": [
+      {
+        "name": "extensions",
+        "description": "array of extension objects with id, name, description, experimental flag, and enabled status"
+      }
+    ]
+  },
+  handler: {
+    execute: async (_context) => {
+      const extensions = extensionRegistry.getExtensions().map((e) => {
+        return {
+          id: e.id,
+          name: e.name,
+          description: e.description,
+          experimental: e.experimental,
+          enabled: extensionRegistry.isEnabled(e.id)
+        };
+      });
+      return extensions;
+    }
+  }
+});
+registerAll({
+  command: {
+    "id": "toast_message",
+    "name": "Toast message to user",
+    "description": "Shows a toast message",
+    "parameters": [
+      {
+        "name": "message",
+        "description": "the message to toast",
+        "required": true
+      },
+      {
+        "name": "type",
+        "description": "the toast type: info (default), or error",
+        "required": false
+      }
+    ]
+  },
+  handler: {
+    execute: ({ params: { message, type } }) => {
+      if (!message) {
+        return;
+      }
+      if (type === "error") {
+        toastError(message);
+      } else {
+        toastInfo(message);
+      }
+    }
+  }
+});
+registerAll({
+  command: {
+    id: "open_view_as_editor",
+    name: "Open view as editor",
+    description: "Opens a dashboard view in the editor area",
+    parameters: [
+      { name: "name", description: "View contribution name", required: true },
+      { name: "sourceContributionSlot", description: "source contribution slot (default: SYSTEM_VIEWS)", required: false }
+    ]
+  },
+  handler: {
+    execute: async ({ params }) => {
+      const name = params?.name;
+      if (!name) return;
+      const slot = params?.sourceContributionSlot ?? SYSTEM_VIEWS;
+      const contributions = contributionRegistry.getContributions(slot);
+      const contribution = contributions.find((c) => c.name === name);
+      if (!contribution?.component) return;
+      await editorRegistry.openTab(contribution);
+    }
+  }
+});
+rootContext.put("constants", constants);
+uiContext.put("html", html);
+uiContext.put("render", render);
+uiContext.put("toastInfo", toastInfo);
+uiContext.put("toastError", toastError);
+uiContext.put("toastWarning", toastWarning);
+let applied = false;
+function applyAppHostConfig(config) {
+  if (applied) return;
+  applied = true;
+  if (config.packageInfo) {
+    packageInfoService.addPackage(config.packageInfo);
+  }
+  if (config.marketplaceCatalogUrls?.length) {
+    config.marketplaceCatalogUrls.forEach((url) => {
+      marketplaceRegistry.addCatalogUrl(url).catch(() => {
+      });
+    });
+  }
+}
+let frameworkConfig = {};
+function configureFramework(config) {
+  frameworkConfig = { ...frameworkConfig, ...config };
+}
+function getFrameworkConfig() {
+  return { ...frameworkConfig };
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let LyraStandardLayout = class extends LyraContainer {
+  constructor() {
+    super(...arguments);
+    this.showBottomSidebar = false;
+    this.showBottomPanel = false;
+    this.showLeftSidebar = true;
+    this.showAuxSidebar = true;
+  }
+  createRenderRoot() {
+    return this;
+  }
+  getGridSizes() {
+    if (this.showLeftSidebar && this.showAuxSidebar) {
+      return "15%, 65%, 20%";
+    }
+    if (this.showLeftSidebar) {
+      return "15%, 85%";
+    }
+    if (this.showAuxSidebar) {
+      return "80%, 20%";
+    }
+    return "100%";
+  }
+  render() {
+    return html`
+            <style>
+                *, *::before, *::after {
+                    box-sizing: border-box;
+                }
+                
+                html {
+                    height: 100%;
+                    margin: 0;
+                    padding: 0;
+                    overflow: hidden;
+                }
+                
+                body {
+                    height: 100%;
+                    width: 100%;
+                    margin: 0;
+                    padding: 0;
+                    overflow: hidden;
+                    display: flex;
+                    flex-direction: column;
+                }
+                
+                lyra-standard-layout {
+                    display: flex;
+                    flex-direction: column;
+                    height: 100vh;
+                    width: 100%;
+                }
+                
+                lyra-standard-layout .toolbar-top {
+                    width: 100%;
+                    display: grid;
+                    grid-template-columns: 1fr 2fr 1fr;
+                    align-items: center;
+                    border-bottom: solid var(--wa-border-width-s) var(--wa-color-neutral-border-loud);
+                    flex-shrink: 0;
+                }
+                
+                lyra-standard-layout .toolbar-bottom {
+                    width: 100%;
+                    border-top: solid var(--wa-border-width-s) var(--wa-color-neutral-border-loud);
+                    display: grid;
+                    grid-template-columns: 1fr 2fr auto;
+                    align-items: center;
+                    flex-shrink: 0;
+                    min-height: 32px;
+                    padding: 0 var(--wa-space-s);
+                    box-sizing: border-box;
+                }
+                
+                lyra-standard-layout .main-layout {
+                    flex: 1;
+                    min-height: 0;
+                }
+                
+                lyra-standard-layout .toolbar-end {
+                    justify-self: end;
+                }
+            </style>
+            
+            <div class="toolbar-top">
+                <lyra-toolbar id=${TOOLBAR_MAIN}></lyra-toolbar>
+                <lyra-toolbar id=${TOOLBAR_MAIN_CENTER}></lyra-toolbar>
+                <lyra-toolbar class="toolbar-end" id=${TOOLBAR_MAIN_RIGHT}></lyra-toolbar>
+            </div>
+            
+            <lyra-resizable-grid 
+                class="main-layout"
+                id="main-layout" 
+                orientation="horizontal" 
+                sizes=${this.getGridSizes()}>
+                
+                ${this.showLeftSidebar ? html`
+                        ${this.showBottomSidebar ? html`
+                                <lyra-resizable-grid 
+                                    id="left-sidebar-split" 
+                                    orientation="vertical" 
+                                    sizes="50%, 50%">
+                                    <lyra-tabs id="${SIDEBAR_MAIN}"></lyra-tabs>
+                                    <lyra-tabs id="${SIDEBAR_MAIN_BOTTOM}"></lyra-tabs>
+                                </lyra-resizable-grid>
+                            ` : html`<lyra-tabs id="${SIDEBAR_MAIN}"></lyra-tabs>`}
+                    ` : nothing}
+                
+                ${this.showBottomPanel ? html`
+                        <lyra-resizable-grid 
+                            id="editor-area-split" 
+                            orientation="vertical" 
+                            sizes="70%, 30%">
+                            <lyra-tabs id="${EDITOR_AREA_MAIN}"></lyra-tabs>
+                            <lyra-tabs id="${PANEL_BOTTOM}"></lyra-tabs>
+                        </lyra-resizable-grid>
+                    ` : html`<lyra-tabs id="${EDITOR_AREA_MAIN}"></lyra-tabs>`}
+                
+                ${this.showAuxSidebar ? html`<lyra-tabs id="${SIDEBAR_AUXILIARY}"></lyra-tabs>` : nothing}
+            </lyra-resizable-grid>
+            
+            <div class="toolbar-bottom">
+                <lyra-toolbar id=${TOOLBAR_BOTTOM}></lyra-toolbar>
+                <lyra-toolbar id=${TOOLBAR_BOTTOM_CENTER}></lyra-toolbar>
+                <lyra-toolbar class="toolbar-end" id=${TOOLBAR_BOTTOM_END}></lyra-toolbar>
+            </div>
+        `;
+  }
+};
+__decorateClass([
+  property({ type: Boolean, attribute: "show-bottom-sidebar" })
+], LyraStandardLayout.prototype, "showBottomSidebar", 2);
+__decorateClass([
+  property({ type: Boolean, attribute: "show-bottom-panel" })
+], LyraStandardLayout.prototype, "showBottomPanel", 2);
+__decorateClass([
+  property({ type: Boolean, attribute: "show-left-sidebar" })
+], LyraStandardLayout.prototype, "showLeftSidebar", 2);
+__decorateClass([
+  property({ type: Boolean, attribute: "show-aux-sidebar" })
+], LyraStandardLayout.prototype, "showAuxSidebar", 2);
+LyraStandardLayout = __decorateClass([
+  customElement("lyra-standard-layout")
+], LyraStandardLayout);
+export {
+  CompositeDirectory as C,
+  Directory as D,
+  File as F,
+  LyraStandardLayout as L,
+  SYSTEM_LANGUAGE_BUNDLES as S,
+  TOPIC_WORKSPACE_CHANGED as T,
+  WorkspaceService as W,
+  FileContentType as a,
+  FileSysDirHandleResource as b,
+  StringFile as c,
+  TOPIC_WORKSPACE_CONNECTED as d,
+  applyAppHostConfig as e,
+  configureFramework as f,
+  editorRegistry as g,
+  getFrameworkConfig as h,
+  i18n as i,
+  i18nLazy as j,
+  packageInfoService as p,
+  treeNodeComparator as t,
+  workspaceService as w
+};
+//# sourceMappingURL=standard-layout-BSGa06lP.js.map