@mudlet/mudlet-web 0.3.1 → 0.4.0

package/dist-lib/ui/video/VideoManager.d.ts

@@ -1,4 +1,5 @@
 import type { MediaCaptionInfo } from '../sound/closedCaption';
+import type { MediaOrigin } from '../sound/SoundManager';
 type LoaderFn = (path: string) => Promise<ArrayBuffer | null>;
 export interface PlayVideoOptions {
     name: string;
@@ -11,6 +12,10 @@ export interface PlayVideoOptions {
     height?: string;
     /** Optional closed-caption text (Mudlet's media `caption`). */
     caption?: string;
+    /** Which mute gate governs this playback. Default 'api' — the only way to
+     *  reach a video today is Lua's `playVideoFile`, but GMCP `Client.Media`
+     *  defines a video type, so the gate is parameterised like the sounds'. */
+    origin?: MediaOrigin;
 }
 export declare class VideoManager {
     private loader;
@@ -20,6 +25,14 @@ export declare class VideoManager {
     private active;
     /** Buffers fetched ahead of play via loadVideoFile, keyed by VFS path. */
     private prefetched;
+    /**
+     * Per-origin mute gates, the video half of {@link SoundManager}'s. A muted
+     * origin's videos keep playing (picture and position both advance) with the
+     * element muted, and new ones start muted — nothing is stopped, so unmuting
+     * restores audio mid-clip. `volume` is left alone so `getPlayingVideos`
+     * still reports what the script asked for.
+     */
+    private muted;
     /** Fires when a video ends naturally or is stopped — mirrors Mudlet's
      *  sysMediaFinished. */
     onEnded: ((name: string, path: string) => void) | null;
@@ -28,6 +41,10 @@ export declare class VideoManager {
     onMediaCaption: ((info: MediaCaptionInfo) => void) | null;
     setLoader(fn: LoaderFn | null): void;
     setMountPoint(fn: (() => HTMLElement | null) | null): void;
+    /** Mudlet `muteMediaAPI` / `muteMediaGame`, applied to video playback. See
+     *  {@link muted}; the sound-side twin is `SoundManager.setOriginMuted`. */
+    setOriginMuted(origin: MediaOrigin, muted: boolean): void;
+    isOriginMuted(origin: MediaOrigin): boolean;
     /**
      * Mudlet `loadVideoFile`. Preloads (fetches + caches) a VFS-backed video so
      * the first playVideoFile has no fetch latency. http(s)/data/blob URLs need

package/dist-lib/ui/windows/WindowManager.d.ts

@@ -1,7 +1,7 @@
 import { type OutputRendererControls } from '../output/OutputRenderer';
 import type { Console } from '../../mud/text/Console';
 import type { AnsiAwareBuffer } from '../../mud/text/FormatState';
-import type { DockSide, WindowHandle, WindowOpenOptions, ScriptWindowRenderData } from './types';
+import type { DockSide, MxpTabPage, WindowHandle, WindowOpenOptions, ScriptWindowRenderData } from './types';
 import { MapStore } from '../../map/MapStore';
 import { OverlayLayerOrder } from '../layout/overlayLayerOrder';
 /** Live handle onto a mounted map renderer, registered by MapPanel. Backs the
@@ -103,6 +103,17 @@ export declare class WindowManager {
      *  from openUserWindow panels for windowType() reporting. */
     private mainViewportEl;
     private readonly miniConsoles;
+    /** MXP `<FRAME>` tab strips, keyed by the frame that hosts the strip. Each
+     *  page is another frame's console nested inside this one's viewport, so
+     *  switching tabs just swaps which child is visible. Purely transient — MXP
+     *  frames are torn down on reconnect and never persisted to a layout hint. */
+    private readonly frameTabs;
+    /** Consoles backing an MXP `<FRAME>`. They render with a hairline border,
+     *  the way Mudlet outlines every frame container (TMxpFrameManager's
+     *  `1px solid #444444`), so a server's panes read as separate panes. */
+    private readonly mxpFrameIds;
+    /** See getMxpBorders. */
+    private mxpBorders;
     private consoleRegistry;
     private windowHints;
     private nextZ;
@@ -359,7 +370,7 @@ export declare class WindowManager {
     private readonly mapViews;
     /** View ids start at 1 — Mudlet treats 0 as "no view". */
     private nextMapViewId;
-    /** The window id backing a map view. */
+    /** The window id backing a map view. Reserved to the client — see types.ts. */
     private static mapViewWindowId;
     /**
      * Mudlet `createMapView([areaID])` — open a secondary map window. Returns
@@ -529,6 +540,38 @@ export declare class WindowManager {
     loadMapXml(xmlText: string): boolean;
     markAsMiniConsole(id: string): void;
     isMiniConsole(id: string): boolean;
+    /** Flag a console as an MXP frame so it renders with a frame border. Also
+     *  hides its scrollbar: Mudlet's frames are `TConsole::SubConsole`s, which
+     *  start with theirs hidden, and no MXP server ever calls enableScrollBar.
+     *  Idempotent — the layout re-places a frame on every reflow. */
+    markAsMxpFrame(id: string): void;
+    /** Install (or replace) an MXP frame's tab strip. An empty `pages` list
+     *  removes it. Pages other than the active one are hidden, which keeps their
+     *  panel mounted — the content pool renders every open window regardless of
+     *  visibility, so a background tab keeps its scrollback. */
+    setFrameTabs(id: string, pages: MxpTabPage[], active: string): void;
+    /** Switch an MXP frame's visible tab. Ignored for an unknown strip or page. */
+    selectFrameTab(id: string, pageId: string): void;
+    getFrameTabs(id: string): {
+        pages: MxpTabPage[];
+        active: string;
+    } | undefined;
+    /** Pixel insets MXP frames have carved out of the main console. Kept apart
+     *  from the profile's setBorder* sizes (Mudlet splits them the same way, as
+     *  Host::mUserBorders vs mMxpBorders) so a server layout never overwrites
+     *  what a script or the settings modal set — OutputArea adds the two. */
+    getMxpBorders(): {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    setMxpBorders(borders: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }): void;
     getRoomIDbyHash(hash: string): number | undefined;
     setPosition(id: string, x: number, y: number): void;
     /** Mudlet setWindow for miniconsole / mapper panels — re-portal the panel
@@ -544,6 +587,24 @@ export declare class WindowManager {
      *  override and lets the inherited font take over. */
     setFont(id: string, family: string): boolean;
     getFont(id: string): string | null;
+    /** Pin a console's rendered row height, in px. Consoles normally lay rows
+     *  out at the stylesheet's `line-height`, which is roomier than the type
+     *  itself; an MXP frame instead has to match Mudlet's row metric
+     *  (`TTextEdit::mFontHeight` = ascent + descent), because its whole geometry
+     *  contract is "this many rows fit in this box". Undefined restores the
+     *  stylesheet default. */
+    setLineHeight(id: string, px: number | undefined): boolean;
+    /** Pin a console back to the first line. Consoles are scrollbacks and follow
+     *  the tail, which is wrong for a pane the server rewrites wholesale: such a
+     *  redraw arrives over several network flushes, so following the tail makes
+     *  the content visibly slide as the rows land, then snap back on the next
+     *  clear. No-op before the panel mounts. */
+    scrollToTop(id: string): void;
+    /** Consoles pinned to their first row rather than following the tail. See
+     *  scrollToTop; TextPanel reads this live through the renderer's followTail. */
+    private readonly topAnchored;
+    setTopAnchored(id: string, anchored: boolean): void;
+    isTopAnchored(id: string): boolean;
     /** Mudlet setWindowWrap. 0 (or any non-positive value) clears the override. */
     setWrap(id: string, wrapAt: number): boolean;
     getWrap(id: string): number | null;
@@ -561,6 +622,14 @@ export declare class WindowManager {
      *  on a console wrapper. Wheel/keyboard scrolling continues regardless; only
      *  the gutter rendering is affected. Persists across mounts; idempotent. */
     setScrollBarVisible(id: string, visible: boolean): void;
+    /**
+     * Mudlet `getScrollBarVisible([window])`. Reads back the *intent* set by
+     * enable/disableScrollBar rather than whether a gutter is on screen right
+     * now: a console that is hidden still answers for the scroll bar it will
+     * have when shown. Only the main window starts with one — a miniconsole is
+     * created without, as in Mudlet.
+     */
+    scrollBarVisible(id: string): boolean;
     /** Mudlet enable/disableHorizontalScrollBar — toggle a horizontal scrollbar
      *  on a console wrapper. mudix wraps long lines by default so this is rarely
      *  needed; included for parity. */
@@ -569,6 +638,26 @@ export declare class WindowManager {
      *  bottom (wheel/touch/keys cannot scroll back). Mudlet forbids this on the
      *  main window; we follow that policy. Returns false on 'main', true otherwise. */
     setScrollingEnabled(id: string, enabled: boolean): boolean;
+    /**
+     * Mudlet `timeStampsEnabled(window)` — whether the console is showing its
+     * timestamp column. Null when the window has no renderer registered, which
+     * is how the Lua wrapper tells a missing window from one that simply has
+     * timestamps off. Pre-mount, a queued preference wins over the default.
+     */
+    timeStampsEnabled(id: string): boolean | null;
+    /**
+     * Mudlet `enable/disableTimeStamps(window)`. The renderer owns the column,
+     * but a script can ask for it before the panel has mounted — openUserWindow
+     * followed immediately by enableTimeStamps — so the preference is queued and
+     * applied by registerTextPanel. False when the window doesn't exist at all.
+     */
+    setTimeStamps(id: string, visible: boolean): boolean;
+    /** Timestamp preference asked for before the panel mounted. */
+    private readonly pendingTimestamps;
+    /** Mudlet `scrollingActive(window)` — whether scrollback is currently
+     *  allowed. Always true for `'main'`, which setScrollingEnabled refuses to
+     *  change, and true for any console nobody has called disableScrolling on. */
+    isScrollingEnabled(id: string): boolean;
     /** Buffer-line index of the topmost visible line in `id`'s wrapper. In tail
      *  mode returns the last line number (matching Mudlet's mCursorY behaviour at
      *  the end of the buffer). Returns 0 if the element is unmounted or empty.
@@ -577,6 +666,26 @@ export declare class WindowManager {
      *  is `position: relative` — child offsetTop is relative to *that*, not to the
      *  scroll-container `.output-wrapper`, so the rectangles are the unambiguous
      *  way to relate child position to the scroll viewport. */
+    /** Whether `id`'s wrapper is mounted with laid-out lines, i.e. whether
+     *  {@link getScrollLine}'s measurement means anything. A console whose panel
+     *  isn't on screen yet measures as 0, which is indistinguishable from being
+     *  genuinely scrolled to the top. */
+    canMeasureScroll(id: string): boolean;
+    /**
+     * Where `scrollTo` last parked each console, as a buffer line index; absent
+     * means tail mode (or that only the user has scrolled it).
+     *
+     * Mudlet's getScroll/scrollTo are buffer-index operations. mudix measured
+     * the DOM instead, which is fine for a console the player is looking at but
+     * answers nothing useful for one whose panel has not been laid out yet — and
+     * a script that scrolls and reads back in the same breath never gives React
+     * a chance to commit in between. So the scripted position is remembered here
+     * and the measurement is the fallback, not the source of truth.
+     */
+    private readonly scriptScrollLine;
+    /** Called when the *user* scrolls a console, so a script's remembered
+     *  position stops overriding what they can see. */
+    noteUserScroll(id: string): void;
     getScrollLine(id: string): number;
     /** Scroll `id`'s wrapper so `line` (0-indexed) sits at the top. `undefined`
      *  resumes tail mode (scroll-to-bottom); negative values count from the end
@@ -611,6 +720,14 @@ export declare class WindowManager {
      *  translates it through cmdLineQssToScopedCss at render time. Returns
      *  false when the window doesn't exist. */
     setCmdLineStyleSheet(id: string, qss: string): boolean;
+    /**
+     * Mudlet setCommandForegroundColor / setCommandBackgroundColor for a named
+     * window. Mudlet styles a per-window command line through QSS, so the colour
+     * is patched into the same `cmdLineStyleSheet` a script could have set by
+     * hand rather than kept as a parallel piece of state. False when the window
+     * doesn't exist.
+     */
+    setCmdLineColor(id: string, property: 'color' | 'background-color', r: number, g: number, b: number, a: number): boolean;
     /** Bind the Lua callback fired when the user presses Enter in this
      *  window's command line. Pass null to clear. Returns false when the
      *  window doesn't exist. */
@@ -687,6 +804,19 @@ export declare class WindowManager {
      * behaviour). Returns false when the named window doesn't exist.
      */
     setTitle(id: string, title?: string): boolean;
+    /** Mudlet `getUserWindowTitle(name)` — the header text, whether it was set
+     *  or generated. Null when there is no such window. */
+    getTitle(id: string): string | null;
+    /**
+     * The title a window carries when nobody has set one. Mudlet builds it from
+     * the profile and the window's own name ("<profile> - <window>"), which is
+     * what a player sees on a freshly opened user window; mudix used to fall
+     * back to the bare id, so resetting a title lost the profile half of it.
+     * The profile name is injected by ScriptingAPI — the manager has no other
+     * reason to know it.
+     */
+    profileName: string;
+    defaultTitle(id: string): string;
     focus(id: string): void;
     has(id: string): boolean;
     getElement(id: string): HTMLElement | null;

package/dist-lib/ui/windows/panels/MapPanel.d.ts

@@ -1,8 +1,11 @@
 import type { WindowManager } from '../WindowManager';
+import type { ProfileVFS } from '../../../scripting/vfs/ProfileVFS';
 interface MapPanelProps {
     id: string;
     manager: WindowManager;
     connectionId: string;
+    /** Lets "Load map…" read a .dat/.xml the profile already holds. */
+    vfs?: ProfileVFS | null;
 }
-export declare function MapPanel({ id, manager, connectionId }: MapPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function MapPanel({ id, manager, connectionId, vfs }: MapPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist-lib/ui/windows/panels/PackageExportModal.d.ts

@@ -0,0 +1,18 @@
+import type { ProfileVFS } from '../../../scripting/vfs/ProfileVFS';
+import './PackageExportModal.css';
+export type ExportCategory = 'triggers' | 'aliases' | 'scripts' | 'timers' | 'keys' | 'buttons';
+interface Props {
+    connectionId: string;
+    vfs: ProfileVFS | null;
+    /** Pre-check this item (and its subtree), as Mudlet does when the exporter is
+     *  opened from a right-click in the editor tree. */
+    preselect?: {
+        category: ExportCategory;
+        id: string;
+    } | null;
+    onClose: () => void;
+    /** Reported back for the editor's log pane. */
+    onExported?: (message: string) => void;
+}
+export declare function PackageExportModal({ connectionId, vfs, preselect, onClose, onExported }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/ui/windows/panels/TextPanel.d.ts

@@ -13,6 +13,8 @@ interface TextPanelProps {
     scrollBoxes?: ScrollBoxManager;
     fontSize?: number;
     fontFamily?: string;
+    /** Rendered row height in px (MXP frames). See WindowManager.setLineHeight. */
+    lineHeight?: number;
     wrapAt?: number;
     wrapIndent?: number;
     wrapHangingIndent?: number;
@@ -31,5 +33,5 @@ interface TextPanelProps {
     cmdLineValue?: string;
     cmdLineValueSeq?: number;
 }
-export declare function TextPanel({ id, title, manager, labels, cmdLines, scrollBoxes, fontSize, fontFamily, wrapAt, wrapIndent, wrapHangingIndent, backgroundColor, backgroundImage, cmdLineEnabled, cmdLineStyleSheet, cmdLineValue, cmdLineValueSeq }: TextPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function TextPanel({ id, title, manager, labels, cmdLines, scrollBoxes, fontSize, fontFamily, lineHeight, wrapAt, wrapIndent, wrapHangingIndent, backgroundColor, backgroundImage, cmdLineEnabled, cmdLineStyleSheet, cmdLineValue, cmdLineValueSeq }: TextPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist-lib/ui/windows/types.d.ts

@@ -11,6 +11,27 @@ export interface DragState {
     /** true = insert before target in cross-axis; false = after. */
     splitBefore?: boolean;
 }
+/** One page of an MXP `<FRAME>` tab strip. `id` is the frame whose console the
+ *  tab shows — the host frame itself for the first page, a `DOCK`ed child
+ *  otherwise. See MxpFrameManager. */
+export interface MxpTabPage {
+    id: string;
+    title: string;
+}
+/** The dockable map widget — the toolbar's Map button and Lua openMapWidget. */
+export declare const MAP_WIDGET_ID = "sys:map";
+/** The embedded mapper created by Lua createMapper / Geyser.Mapper. */
+export declare const MAPPER_WIDGET_ID = "sys:mapper";
+/** Window id backing secondary map views (Lua createMapView). */
+export declare function mapViewWindowId(viewId: number): string;
+export declare const MAP_VIEW_ID_RE: RegExp;
+/**
+ * Saved window hints predate the prefix, so a profile stored the map widget's
+ * geometry under the bare `map`. Rename it on load, or every existing profile
+ * loses its Map position, size and dock side. Bare `mapper`/`mapViewN` need no
+ * migration: neither is ever restored from a hint.
+ */
+export declare function migrateClientWindowHints(hints: Record<string, WindowOpenOptions>): Record<string, WindowOpenOptions>;
 export interface WindowOpenOptions {
     title?: string;
     kind?: 'text' | 'html' | 'map';
@@ -46,6 +67,10 @@ export interface WindowOpenOptions {
     fontSize?: number;
     /** Output font family override (Mudlet setFont). */
     fontFamily?: string;
+    /** Rendered row height in px, overriding the stylesheet's line-height. Set
+     *  for MXP frames so a box of N rows really holds N rows. See
+     *  WindowManager.setLineHeight. */
+    lineHeight?: number;
     /** Character-column wrap width (Mudlet setWindowWrap). 0/undefined disables. */
     wrapAt?: number;
     /** Indent (in characters) of newline-started lines (Mudlet setWindowWrapIndent). */
@@ -102,6 +127,8 @@ export interface ScriptWindowRenderData {
     splitFlex?: number;
     fontSize?: number;
     fontFamily?: string;
+    /** See WindowOpenOptions.lineHeight. */
+    lineHeight?: number;
     wrapAt?: number;
     wrapIndent?: number;
     wrapHangingIndent?: number;
@@ -142,4 +169,12 @@ export interface ScriptWindowRenderData {
      *  still trigger React's seed effect (otherwise printCmdLine('x') after a
      *  user types 'x' would do nothing). */
     cmdLineValueSeq?: number;
+    /** MXP `<FRAME TITLE=…>` tab strip rendered as this window's chrome. Absent
+     *  for every other window; set only by MxpFrameManager. */
+    frameTabs?: {
+        pages: MxpTabPage[];
+        active: string;
+    };
+    /** True for a console backing an MXP `<FRAME>` — draws the frame border. */
+    isMxpFrame?: boolean;
 }

package/dist-lib/utils/describeThrown.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Render a caught value for a user-facing error line.
+ *
+ * `String(err)` is the usual shorthand, but it collapses every non-`Error`
+ * object to the literal text "[object Object]" — which is exactly what the
+ * script error log showed for errors that never went through Lua's own
+ * `error()`. Those come from a JS exception escaping the wasm boundary: the
+ * metamethod trampolines wasmoon installs for JS objects (`__index`,
+ * `__newindex`, `__tostring`) don't wrap the call, so a throw inside a getter
+ * unwinds straight past Lua into whoever called `resume`. Nothing rewrites it
+ * into a Lua error string on the way, so the value arrives raw — and a raw
+ * plain object rendered with `String` says nothing at all.
+ *
+ * Errors keep rendering as their bare `message` (unchanged); everything else is
+ * described by what it actually is.
+ *
+ * Pass `label` (the entity or event the failure is attributed to) to also
+ * record the live value in devtools when it is opaque — such a value carries no
+ * stack of its own, so the object itself is the only handle on where it came
+ * from.
+ */
+export declare function describeThrown(err: unknown, label?: string): string;

package/dist-lib/utils/fontLoader.d.ts

@@ -34,6 +34,11 @@ export interface LocalFontEntry {
 }
 export declare function isLocalFontApiSupported(): boolean;
 export declare function queryLocalFonts(): Promise<LocalFontEntry[]>;
+/** The family consoles actually render in when the profile sets none — the
+ *  bundled face App.css applies (picked to match Mudlet's default look). Mudlet
+ *  always reports a concrete family from getFont, never an empty string, and
+ *  UI_spec checks that what comes back is a real name. */
+export declare const DEFAULT_OUTPUT_FONT_FAMILY = "Bitstream Vera Sans Mono";
 export declare function getUniversalDefaultFonts(): readonly string[];
 export declare function getCachedLocalFonts(): string[];
 export declare function setLocalFontsCache(families: Iterable<string>): void;

package/dist-lib/vite.js

@@ -95,6 +95,28 @@ export default function mudix() {
         {
             name: 'mudix:config',
             config: () => ({
+                resolve: {
+                    // Exactly one React instance, always. `mudlet-map-editor`
+                    // declares react/react-dom as plain *dependencies* (not
+                    // peers), so the moment its range outruns the range the
+                    // app resolved, the package manager nests a second copy
+                    // under the editor. The editor's `App` is then rendered by
+                    // mudix's React while its hooks come from the nested one,
+                    // whose dispatcher is null — "Invalid hook call", and with
+                    // no error boundary above the lazy boundary the throw
+                    // unmounts the whole root, so opening the map editor
+                    // blanked the entire UI in dev and in production alike.
+                    // Deduping is the structural fix: it survives the next
+                    // version skew, and consumers of the library (which
+                    // externalizes react) get it through this plugin too.
+                    dedupe: ['react', 'react-dom'],
+                },
+                // A Mudlet package archive is a zip, not source. `?url` imports
+                // get away without this (the explicit query short-circuits
+                // import analysis), but `?inline` — which the busted fixtures
+                // use to carry an archive into the VFS — reaches the asset
+                // pipeline and needs the extension declared.
+                assetsInclude: ['**/*.mpackage'],
                 optimizeDeps: {
                     // 'mudix': the library entry carries relative `?url` asset
                     // imports (external in the lib build); the dep optimizer's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mudlet/mudlet-web",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "description": "Mudlet Web — Mudlet in the browser, usable standalone or as a library for branded builds",
   "license": "GPL-2.0-or-later",
@@ -45,10 +45,11 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "dev:busted": "vite --mode busted --port 5174 --strictPort",
-    "pretest:e2e": "npm run gen:busted-manifest",
     "test:e2e": "playwright test",
-    "gen:busted-manifest": "playwright test -c playwright.manifest.config.ts",
-    "sync:mudlet-specs": "node scripts/sync-mudlet-specs.mjs"
+    "busted:failures": "playwright test -c playwright.failures.config.ts",
+    "sync:mudlet-specs": "node scripts/sync-mudlet-specs.mjs",
+    "sync:mudlet-lua": "node scripts/sync-mudlet-lua.mjs",
+    "sync:mudlet-games": "node scripts/sync-mudlet-games.mjs"
   },
   "dependencies": {
     "@codemirror/autocomplete": "^6.20.1",
@@ -63,12 +64,12 @@
     "@types/dompurify": "^3.0.5",
     "@zenfs/core": "^2.5.6",
     "@zenfs/dom": "^1.2.9",
-    "dompurify": "^3.4.12",
+    "dompurify": "^3.4.14",
     "fflate": "^0.8.2",
     "lucide-react": "^1.14.0",
     "marked": "^18.0.4",
     "mudlet-map-binary-reader": "^1.2.0",
-    "mudlet-map-editor": "^1.3.1",
+    "mudlet-map-editor": "^1.3.2",
     "mudlet-map-renderer": "^2.6.1",
     "pako": "^2.1.0",
     "pcre2-wasm-universal": "^1.0.0",
@@ -89,5 +90,8 @@
     "typescript": "^5.0.0",
     "vite": "8.0.16",
     "vitest": "^4.1.7"
+  },
+  "resolutions": {
+    "dompurify": "^3.4.14"
   }
 }

package/dist-lib/ui/windows/panels/VfsModulePickerModal.d.ts

@@ -1,8 +0,0 @@
-import type { ProfileVFS } from '../../../scripting/vfs/ProfileVFS';
-interface Props {
-    vfs: ProfileVFS;
-    onClose: () => void;
-    onPick: (absolutePath: string) => void;
-}
-export declare function VfsModulePickerModal({ vfs, onClose, onPick }: Props): import("react/jsx-runtime").JSX.Element;
-export {};