@dimina-kit/devtools 0.3.2-dev.20260601115343 → 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: {
@@ -110,6 +163,19 @@ export declare const ProjectFsChannel: {
     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";
@@ -140,6 +206,23 @@ export declare const PanelChannel: {
 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;

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',
@@ -95,6 +146,18 @@ export const ProjectFsChannel = {
     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',
@@ -135,6 +198,23 @@ export const PanelChannel = {
 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 = {

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

@@ -25,16 +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,63 @@ 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.
@@ -72,6 +122,17 @@ export const ViewBoundsSchema = z.tuple([
         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

package/dist/shared/open-in-editor.js

@@ -0,0 +1,138 @@
+/**
+ * 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 const OPEN_IN_EDITOR_SCHEME = 'dimina-open-in-editor';
+/**
+ * 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 function encodeOpenInEditorUrl(req) {
+    const params = new URLSearchParams();
+    params.set('u', req.url);
+    if (typeof req.line === 'number' && Number.isFinite(req.line)) {
+        params.set('l', String(Math.trunc(req.line)));
+    }
+    if (typeof req.column === 'number' && Number.isFinite(req.column)) {
+        params.set('c', String(Math.trunc(req.column)));
+    }
+    return `${OPEN_IN_EDITOR_SCHEME}:?${params.toString()}`;
+}
+/**
+ * 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 function decodeOpenInEditorUrl(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const prefix = `${OPEN_IN_EDITOR_SCHEME}:`;
+    if (!raw.startsWith(prefix))
+        return null;
+    // Strip the scheme; tolerate an optional leading `?` on the query.
+    let query = raw.slice(prefix.length);
+    if (query.startsWith('?'))
+        query = query.slice(1);
+    const params = new URLSearchParams(query);
+    const url = params.get('u');
+    if (!url)
+        return null;
+    const out = { url };
+    const l = params.get('l');
+    const c = params.get('c');
+    if (l !== null && l !== '') {
+        const n = Number(l);
+        if (Number.isFinite(n))
+            out.line = Math.trunc(n);
+    }
+    if (c !== null && c !== '') {
+        const n = Number(c);
+        if (Number.isFinite(n))
+            out.column = Math.trunc(n);
+    }
+    return out;
+}
+/**
+ * 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 function resourceUrlToProjectRelativePath(resourceUrl, expectedOrigin) {
+    if (typeof resourceUrl !== 'string' || !resourceUrl)
+        return null;
+    let resource;
+    try {
+        resource = new URL(resourceUrl);
+    }
+    catch {
+        return null;
+    }
+    // Only http(s) dev-server sources map to project files; schemes like
+    // `webpack://`, `node:`, `data:` are framework/runtime frames with no file.
+    if (resource.protocol !== 'http:' && resource.protocol !== 'https:')
+        return null;
+    if (expectedOrigin) {
+        let base;
+        try {
+            base = new URL(expectedOrigin);
+        }
+        catch {
+            return null;
+        }
+        if (resource.origin !== base.origin)
+            return null;
+    }
+    // pathname is `/<appId>/<source-path>`. Drop the leading appId segment; the
+    // remainder, percent-decoded per segment, is the project-relative path.
+    const segments = resource.pathname.split('/').filter(Boolean).map((s) => {
+        try {
+            return decodeURIComponent(s);
+        }
+        catch {
+            return s;
+        }
+    });
+    if (segments.length < 2)
+        return null;
+    return segments.slice(1).join('/');
+}
+//# sourceMappingURL=open-in-editor.js.map

package/dist/shared/simulator-api-metadata.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Persistent (subscription) simulator APIs — a call that, once made, keeps
+ * delivering a response on every underlying event instead of settling once.
+ *
+ * The dimina service runtime strips `keep` / `evtId` / `success` before the
+ * call leaves the service host (it stores them service-local in
+ * `callback.store`), so by the time `audioListen` reaches the container its
+ * `keep: true` intent is gone and it would degrade to a one-shot call —
+ * dropping every audio DOM event after the first. The container and router
+ * therefore recognise these APIs by NAME and treat them as persistent
+ * regardless of the (stripped) params.
+ *
+ * Currently only `audioListen` — the InnerAudioContext DOM-event bridge
+ * (canplay / play / pause / ended / error / timeupdate / waiting / seeking /
+ * seeked). Add any new subscription API here: this is the single source of
+ * truth, consumed by `bridge-router` (skip the one-shot timeout, keep-alive
+ * responses) and `run-api-async` (no premature settle, re-fire on every event).
+ */
+export declare const PERSISTENT_SIMULATOR_APIS: ReadonlySet<string>;
+export declare function isPersistentSimulatorApi(name: string): boolean;
+//# sourceMappingURL=simulator-api-metadata.d.ts.map