refactor(ide): the IDE is always its own window

The IDE was reachable six ways. Three of them swapped the shell inside the
running process, so the Fiddle you were working in silently became a different
product — and that is not only jarring, it breaks the assumption the one
deliberate path was built around. openShowcaseInIdeWindow spawns a child
process for a documented reason: the Scintilla registry, its keyWindow attach,
and the config-store writer lease all assume ONE WINDOW PER PROCESS. One entry
point honoured that; the rest went around it.

One rule now: opening a workspace spawns a window, and every command says where
it lands.

- File ▸ Open Folder in IDE… and the palette's Open Folder in IDE (⇧⌘O) spawn
- Open Showcase from URL in IDE — it was "Open Showcase (URL)", differing from
  "Open Showcase" only in which product it dropped you into, with nothing in
  either name to say so — spawns too
- File ▸ Open Fiddle Folder… (⌘O) still loads into this Fiddle, and says so

The folder reaches the child by env, not by deep link. The deep-link scheme is
a public contract with a parser and tests; "open this local directory" is a
private handoff between a parent window and the child it just spawned.

Also drops a duplicate delivery. main.ts answered the openFolder bridge call
twice — reply callback plus a `folderOpened` broadcast, a fallback from when
the reply was unreliable on some runtimes. Two deliveries were harmless while
both did the same thing; with the callback now spawning, honouring the
broadcast as well would have opened the new window AND converted this one.

The helper sits above openFolderDialog rather than beside its siblings further
down: Lynx evaluates a useCallback's dependency array at declaration, so a
later declaration referenced from an earlier one is a load-time TDZ crash.

Author: Huxpro

.changeset/gallery-and-new-fiddle.md

@@ -37,3 +37,33 @@ third label competing with the two real controls.
 Also removes a stale light-theme override that was repainting the cards' `Open`
 Blueprint blue — the brand token already adapts per theme, so the override was
 undoing the accent in exactly one of them.
