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

package/dist/shared/ipc-channels.d.ts

@@ -6,11 +6,53 @@
  * requires a single edit.
  */
 export declare const SimulatorChannel: {
-    readonly Attach: "simulator:attach";
+    readonly AttachNative: "simulator:attach-native";
+    readonly SetNativeBounds: "simulator:set-native-bounds";
+    readonly SetDeviceInfo: "simulator:set-device-info";
     readonly Detach: "simulator:detach";
     readonly Resize: "simulator:resize";
     readonly SetVisible: "simulator:setVisible";
     readonly Console: "simulator:console";
+    readonly CurrentPage: "simulator:current-page";
+};
+/** iPhone bezel cutout family driving the device-shell notch visual. */
+export type NotchType = 'none' | 'notch' | 'dynamic-island';
+/** Per-device safe-area insets in CSS px (portrait). */
+export interface SafeAreaInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * Logical device metrics pushed by the renderer device dropdown under
+ * native-host (`SimulatorChannel.SetDeviceInfo`). Mirrors a row of the renderer
+ * `DEVICES` table; main maps it onto a `HostEnvSnapshot` for the service-host
+ * window so `wx.getSystemInfoSync()` reflects the selected device, relays it to
+ * the simulator WCV (DeviceShell: bezel size + status bar + notch), and drives
+ * the CSS `env(safe-area-inset-*)` override on render-host guests.
+ */
+export interface NativeDeviceInfo {
+    brand: string;
+    model: string;
+    system: string;
+    platform: string;
+    pixelRatio: number;
+    screenWidth: number;
+    screenHeight: number;
+    statusBarHeight: number;
+    safeAreaBottom: number;
+    notchType: NotchType;
+    safeAreaInsets: SafeAreaInsets;
+}
+export declare const ServiceHostChannel: {
+    /**
+     * NATIVE-HOST ONLY. Live-update the service-host window's host-env snapshot
+     * (device metrics) so subsequent `wx.getSystemInfoSync()` reflects a device
+     * change without a relaunch. The service-host preload mutates
+     * `__diminaSpawnContext.hostEnvSnapshot` in place (see `service-host/preload.cjs`).
+     */
+    readonly HostEnvUpdate: "service-host:host-env:update";
 };
 export declare const SimulatorCustomApiChannel: {
     readonly List: "simulator:custom-apis:list";
@@ -58,6 +100,17 @@ export declare const SimulatorElementChannel: {
     readonly Inspect: "simulator:element:inspect";
     readonly Clear: "simulator:element:clear";
 };
+export declare const WorkbenchRuntimeChannel: {
+    readonly GetNativeHost: "workbench:runtime:native-host";
+};
+export declare const SimulatorWxmlChannel: {
+    readonly GetSnapshot: "simulator:wxml:snapshot";
+    readonly Event: "simulator:wxml:event";
+};
+export declare const SimulatorAppDataChannel: {
+    readonly GetSnapshot: "simulator:appdata:snapshot";
+    readonly Event: "simulator:appdata:event";
+};
 export interface ElementInspection {
     sid: string;
     rect: {
@@ -96,6 +149,33 @@ export declare const ProjectChannel: {
     readonly CaptureThumbnail: "project:captureThumbnail";
     readonly GetThumbnail: "project:getThumbnail";
 };
+export declare const ProjectFsChannel: {
+    readonly GetRoot: "project:fs:getRoot";
+    readonly ReadFile: "project:fs:readFile";
+    readonly WriteFile: "project:fs:writeFile";
+    /**
+     * Synchronous (blocking) write, used ONLY by the editor's `beforeunload`
+     * flush: a hard window/app close tears the renderer down before an async
+     * `WriteFile` IPC can round-trip, so the last in-debounce-window edit would
+     * be lost. `sendSync` blocks page teardown until the bytes hit disk. Runs the
+     * SAME sandbox as `WriteFile` (see project-fs `writeFileSync`).
+     */
+    readonly WriteFileSync: "project:fs:writeFileSync";
+    readonly ListFiles: "project:fs:listFiles";
+};
+export declare const EditorChannel: {
+    /** main → renderer: open `path` (project-relative POSIX) at `line`/`column`. */
+    readonly OpenFile: "editor:openFile";
+};
+/** Payload for `editor:openFile`. `line`/`column` are 1-based for Monaco. */
+export interface EditorOpenFilePayload {
+    /** Project-relative POSIX path (the same key Monaco opens files by). */
+    path: string;
+    /** 1-based line to reveal; omitted/<=0 means open without moving the cursor. */
+    line?: number;
+    /** 1-based column to reveal; defaults to 1 when a line is given. */
+    column?: number;
+}
 export declare const ProjectsChannel: {
     readonly List: "projects:list";
     readonly Add: "projects:add";
@@ -123,6 +203,33 @@ export declare const PanelChannel: {
     readonly Select: "panel:select";
     readonly SelectSimulator: "panel:selectSimulator";
 };
+export declare const ViewChannel: {
+    /** Update the simulator DevTools view's bounds (or hide if w/h = 0). */
+    readonly SimulatorDevtoolsBounds: "view:simulator:devtools-bounds";
+    /**
+     * Host-controllable toolbar WebContentsView (sits ABOVE the devtools built-in
+     * header). Forward anchor: the main renderer reports the toolbar placeholder's
+     * bounds (or w/h=0 to hide). invoke.
+     */
+    readonly HostToolbarBounds: "view:host-toolbar:bounds";
+    /**
+     * Reverse size-advertiser: the host-toolbar WCV's OWN renderer advertises its
+     * intrinsic content height so main reserves exactly that much. Payload
+     * `{ axis: 'block', extent }`. fire-and-forget (send), NOT invoke.
+     */
+    readonly HostToolbarAdvertiseHeight: "view:host-toolbar:advertise-height";
+    /**
+     * main → main-window renderer: push the reserved host-toolbar height so the
+     * renderer placeholder div resizes (closing the dynamic-height loop).
+     */
+    readonly HostToolbarHeightChanged: "view:host-toolbar:height-changed";
+};
+export interface ViewBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
 export declare const PopoverChannel: {
     readonly Show: "popover:show";
     readonly Hide: "popover:hide";

package/dist/shared/ipc-channels.js

@@ -7,29 +7,58 @@
  */
 // ── Simulator (preload → host / renderer ↔ main) ────────────────────────
 export const SimulatorChannel = {
-    Attach: 'simulator:attach',
+    // Ask main to create the simulator as a top-level WebContentsView (so nested
+    // render-host <webview>s can attach). Native-host is the sole runtime.
+    AttachNative: 'simulator:attach-native',
+    // Renderer reports the device-bezel inner-screen rect (CSS px from content
+    // top-left) + zoom so main can overlay the simulator WCV on it.
+    SetNativeBounds: 'simulator:set-native-bounds',
+    // Renderer pushes the selected device's LOGICAL metrics (screen size,
+    // pixelRatio, statusBarHeight, …) when the device dropdown changes. Main
+    // maps it to a HostEnvSnapshot and live-updates the running service-host
+    // window — the authoritative `wx.getSystemInfoSync()` source — so the
+    // mini-app sees the selected device without a relaunch.
+    SetDeviceInfo: 'simulator:set-device-info',
     Detach: 'simulator:detach',
     Resize: 'simulator:resize',
     SetVisible: 'simulator:setVisible',
     Console: 'simulator:console',
+    // Main → renderer push of the visible top-of-stack page route whenever the
+    // mini-app navigates (navigateTo / switchTab / back). Payload: the page path
+    // string (same bare format as `getCurrentPagePath`), or '' when unknown.
+    CurrentPage: 'simulator:current-page',
+};
+// ── Service host (main → hidden service-host window) ─────────────────────
+export const ServiceHostChannel = {
+    /**
+     * NATIVE-HOST ONLY. Live-update the service-host window's host-env snapshot
+     * (device metrics) so subsequent `wx.getSystemInfoSync()` reflects a device
+     * change without a relaunch. The service-host preload mutates
+     * `__diminaSpawnContext.hostEnvSnapshot` in place (see `service-host/preload.cjs`).
+     */
+    HostEnvUpdate: 'service-host:host-env:update',
 };
 // ── Custom simulator APIs (downstream-registered, main-process handlers) ──
 // list: simulator queries the names registered via instance.registerSimulatorApi().
 // invoke: simulator forwards an API call to the registry; result/reject propagates.
 //
 // These are ipcMain.handle channels invoked by the **main-window renderer**
-// only (trusted host). The simulator <webview> never reaches them directly —
-// it proxies through the host via the bridge channels below, so the
-// sender-policy can keep the webview off the IPC white-list.
+// only (trusted host). The simulator guest never reaches them directly — it
+// reaches the host via the bridge channels below, so the sender-policy can keep
+// the simulator off the IPC white-list.
 export const SimulatorCustomApiChannel = {
     List: 'simulator:custom-apis:list',
     Invoke: 'simulator:custom-apis:invoke',
 };
-// ── Custom APIs bridge proxy (simulator <webview> ↔ main-window renderer) ──
-// Request:  webview → host via `ipcRenderer.sendToHost`,
-//           payload = { id, op: 'list' } | { id, op: 'invoke', name, params }
-// Response: host → webview via `<webview>.send`,
-//           payload = { id, result } | { id, error }
+// ── Custom APIs bridge (simulator → host) ──
+// payload = { id, op: 'list' } | { id, op: 'invoke', name, params } for Request,
+// { id, result } | { id, error } for Response. Transport (in
+// `src/preload/runtime/custom-apis.ts`): native-host — the simulator is a
+// top-level WebContentsView (no embedder), so Request goes via
+// `ipcRenderer.send` → `ipcMain.on` dispatcher bound to that simWc (view-manager
+// `attachNativeCustomApiBridge`) → Response via `simWc.send`. (The old
+// renderer-proxied `<webview>` transport, `ipcRenderer.sendToHost` →
+// `<webview>.send`, no longer exists — native-host is the sole runtime.)
 //
 // Request/response are correlated by `id` so multiple concurrent invokes can
 // be in flight at once.
@@ -38,7 +67,7 @@ export const SimulatorCustomApiBridgeChannel = {
     Response: 'simulator:custom-apis:bridge-response',
 };
 // ── Storage (CDP-backed; main process attaches the debugger to the
-// simulator <webview> and forwards DOMStorage events to the renderer) ──
+// simulator guest and forwards DOMStorage events to the renderer) ──
 export const SimulatorStorageChannel = {
     GetSnapshot: 'simulator:storage:snapshot',
     GetActivePrefix: 'simulator:storage:activePrefix',
@@ -53,6 +82,28 @@ export const SimulatorElementChannel = {
     Inspect: 'simulator:element:inspect',
     Clear: 'simulator:element:clear',
 };
+// ── Workbench runtime info (renderer reads once to pick panel data sources) ──
+// Under native-host the page DOM / service logic live in separate webContents,
+// so WXML + AppData are sourced from the main process instead of the simulator
+// guest's miniappSnapshot transport. The renderer queries this flag once and
+// branches usePanelData accordingly.
+export const WorkbenchRuntimeChannel = {
+    GetNativeHost: 'workbench:runtime:native-host',
+};
+// ── WXML tree (native-host: main pulls the tree from the active render-host
+// <webview> guest via render-inspect, and pushes/answers here — mirroring the
+// Storage panel's main→renderer contract so the renderer panel is unchanged) ──
+export const SimulatorWxmlChannel = {
+    GetSnapshot: 'simulator:wxml:snapshot',
+    Event: 'simulator:wxml:event',
+};
+// ── AppData (native-host: main taps the service→render setData stream in
+// bridge-router and pushes the cumulative snapshot here — the service logic runs
+// in the hidden service-host window, not a Worker in the simulator guest) ──
+export const SimulatorAppDataChannel = {
+    GetSnapshot: 'simulator:appdata:snapshot',
+    Event: 'simulator:appdata:event',
+};
 // ── Workbench settings ───────────────────────────────────────────────────
 export const WorkbenchSettingsChannel = {
     Get: 'workbenchSettings:get',
@@ -74,6 +125,39 @@ export const ProjectChannel = {
     CaptureThumbnail: 'project:captureThumbnail',
     GetThumbnail: 'project:getThumbnail',
 };
+// ── Project file system (sandboxed to active project root) ────────────────
+//
+// Read/write access to the active project's files, used by the in-renderer
+// Monaco editor. Every path is verified against the active project root in
+// the main process (see `services/project-fs`). Replaces the OpenSumi
+// editor's `editor:fs:*` bridge — same sandbox, callable from the main
+// renderer instead of a separate WebContentsView.
+export const ProjectFsChannel = {
+    GetRoot: 'project:fs:getRoot',
+    ReadFile: 'project:fs:readFile',
+    WriteFile: 'project:fs:writeFile',
+    /**
+     * Synchronous (blocking) write, used ONLY by the editor's `beforeunload`
+     * flush: a hard window/app close tears the renderer down before an async
+     * `WriteFile` IPC can round-trip, so the last in-debounce-window edit would
+     * be lost. `sendSync` blocks page teardown until the bytes hit disk. Runs the
+     * SAME sandbox as `WriteFile` (see project-fs `writeFileSync`).
+     */
+    WriteFileSync: 'project:fs:writeFileSync',
+    ListFiles: 'project:fs:listFiles',
+};
+// ── Editor (main → renderer) ──────────────────────────────────────────────
+//
+// Drives the in-renderer Monaco editor from the main process. Used by the
+// "click a console file link → open the file at line:col" pipeline: the
+// embedded DevTools front-end routes a source-link click through an open-
+// resource handler → Electron `devtools-open-url` on the service host → main
+// maps the resource URL to a project-relative path → this event opens it in
+// Monaco. Payload: `EditorOpenFilePayload`.
+export const EditorChannel = {
+    /** main → renderer: open `path` (project-relative POSIX) at `line`/`column`. */
+    OpenFile: 'editor:openFile',
+};
 // ── Project list / workspace ─────────────────────────────────────────────
 export const ProjectsChannel = {
     List: 'projects:list',
@@ -99,6 +183,39 @@ export const PanelChannel = {
     Select: 'panel:select',
     SelectSimulator: 'panel:selectSimulator',
 };
+// ── Embedded views (renderer → main) ─────────────────────────────────────
+//
+// The main window's React layout owns the *positions* of the editor +
+// simulator-DevTools WebContentsView overlays — each visible placeholder
+// `<div>` measures its client rect via ResizeObserver and pushes the
+// rectangle to the main process. The view manager caches the latest
+// payload per kind and applies it to the overlay; no payload means the
+// overlay is hidden.
+//
+// Payload (after schema validation): `{ x, y, width, height }` in CSS
+// pixels relative to the window's content area (origin = top-left,
+// not including the OS chrome).
+export const ViewChannel = {
+    /** Update the simulator DevTools view's bounds (or hide if w/h = 0). */
+    SimulatorDevtoolsBounds: 'view:simulator:devtools-bounds',
+    /**
+     * Host-controllable toolbar WebContentsView (sits ABOVE the devtools built-in
+     * header). Forward anchor: the main renderer reports the toolbar placeholder's
+     * bounds (or w/h=0 to hide). invoke.
+     */
+    HostToolbarBounds: 'view:host-toolbar:bounds',
+    /**
+     * Reverse size-advertiser: the host-toolbar WCV's OWN renderer advertises its
+     * intrinsic content height so main reserves exactly that much. Payload
+     * `{ axis: 'block', extent }`. fire-and-forget (send), NOT invoke.
+     */
+    HostToolbarAdvertiseHeight: 'view:host-toolbar:advertise-height',
+    /**
+     * main → main-window renderer: push the reserved host-toolbar height so the
+     * renderer placeholder div resizes (closing the dynamic-height loop).
+     */
+    HostToolbarHeightChanged: 'view:host-toolbar:height-changed',
+};
 // ── Popover ──────────────────────────────────────────────────────────────
 export const PopoverChannel = {
     Show: 'popover:show',

package/dist/shared/ipc-schemas.d.ts

@@ -25,10 +25,73 @@ export declare const ProjectSaveCompileConfigSchema: z.ZodTuple<[z.ZodString, z.
 }, z.core.$loose>], null>;
 /** popover:show — must be an object (not undefined/null/string). */
 export declare const PopoverShowSchema: z.ZodTuple<[z.ZodObject<{}, z.core.$loose>], null>;
-/** simulator:attach — webContents id (positive int) + simulator width. */
-export declare const SimulatorAttachSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+/**
+ * simulator:attach-native (native-host only) — the simulator URL to load into
+ * the top-level WebContentsView + simulator width. The URL is the dev-server
+ * `http://localhost:<port>/simulator.html?…` the renderer would otherwise put
+ * on the `<webview src>`; we validate it's an http(s) URL to keep the WCV off
+ * arbitrary origins (will-navigate hardening re-checks at navigation time).
+ */
+export declare const SimulatorAttachNativeSchema: z.ZodTuple<[z.ZodString, z.ZodNumber], null>;
 /** simulator:resize — simulator width. */
 export declare const SimulatorResizeSchema: z.ZodTuple<[z.ZodNumber], null>;
+/**
+ * simulator:set-native-bounds (native-host only) — the renderer-measured
+ * device-bezel inner-screen rect (CSS px, from `getBoundingClientRect()`, may
+ * be fractional/zero) plus the device zoom percent. Positioned 1:1 as the
+ * simulator WCV overlay bounds. Coordinates are plain finite numbers (x/y may
+ * be negative when scrolled off-screen); zoom is the ZOOM_OPTIONS percent.
+ */
+export declare const SimulatorSetNativeBoundsSchema: z.ZodTuple<[z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    zoom: z.ZodNumber;
+}, z.core.$strip>], null>;
+/**
+ * simulator:set-device-info (native-host only) — the selected device's logical
+ * metrics, mapped by main into the service-host window's HostEnvSnapshot. Sizes
+ * are bounded positive ints (logical device px); strings are bounded to keep the
+ * payload small. Matches `NativeDeviceInfo` in ipc-channels.ts.
+ */
+export declare const SimulatorSetDeviceInfoSchema: z.ZodTuple<[z.ZodObject<{
+    brand: z.ZodString;
+    model: z.ZodString;
+    system: z.ZodString;
+    platform: z.ZodString;
+    pixelRatio: z.ZodNumber;
+    screenWidth: z.ZodNumber;
+    screenHeight: z.ZodNumber;
+    statusBarHeight: z.ZodNumber;
+    safeAreaBottom: z.ZodNumber;
+    notchType: z.ZodEnum<{
+        none: "none";
+        notch: "notch";
+        "dynamic-island": "dynamic-island";
+    }>;
+    safeAreaInsets: z.ZodObject<{
+        top: z.ZodNumber;
+        right: z.ZodNumber;
+        bottom: z.ZodNumber;
+        left: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>], null>;
+export declare const ViewBoundsSchema: z.ZodTuple<[z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>], null>;
+/**
+ * host-toolbar reverse size-advertiser payload — the toolbar WCV renderer
+ * advertises its intrinsic content height on the block axis. Mirrors
+ * `@dimina-kit/view-anchor`'s `AdvertisedSize`.
+ */
+export declare const HostToolbarAdvertiseHeightSchema: z.ZodTuple<[z.ZodObject<{
+    axis: z.ZodLiteral<"block">;
+    extent: z.ZodNumber;
+}, z.core.$strip>], null>;
 /** simulator:setVisible — visible flag + simulator width. */
 export declare const SimulatorSetVisibleSchema: z.ZodTuple<[z.ZodBoolean, z.ZodNumber], null>;
 /**

package/dist/shared/ipc-schemas.js

@@ -50,13 +50,89 @@ export const PopoverShowSchema = z.tuple([z.looseObject({})]);
  * we still reject obvious garbage (negative, zero, absurdly large).
  */
 const SimWidth = z.number().int().min(100).max(2000);
-/** simulator:attach — webContents id (positive int) + simulator width. */
-export const SimulatorAttachSchema = z.tuple([
-    z.number().int().positive(),
+/**
+ * simulator:attach-native (native-host only) — the simulator URL to load into
+ * the top-level WebContentsView + simulator width. The URL is the dev-server
+ * `http://localhost:<port>/simulator.html?…` the renderer would otherwise put
+ * on the `<webview src>`; we validate it's an http(s) URL to keep the WCV off
+ * arbitrary origins (will-navigate hardening re-checks at navigation time).
+ */
+export const SimulatorAttachNativeSchema = z.tuple([
+    z.string().url().refine((u) => u.startsWith('http://') || u.startsWith('https://'), {
+        message: 'simulator URL must be http(s)',
+    }),
     SimWidth,
 ]);
 /** simulator:resize — simulator width. */
 export const SimulatorResizeSchema = z.tuple([SimWidth]);
+/**
+ * simulator:set-native-bounds (native-host only) — the renderer-measured
+ * device-bezel inner-screen rect (CSS px, from `getBoundingClientRect()`, may
+ * be fractional/zero) plus the device zoom percent. Positioned 1:1 as the
+ * simulator WCV overlay bounds. Coordinates are plain finite numbers (x/y may
+ * be negative when scrolled off-screen); zoom is the ZOOM_OPTIONS percent.
+ */
+export const SimulatorSetNativeBoundsSchema = z.tuple([
+    z.object({
+        x: z.number().finite(),
+        y: z.number().finite(),
+        width: z.number().finite(),
+        height: z.number().finite(),
+        zoom: z.number().finite().positive(),
+    }),
+]);
+/**
+ * simulator:set-device-info (native-host only) — the selected device's logical
+ * metrics, mapped by main into the service-host window's HostEnvSnapshot. Sizes
+ * are bounded positive ints (logical device px); strings are bounded to keep the
+ * payload small. Matches `NativeDeviceInfo` in ipc-channels.ts.
+ */
+export const SimulatorSetDeviceInfoSchema = z.tuple([
+    z.object({
+        brand: z.string().max(64),
+        model: z.string().max(64),
+        system: z.string().max(64),
+        platform: z.string().max(32),
+        pixelRatio: z.number().finite().positive(),
+        screenWidth: z.number().int().min(100).max(4000),
+        screenHeight: z.number().int().min(100).max(4000),
+        statusBarHeight: z.number().finite().min(0).max(400),
+        safeAreaBottom: z.number().finite().min(0).max(400),
+        notchType: z.enum(['none', 'notch', 'dynamic-island']),
+        safeAreaInsets: z.object({
+            top: z.number().finite().min(0).max(400),
+            right: z.number().finite().min(0).max(400),
+            bottom: z.number().finite().min(0).max(400),
+            left: z.number().finite().min(0).max(400),
+        }),
+    }),
+]);
+/**
+ * view:*:bounds — renderer-measured CSS pixel rectangle in window content
+ * coordinates. Width/height = 0 is the canonical "overlay hidden" signal.
+ * No upper bound is enforced (window can be very large); we only refuse
+ * negative/NaN values that would break setBounds.
+ */
+const NonNegInt = z.number().int().min(0).max(100_000);
+export const ViewBoundsSchema = z.tuple([
+    z.object({
+        x: NonNegInt,
+        y: NonNegInt,
+        width: NonNegInt,
+        height: NonNegInt,
+    }),
+]);
+/**
+ * host-toolbar reverse size-advertiser payload — the toolbar WCV renderer
+ * advertises its intrinsic content height on the block axis. Mirrors
+ * `@dimina-kit/view-anchor`'s `AdvertisedSize`.
+ */
+export const HostToolbarAdvertiseHeightSchema = z.tuple([
+    z.object({
+        axis: z.literal('block'),
+        extent: NonNegInt,
+    }),
+]);
 /** simulator:setVisible — visible flag + simulator width. */
 export const SimulatorSetVisibleSchema = z.tuple([z.boolean(), SimWidth]);
 /**

package/dist/shared/open-in-editor.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Shared, pure helpers for the "click a console file link → open the built-in
+ * Monaco editor" pipeline (native-host).
+ *
+ * The right-panel console is the embedded Chromium DevTools front-end inspecting
+ * the service host. When a sourcemap maps a console frame back to source, the
+ * front-end can be made to route a source-link click through an "open resource
+ * handler" instead of its own Sources panel (the same hook IDEs use to integrate
+ * with Chrome DevTools). Our handler can't talk IPC directly from the closed
+ * DevTools realm, so it encodes the target as a sentinel URL and asks the
+ * front-end to "open" it; Electron surfaces that as a `devtools-open-url` event
+ * on the inspected webContents, which main decodes here.
+ *
+ * This module owns ONLY the pure string/URL logic (encode + decode + map a
+ * DevTools resource URL to a project-relative path). It has no electron / DOM /
+ * node deps so it is unit-testable and shared by main + the injected front-end
+ * snippet's expectations.
+ */
+/**
+ * Sentinel scheme for the encoded "open in editor" request. A bare custom scheme
+ * (no `//authority`) keeps the encoded payload entirely in the URL's path/query,
+ * which `InspectorFrontendHost.openInNewTab` forwards verbatim to Electron's
+ * `devtools-open-url` event.
+ */
+export declare const OPEN_IN_EDITOR_SCHEME = "dimina-open-in-editor";
+/** A decoded open-in-editor request: a project source location. */
+export interface OpenInEditorRequest {
+    /** The DevTools resource URL of the clicked source (the map `sources` entry, absolute). */
+    url: string;
+    /** 0-based line as reported by DevTools (may be undefined for a bare file link). */
+    line?: number;
+    /** 0-based column as reported by DevTools (may be undefined). */
+    column?: number;
+}
+/**
+ * Encode an open-in-editor request as a sentinel URL the DevTools front-end can
+ * hand to `InspectorFrontendHost.openInNewTab(...)`. All fields ride in the
+ * query string so no value is ever interpolated into a path segment.
+ */
+export declare function encodeOpenInEditorUrl(req: OpenInEditorRequest): string;
+/**
+ * Decode a sentinel URL produced by `encodeOpenInEditorUrl`. Returns null for
+ * any URL that is not our sentinel scheme (so a real "open in new tab" link the
+ * user clicked is left to Electron's default external-open path).
+ */
+export declare function decodeOpenInEditorUrl(raw: string): OpenInEditorRequest | null;
+/**
+ * Map a DevTools resource URL to a PROJECT-RELATIVE source path (POSIX, no
+ * leading slash) — the same key the in-renderer Monaco editor opens files by
+ * (`joinPosix(root, rel)` → `project:fs:readFile`).
+ *
+ * The compiler emits each `logic.js.map` with `sources` = the project-relative
+ * source path (e.g. `pages/home/home.js`, or `subpkg/pages/x/x.js` for a sub-
+ * package — both already rooted at the project). DevTools resolves those against
+ * the map URL on the dev server, producing
+ * `http://127.0.0.1:<port>/<appId>/<source-path>`. So recovering the project-
+ * relative path is exactly: strip the origin, then strip the FIRST path segment
+ * (the `<appId>` the dev server namespaces the bundle under). What remains is
+ * the source path the compiler recorded, which is the editor's open key — this
+ * holds for both the main package and sub-packages without needing the project's
+ * appId / root threaded in.
+ *
+ * @param resourceUrl  The absolute URL DevTools reported for the clicked source.
+ * @param expectedOrigin  Optional dev-server origin to gate on
+ *   (`http://127.0.0.1:<port>`); when given, a URL from a different origin (a
+ *   framework/`webpack://`/`node:` frame) returns null instead of mis-mapping.
+ * @returns the project-relative POSIX path, or null when the URL is not a
+ *   mappable dev-server source.
+ */
+export declare function resourceUrlToProjectRelativePath(resourceUrl: string, expectedOrigin?: string): string | null;
+//# sourceMappingURL=open-in-editor.d.ts.map