+
+**One rule for the IDE: it is always its own window.**
+
+The IDE was reachable six ways and three of them swapped the shell inside the
+running process — the Fiddle you were working in silently became a different
+product. That also broke the assumption the one deliberate path was built
+around: the Scintilla registry, its keyWindow attach, and the config-store
+writer lease all assume one window per process, which is exactly why the
+gallery's `IDE` action spawns a child. One entry point honoured that; the rest
+went around it.
+
+Now every "open a workspace" act spawns, and every command says where it goes:
+
+- `File ▸ Open Folder in IDE…` and the palette's `Open Folder in IDE` (⇧⌘O)
+  spawn a window instead of converting this one
+- the palette's `Open Showcase from URL in IDE` — previously `Open Showcase
+  (URL)`, which differed from `Open Showcase` only in landing you in a
+  different product — does the same
+- `File ▸ Open Fiddle Folder…` (⌘O) keeps loading a folder into this Fiddle,
+  and now says so
+
+The spawned window receives its folder by env rather than by deep link: the
+deep-link scheme is a public contract with a parser and tests, and this is a
+private handoff between a parent and the child it just spawned.
+
+Also removes a duplicate delivery: `main.ts` answered the openFolder bridge call
+both through its reply callback and as a `folderOpened` broadcast, a fallback
+from when the reply was unreliable. Harmless while both did the same thing —
+but with the callback now spawning, honouring the broadcast too would have
+opened a new window *and* converted the old one.

lynxtron-go/src/app/App.tsx

@@ -708,25 +708,13 @@ export function App(props: { onRender?: () => void } = {}) {
     }
   }, [applyWorkspaceSession, createFolderWorkspaceSession, createShowcaseWorkspaceSession, log, rememberWorkspaceSession]);
 
-  // Listen for global event from main.ts after showOpenDialog resolves
-  useEffect(() => {
-    const handler = (data: any) => {
-      try {
-        const parsed = typeof data === 'string' ? JSON.parse(data) : data;
-        if (parsed?.path) openFolder(parsed.path);
-      } catch (_) { /* ignore */ }
-    };
-    try {
-      // @ts-ignore
-      lynx.getJSModule('GlobalEventEmitter').addListener('folderOpened', handler);
-    } catch (_) { /* ignore */ }
-    return () => {
-      try {
-        // @ts-ignore
-        lynx.getJSModule('GlobalEventEmitter').removeListener('folderOpened', handler);
-      } catch (_) {}
-    };
-  }, [openFolder]);
+  // The `folderOpened` broadcast is NOT handled here. main.ts answers the
+  // openFolder bridge call twice — once through the reply callback and once as
+  // a global event, added long ago as a fallback for runtimes where the reply
+  // was unreliable. Two deliveries of one dialog result were harmless while
+  // both did the same thing; now that picking a folder spawns an IDE WINDOW,
+  // honouring the broadcast as well would open the new window AND convert this
+  // one. The callback in openFolderDialog is the single handler.
 
 
   // Auto-restore last workspace on startup
@@ -1247,6 +1235,74 @@ export function App(props: { onRender?: () => void } = {}) {
   }, [log]);
 
   // ── Open folder dialog ────────────────────────────────────────────────────
+  /**
+   * Open an arbitrary folder as an IDE workspace — in a NEW WINDOW, never in
+   * this one.
+   *
+   * The IDE used to be reachable four ways, and three of them swapped the
+   * shell inside the running process: the Fiddle you were working in silently
+   * became a different product. That is not just jarring, it breaks the
+   * assumption the deliberate path was built around — see
+   * openShowcaseInIdeWindow above: the Scintilla registry, its keyWindow
+   * attach, and the config-store writer lease all assume ONE WINDOW PER
+   * PROCESS. One entry point honoured that; the rest went around it.
+   *
+   * So there is one rule now: the IDE is always its own window. `Open` always
+   * means "in this Fiddle", and going to the IDE is always a differently-named
+   * act.
+   *
+   * The folder travels by env rather than by deep link. The deep-link scheme
+   * is a public contract with a parser and tests; "open this local directory"
+   * is a private handoff from a parent window to the child it just spawned.
+   */
+  const openFolderInIdeWindow = useCallback((folderPath: string) => {
+    const rt = (foundationApi() as any)?.runtime;
+    const exec = (foundationApi() as any)?.exec;
+    if (!rt?.execPath || !rt?.appDir || !exec?.runAsync) {
+      showOutput('warn', '[IDE] spawn bridge unavailable — opening in this window instead');
+      openFolder(folderPath);
+      return;
+    }
+    const handle = exec.runAsync(rt.execPath, [rt.appDir], {
+      env: {
+        LYNXTRON_ALLOW_MULTI: '1',
+        LYNXTRON_WINDOW_CASCADE: '1',
+        LYNXTRON_BOOT_TARGET: 'ide',
+        LYNXTRON_BOOT_FOLDER: folderPath,
+        // Children must NOT inherit the dev automation channels — two pollers
+        // on the same /tmp command files steal each other's commands.
+        LYNXTRON_FIDDLE_DEV: '0',
+      },
+      onExit: (code: number | null) => {
+        showOutput('info', `[IDE] window for "${folderPath}" exited (code=${code})`);
+      },
+    });
+    if (handle?.pid) {
+      setGalleryOpen(false);
+      showOutput('info', `[IDE] opened "${folderPath}" in a new window (pid=${handle.pid})`);
+      setStatus(`Opened ${folderPath} in new IDE window`);
+    } else {
+      showOutput('warn', '[IDE] spawn failed — opening in this window instead');
+      openFolder(folderPath);
+    }
+  }, [openFolder, showOutput]);
+
+  /**
+   * A window spawned as a dedicated IDE opens the folder it was spawned for,
+   * once. The parent hands it over by env (see preload-bridge) because this is
+   * an internal handoff, not a public deep link.
+   */
+  const bootFolderOpenedRef = useRef(false);
+  useEffect(() => {
+    if (bootFolderOpenedRef.current) return;
+    let folder: string | null = null;
+    try { folder = (getExposed() as any)?.bootFolder ?? null; } catch (_) { folder = null; }
+    if (!folder) return;
+    bootFolderOpenedRef.current = true;
+    openFolder(folder);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   const openFolderDialog = useCallback(() => {
     console.log('[IDE] openFolderDialog tapped');
     log('[IDE] openFolderDialog tapped');
@@ -1255,13 +1311,13 @@ export function App(props: { onRender?: () => void } = {}) {
       NativeModules.bridge.call('openFolder', {}, (result: any) => {
         console.log('[IDE] openFolder bridge callback:', JSON.stringify(result));
         log(`[IDE] openFolder callback: ${JSON.stringify(result)}`);
-        if (result?.path) openFolder(result.path);
+        if (result?.path) openFolderInIdeWindow(result.path);
       });
     } catch (e) {
       console.error('[IDE] openFolderDialog error:', e);
       log(`openFolderDialog error: ${e}`);
     }
-  }, [log, openFolder]);
+  }, [log, openFolderInIdeWindow]);
 
   const startShowcaseList = useCallback(() => {
     setPickerQuery('');
@@ -1695,9 +1751,14 @@ export function App(props: { onRender?: () => void } = {}) {
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  /**
+   * Fetch a showcase by URL and open it. Its only caller is the palette's
+   * "Open Showcase from URL in IDE", and the destination is in that name now:
+   * a fetched workspace is the same kind of thing as a folder you picked, so
+   * it opens the same way — a new IDE window, never this one.
+   */
   const fetchShowcaseByUrl = useCallback(async (
     url: string,
-    source: 'folder' | 'showcase' = 'folder',
     options?: { showLoading?: boolean },
   ): Promise<string | null> => {
     const shouldShowLoading = options?.showLoading !== false;
@@ -1727,7 +1788,7 @@ export function App(props: { onRender?: () => void } = {}) {
         console.log('[IDE] fetchShowcaseByUrl success', { url, showcasePath });
         log(`[IDE] fetchShowcaseByUrl success url=${url} path=${showcasePath}`);
         showOutput('info', `Showcase fetched to: ${showcasePath}`);
-        openFolder(showcasePath, source);
+        openFolderInIdeWindow(showcasePath);
         setStatus(`Opened showcase: ${showcasePath.split('/').pop()}`);
         return showcasePath;
       }
@@ -1750,7 +1811,7 @@ export function App(props: { onRender?: () => void } = {}) {
       }
     }
     return null;
-  }, [clearShowcaseLoading, log, openFolder, showOutput, startShowcaseLoading]);
+  }, [clearShowcaseLoading, log, openFolderInIdeWindow, showOutput, startShowcaseLoading]);
 
   const resolveShowcaseEntryWorkspacePath = useCallback(async (entry: ShowcaseEntry): Promise<string | null> => {
     // Same policy the Fiddle uses — local source tree, then an already
@@ -2301,7 +2362,7 @@ export function App(props: { onRender?: () => void } = {}) {
     if (pickerMode === 'url') {
       setPickerOpen(false);
       setPickerMode(undefined);
-      void fetchShowcaseByUrl(value, 'showcase');
+      void fetchShowcaseByUrl(value);
       return;
     }
     if (pickerMode === 'bundleUrl') {

lynxtron-go/src/app/commands/showcase-commands.ts

@@ -32,9 +32,13 @@ export function registerShowcaseCommands(deps: {
     },
   });
 
+  // Named for its destination. "Open Showcase" loads a showcase into THIS
+  // Fiddle; this fetches one and opens it as a workspace in a new IDE window.
+  // They were "Open Showcase" and "Open Showcase (URL)" — one verb, one noun,
+  // two different products, and nothing in either name said which.
   registerCommand({
     id: 'showcase.openUrl',
-    label: 'Open Showcase (URL)',
+    label: 'Open Showcase from URL in IDE',
     execute: () => {
       deps.startUrlFetch();
     },
@@ -144,7 +148,7 @@ export function registerShowcaseCommands(deps: {
 
   registerCommand({
     id: 'folder.open',
-    label: 'Open Folder',
+    label: 'Open Folder in IDE',
     keybinding: 'Cmd+Shift+O',
     execute: () => { deps.setPickerOpen(false); deps.openFolderDialog(); },
   });

lynxtron-go/src/main/desktop/main.ts

@@ -558,7 +558,9 @@ function buildAppMenu(w: LynxWindowInstance, surface: MenuSurface) {
     ? [
         {
           id: 'openFolder',
-          label: 'Open Folder…',
+          // Says where it goes. The IDE is always its own window now, so this
+          // no longer replaces whatever you were working in.
+          label: 'Open Folder in IDE…',
           accelerator: 'CmdOrCtrl+O',
           registerAccelerator: true,
           // App.tsx runs the native dialog itself through the openFolder
@@ -596,7 +598,11 @@ function buildAppMenu(w: LynxWindowInstance, surface: MenuSurface) {
         { type: 'separator' },
         {
           id: 'open',
-          label: 'Open...',
+          // Loads a folder's fiddle files into THIS Fiddle (fiddle:openFolder
+          // → loadLocalFiddle). Distinct from "Open Folder in IDE…" below,
+          // which opens a workspace in its own window — the two used to be
+          // "Open..." and "Open Folder…", which said nothing about either.
+          label: 'Open Fiddle Folder…',
           accelerator: 'CmdOrCtrl+O',
           registerAccelerator: true,
           click: async () => {

lynxtron-go/src/main/desktop/preload-bridge.ts

@@ -29,6 +29,13 @@ export function createPreloadBridge() {
     // (Gallery IDE action) — the UI hides Fiddle-centric chrome like the
     // route-back chevrons in that mode.
     bootTarget: process.env.LYNXTRON_BOOT_TARGET ?? null,
+    /**
+     * An absolute folder for an IDE window to open at startup. Passed by env
+     * rather than by deep link on purpose: the deep-link scheme is a public,
+     * user-facing contract, and "open this arbitrary local directory" is an
+     * internal handoff between a parent window and the child it spawned.
+     */
+    bootFolder: process.env.LYNXTRON_BOOT_FOLDER ?? null,
     ...createFoundationBridge(dbg),
     ls: extensionHost.bridge,
     pty: pty.bridge,