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

package/dist/main/ipc/bridge-router.js

@@ -1,13 +1,14 @@
 import { app, ipcMain, protocol, session as electronSession, webContents } from 'electron';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { BRIDGE_CHANNELS as C, SIMULATOR_EVENTS as E } from '../../shared/bridge-channels.js';
+import { BRIDGE_CHANNELS as C, SIMULATOR_EVENTS as E, deviceInfoToHostEnv } from '../../shared/bridge-channels.js';
 import { isPersistentSimulatorApi } from '../../shared/simulator-api-metadata.js';
 import { devtoolsPackageRoot } from '../utils/paths.js';
 import { createDebugTap } from '@dimina-kit/electron-deck/main';
 import { startDiminaResourceServer } from '../services/dimina-resource-server.js';
 import { buildServiceHostSpawnUrl, createServiceHostWindow, navigateServiceHost, serviceHostSpec, } from '../windows/service-host-window/create.js';
 import { ServiceHostPool } from '../services/service-host-pool/pool.js';
+import { registerMiniappSessionConfigurator, SHARED_MINIAPP_PARTITION, } from '../services/views/miniapp-partition.js';
 import { createConsoleForwarder } from '../services/console-forward/index.js';
 import { STORAGE_API_NAMES } from '../services/simulator-storage/index.js';
 const STACK_ID = 'stack_0';
@@ -417,7 +418,18 @@ async function handleSpawn(state, ctx, event, opts) {
         resourceServer = await startDiminaResourceServer(path.resolve(pkgRoot, root));
         resourceBaseUrl = resourceServer.baseUrl;
     }
-    const hostEnv = makeHostEnv(opts.hostEnvSnapshot);
+    // The selected device (renderer toolbar) is the authoritative source for the
+    // logical dims a spawn must report. The simulator-supplied `hostEnvSnapshot`
+    // is derived from the device baked into the simulator at BOOT time, so on a
+    // RESPAWN after a live device change it still carries the boot device. Layer
+    // the live `currentDevice` on top so every spawn/respawn reports the selected
+    // device — matching what the live `SetDeviceInfo` HostEnvUpdate pushes to an
+    // already-running service host. Pre-selection (null) → simulator snapshot wins.
+    const selectedDevice = ctx.bridge?.getDevice?.() ?? null;
+    const hostEnv = makeHostEnv({
+        ...opts.hostEnvSnapshot,
+        ...(selectedDevice ? deviceInfoToHostEnv(selectedDevice) : {}),
+    });
     // app-config.json lives at `<base><appId>/<root>/app-config.json` on the dev
     // server, or at the local server root for the fallback path.
     const appConfig = await loadAppConfig(resourceServer ? resourceServer.baseUrl : `${resourceBaseUrl}${appId}/${root}/`);
@@ -1256,7 +1268,7 @@ function installResourceProtocolHandlers(ctx, state) {
         const target = new URL(url.pathname.replace(/^\/+/, '') + url.search, ap.resourceBaseUrl);
         return fetch(target);
     };
-    const simulatorSession = electronSession.fromPartition('persist:simulator');
+    const simulatorSession = electronSession.fromPartition(SHARED_MINIAPP_PARTITION);
     try {
         protocol.unhandle('dmb-resource');
     }
@@ -1267,7 +1279,22 @@ function installResourceProtocolHandlers(ctx, state) {
     catch { }
     protocol.handle('dmb-resource', handler);
     simulatorSession.protocol.handle('dmb-resource', handler);
+    // Per-project partition sessions need the SAME resource handler so each
+    // project's render/service can load `dmb-resource://…`. Install on every
+    // miniapp partition (current + future); track installed sessions for teardown.
+    const perProjectSessions = new Set();
+    const unregisterConfigurator = registerMiniappSessionConfigurator((sess) => {
+        if (perProjectSessions.has(sess))
+            return;
+        perProjectSessions.add(sess);
+        try {
+            sess.protocol.unhandle('dmb-resource');
+        }
+        catch { }
+        sess.protocol.handle('dmb-resource', handler);
+    });
     ctx.registry.add(() => {
+        unregisterConfigurator();
         try {
             protocol.unhandle('dmb-resource');
         }
@@ -1276,6 +1303,12 @@ function installResourceProtocolHandlers(ctx, state) {
             simulatorSession.protocol.unhandle('dmb-resource');
         }
         catch { }
+        for (const sess of perProjectSessions) {
+            try {
+                sess.protocol.unhandle('dmb-resource');
+            }
+            catch { }
+        }
     });
 }
 function makeHostEnv(snapshot) {

package/dist/main/ipc/simulator.js

@@ -1,28 +1,8 @@
 import { ServiceHostChannel, SimulatorChannel, SimulatorCustomApiChannel } from '../../shared/ipc-channels.js';
 import { SimulatorAttachNativeSchema, SimulatorCustomApiInvokeSchema, SimulatorResizeSchema, SimulatorSetDeviceInfoSchema, SimulatorSetNativeBoundsSchema, SimulatorSetVisibleSchema, } from '../../shared/ipc-schemas.js';
+import { deviceInfoToHostEnv } from '../../shared/bridge-channels.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-/**
- * Map the renderer's logical device metrics onto the subset of a
- * HostEnvSnapshot the service-host window's `getSystemInfoSync` consumes.
- * `windowHeight` excludes the status bar (the page area); `windowWidth` has no
- * horizontal chrome. Zoom is intentionally absent — it is a display scale, not
- * a logical-size change.
- */
-function deviceInfoToHostEnv(d) {
-    return {
-        brand: d.brand,
-        model: d.model,
-        system: d.system,
-        platform: d.platform,
-        pixelRatio: d.pixelRatio,
-        screenWidth: d.screenWidth,
-        screenHeight: d.screenHeight,
-        windowWidth: d.screenWidth,
-        windowHeight: Math.max(0, d.screenHeight - d.statusBarHeight),
-        statusBarHeight: d.statusBarHeight,
-    };
-}
 export function registerSimulatorIpc(ctx) {
     return new IpcRegistry(ctx.senderPolicy)
         .handle(SimulatorChannel.AttachNative, (_, ...args) => {

package/dist/main/services/simulator-temp-files/index.js

@@ -31,6 +31,7 @@ import { IpcRegistry } from '../../utils/ipc-registry.js';
 import { toDisposable } from '@dimina-kit/electron-deck/main';
 import { registerTempFile, revokeTempFile, revokeAllTempFiles } from './store.js';
 import { handleDifileRequest } from './request-handler.js';
+import { registerMiniappSessionConfigurator } from '../views/miniapp-partition.js';
 import { handleFsMkdir, handleFsRead, handleFsReaddir, handleFsStat, handleFsUnlink, handleFsWrite, } from './fs-channels.js';
 /** Upper bound for in-memory entries; oldest insertion is evicted (FIFO). */
 const MAX_STORE_ENTRIES = 200;
@@ -63,7 +64,12 @@ export function setupSimulatorTempFiles(simSession) {
             for (const fn of list)
                 fn();
     }
-    const simulatorOnlyPolicy = sender => !sender.isDestroyed() && sender.session === simSession;
+    // The protocol handler + IPC channels are shared across every per-project
+    // miniapp partition session (each project's render/service runs the same
+    // difile:// + temp-file FSM). The base session is always trusted; additional
+    // per-project partition sessions register themselves via `installOnSession`.
+    const trustedSessions = new Set([simSession]);
+    const simulatorOnlyPolicy = sender => !sender.isDestroyed() && trustedSessions.has(sender.session);
     const registry = new IpcRegistry(simulatorOnlyPolicy);
     registry.on('simulator:temp-file:write', (_event, payload) => {
         if (disposed)
@@ -84,15 +90,7 @@ export function setupSimulatorTempFiles(simSession) {
             return;
         revokeAllTempFiles(store);
     });
-    // Idempotent: a stale handler from a prior setup (e.g. fast app
-    // re-init in tests) is replaced rather than throwing.
-    try {
-        simSession.protocol.unhandle('difile');
-    }
-    catch {
-        // Not previously registered — fine.
-    }
-    simSession.protocol.handle('difile', async (req) => {
+    const difileHandler = async (req) => {
         const url = req.url;
         // Forward any HTTP headers Electron parsed (Range / If-None-Match)
         // to the pure dispatcher so it can do its own conditional / range
@@ -135,7 +133,28 @@ export function setupSimulatorTempFiles(simSession) {
             res = await handleDifileRequest(ctx, { url, headers });
         }
         return res;
-    });
+    };
+    // Install the difile:// protocol handler on a session. Idempotent per
+    // session: a stale handler from a prior setup (e.g. fast app re-init in
+    // tests) is replaced rather than throwing. Trusts that session's senders for
+    // the temp-file / fs IPC channels.
+    const installedSessions = new Set();
+    function installOnSession(sess) {
+        trustedSessions.add(sess);
+        if (installedSessions.has(sess))
+            return;
+        installedSessions.add(sess);
+        try {
+            sess.protocol.unhandle('difile');
+        }
+        catch {
+            // Not previously registered — fine.
+        }
+        sess.protocol.handle('difile', difileHandler);
+    }
+    installOnSession(simSession);
+    // Apply to every per-project miniapp partition session (current + future).
+    const unregisterConfigurator = registerMiniappSessionConfigurator((sess) => installOnSession(sess));
     // Phase 1 (P1-7): renderer FSM → main fs operations bridge. The same
     // simulator-only sender policy applies — registry instance is shared.
     registry.handle('simulator:fs:read', (_event, payload) => handleFsRead(payload));
@@ -146,13 +165,16 @@ export function setupSimulatorTempFiles(simSession) {
     registry.handle('simulator:fs:mkdir', (_event, payload) => handleFsMkdir(payload));
     return toDisposable(async () => {
         disposed = true;
+        unregisterConfigurator();
         drainAllWaiters();
         store.clear();
-        try {
-            simSession.protocol.unhandle('difile');
-        }
-        catch {
-            // May already have been unhandled by app shutdown.
+        for (const sess of installedSessions) {
+            try {
+                sess.protocol.unhandle('difile');
+            }
+            catch {
+                // May already have been unhandled by app shutdown.
+            }
         }
         await registry.dispose();
     });

package/dist/main/services/views/miniapp-partition.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Per-project session partition for the native-host miniapp runtime (P0 debt).
+ *
+ * Historically every project's miniapp webContents — the simulator content
+ * WebContentsView, its nested render-host `<webview>` guests, AND the
+ * service-host window — shared ONE hard-coded `persist:simulator` Electron
+ * session. Cookies / localStorage / cache / IndexedDB written by project A were
+ * visible to (and clobbered by) project B; two projects open at once cross-
+ * contaminate and "clear storage" on one nukes the other.
+ *
+ * The fix derives a STABLE per-project partition from the project identity (the
+ * miniapp `appId`, which flows in via the simulator URL `?appId=` and the spawn
+ * path's `appId`). Same project → same partition (storage survives a relaunch);
+ * different projects → different partitions (no cross-contamination). The shape
+ * mirrors the IDE state of the art (WeChat's static partition, ByteDance's
+ * `persist:miniapp-<id>` dynamic partition).
+ *
+ * The protocol handlers (`difile://`, `dmb-resource`) and webRequest policies
+ * (referer / CORS) that the simulator runtime needs were installed once on the
+ * single `persist:simulator` session. With per-project partitions those have to
+ * be (re)applied to EACH project session the first time it is used. The setup
+ * sites register a partition-agnostic configurator here; `configureMiniappSession`
+ * runs every registered configurator exactly once per partition.
+ *
+ * Partition CLEANUP (reclaiming on-disk `persist:` data) is intentionally NOT
+ * done here — leaving the data on disk is the whole point of a `persist:`
+ * partition (cache/storage survives a relaunch). That is a separate concern.
+ */
+import type { Session } from 'electron';
+/** The legacy single-session partition. Still used by the pre-warm pool (which
+ * is intentionally NOT isolation-aware — see `serviceHostSpec`) and as the
+ * fallback when a project key cannot be derived. */
+export declare const SHARED_MINIAPP_PARTITION = "persist:simulator";
+/**
+ * Derive a stable, filesystem-safe partition key from a project `appId`.
+ *
+ * `appId` is the project identity (e.g. a `wxapp…` id). We pass through the
+ * characters Electron is happy to put in a session partition / on-disk folder
+ * name (`[A-Za-z0-9_-]`) verbatim so the common case is human-legible, and fold
+ * anything else into a short deterministic hash suffix so two appIds that differ
+ * only in stripped characters never collide. The same `appId` always yields the
+ * same key (so storage survives a relaunch); different `appId`s yield different
+ * keys.
+ */
+export declare function miniappPartitionKey(appId: string): string;
+/**
+ * The Electron session partition for a project. Returns the SHARED partition
+ * when `appId` is empty/unknown (so the runtime still has a session to load on,
+ * matching the legacy behavior) and a `persist:miniapp-<key>` partition
+ * otherwise.
+ */
+export declare function miniappPartition(appId: string | null | undefined): string;
+type SessionConfigurator = (sess: Session, partition: string) => void;
+/**
+ * Register a configurator that runs against every miniapp partition session.
+ * Already-configured partitions are (re)configured immediately so registration
+ * order does not matter. Returns a disposer that unregisters the configurator
+ * (it does not undo work already applied to live sessions).
+ */
+export declare function registerMiniappSessionConfigurator(fn: SessionConfigurator): () => void;
+/**
+ * Ensure a partition's session has every registered configurator applied. Safe
+ * to call repeatedly per partition (idempotent — each partition is configured
+ * once). Call this before loading project content on `partition`.
+ *
+ * Returns `null` when there is nothing to configure (no configurator registered)
+ * so the partition derivation stays independent of any live Electron session —
+ * the partition is a constructor-time fact, not a side effect of touching the
+ * session API. Setup sites register configurators at app boot; in unit tests
+ * that mock `electron` without a `session` export this short-circuits cleanly.
+ */
+export declare function configureMiniappSession(partition: string): Session | null;
+/**
+ * Test-only: drop the configurator + configured-partition bookkeeping so each
+ * test starts from a clean slate. (Module-level state otherwise leaks across
+ * unit tests that mock `electron`.)
+ */
+export declare function __resetMiniappSessionConfigForTests(): void;
+export {};
+//# sourceMappingURL=miniapp-partition.d.ts.map

package/dist/main/services/views/miniapp-partition.js

@@ -0,0 +1,138 @@
+/**
+ * Per-project session partition for the native-host miniapp runtime (P0 debt).
+ *
+ * Historically every project's miniapp webContents — the simulator content
+ * WebContentsView, its nested render-host `<webview>` guests, AND the
+ * service-host window — shared ONE hard-coded `persist:simulator` Electron
+ * session. Cookies / localStorage / cache / IndexedDB written by project A were
+ * visible to (and clobbered by) project B; two projects open at once cross-
+ * contaminate and "clear storage" on one nukes the other.
+ *
+ * The fix derives a STABLE per-project partition from the project identity (the
+ * miniapp `appId`, which flows in via the simulator URL `?appId=` and the spawn
+ * path's `appId`). Same project → same partition (storage survives a relaunch);
+ * different projects → different partitions (no cross-contamination). The shape
+ * mirrors the IDE state of the art (WeChat's static partition, ByteDance's
+ * `persist:miniapp-<id>` dynamic partition).
+ *
+ * The protocol handlers (`difile://`, `dmb-resource`) and webRequest policies
+ * (referer / CORS) that the simulator runtime needs were installed once on the
+ * single `persist:simulator` session. With per-project partitions those have to
+ * be (re)applied to EACH project session the first time it is used. The setup
+ * sites register a partition-agnostic configurator here; `configureMiniappSession`
+ * runs every registered configurator exactly once per partition.
+ *
+ * Partition CLEANUP (reclaiming on-disk `persist:` data) is intentionally NOT
+ * done here — leaving the data on disk is the whole point of a `persist:`
+ * partition (cache/storage survives a relaunch). That is a separate concern.
+ */
+import * as electron from 'electron';
+/** The legacy single-session partition. Still used by the pre-warm pool (which
+ * is intentionally NOT isolation-aware — see `serviceHostSpec`) and as the
+ * fallback when a project key cannot be derived. */
+export const SHARED_MINIAPP_PARTITION = 'persist:simulator';
+const PARTITION_PREFIX = 'persist:miniapp-';
+/**
+ * Derive a stable, filesystem-safe partition key from a project `appId`.
+ *
+ * `appId` is the project identity (e.g. a `wxapp…` id). We pass through the
+ * characters Electron is happy to put in a session partition / on-disk folder
+ * name (`[A-Za-z0-9_-]`) verbatim so the common case is human-legible, and fold
+ * anything else into a short deterministic hash suffix so two appIds that differ
+ * only in stripped characters never collide. The same `appId` always yields the
+ * same key (so storage survives a relaunch); different `appId`s yield different
+ * keys.
+ */
+export function miniappPartitionKey(appId) {
+    const safe = appId.replace(/[^A-Za-z0-9_-]/g, '');
+    // Folding may have dropped distinguishing characters; if the input was not
+    // already fully safe, append a deterministic hash of the RAW appId so two
+    // distinct appIds can never alias onto the same key.
+    if (safe === appId && safe.length > 0)
+        return safe;
+    const hash = djb2(appId).toString(36);
+    return safe.length > 0 ? `${safe}-${hash}` : hash;
+}
+/**
+ * The Electron session partition for a project. Returns the SHARED partition
+ * when `appId` is empty/unknown (so the runtime still has a session to load on,
+ * matching the legacy behavior) and a `persist:miniapp-<key>` partition
+ * otherwise.
+ */
+export function miniappPartition(appId) {
+    if (!appId)
+        return SHARED_MINIAPP_PARTITION;
+    return `${PARTITION_PREFIX}${miniappPartitionKey(appId)}`;
+}
+/** Small, stable string hash (djb2). Not cryptographic — only needs to be
+ * deterministic and collision-resistant enough to disambiguate appIds. */
+function djb2(input) {
+    let h = 5381;
+    for (let i = 0; i < input.length; i++) {
+        h = ((h << 5) + h + input.charCodeAt(i)) >>> 0;
+    }
+    return h;
+}
+const configurators = new Set();
+const configuredPartitions = new Set();
+/**
+ * Register a configurator that runs against every miniapp partition session.
+ * Already-configured partitions are (re)configured immediately so registration
+ * order does not matter. Returns a disposer that unregisters the configurator
+ * (it does not undo work already applied to live sessions).
+ */
+export function registerMiniappSessionConfigurator(fn) {
+    configurators.add(fn);
+    for (const partition of configuredPartitions) {
+        try {
+            fn(electron.session.fromPartition(partition), partition);
+        }
+        catch (err) {
+            console.warn('[miniapp-partition] configurator failed for', partition, err);
+        }
+    }
+    return () => {
+        configurators.delete(fn);
+    };
+}
+/**
+ * Ensure a partition's session has every registered configurator applied. Safe
+ * to call repeatedly per partition (idempotent — each partition is configured
+ * once). Call this before loading project content on `partition`.
+ *
+ * Returns `null` when there is nothing to configure (no configurator registered)
+ * so the partition derivation stays independent of any live Electron session —
+ * the partition is a constructor-time fact, not a side effect of touching the
+ * session API. Setup sites register configurators at app boot; in unit tests
+ * that mock `electron` without a `session` export this short-circuits cleanly.
+ */
+export function configureMiniappSession(partition) {
+    // Record that this partition should be configured even if no configurator is
+    // registered YET — a later `registerMiniappSessionConfigurator` back-fills it.
+    const alreadyConfigured = configuredPartitions.has(partition);
+    configuredPartitions.add(partition);
+    if (configurators.size === 0)
+        return null;
+    const sess = electron.session.fromPartition(partition);
+    if (alreadyConfigured)
+        return sess;
+    for (const fn of configurators) {
+        try {
+            fn(sess, partition);
+        }
+        catch (err) {
+            console.warn('[miniapp-partition] configurator failed for', partition, err);
+        }
+    }
+    return sess;
+}
+/**
+ * Test-only: drop the configurator + configured-partition bookkeeping so each
+ * test starts from a clean slate. (Module-level state otherwise leaks across
+ * unit tests that mock `electron`.)
+ */
+export function __resetMiniappSessionConfigForTests() {
+    configurators.clear();
+    configuredPartitions.clear();
+}
+//# sourceMappingURL=miniapp-partition.js.map

package/dist/main/services/views/simulator-session-policy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Referer + CORS webRequest policy for the simulator runtime's sessions.
+ *
+ * The native render/service hosts fetch the compiled `<appId>/…` resources
+ * cross-origin and need a WeChat-style page-frame `Referer`; this installs that
+ * policy on the shared fallback session AND on every per-project
+ * `persist:miniapp-<key>` partition (current + future) via the partition
+ * configurator registry, so isolated projects load resources identically.
+ *
+ * TEARDOWN: a `webRequest` listener is per-session and there is exactly one
+ * slot per (session, event) — re-installing replaces, never stacks. But the
+ * configurator registration itself leaks if discarded: re-creating the
+ * WorkbenchApp in the same process would register a second configurator that
+ * keeps firing for every future partition. So this returns a {@link Disposable}
+ * that unregisters the configurator AND clears the listeners off every session
+ * it touched. Wire it into the context registry like any other module.
+ */
+import { type Disposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Install the simulator referer/CORS policy on the shared fallback session and
+ * register a configurator so every per-project partition session gets it too.
+ * Returns a disposable that unregisters the configurator and clears the policy
+ * off every session it installed on — call its teardown when the owning
+ * context is disposed so re-creating the app never leaks a duplicate
+ * configurator/listener.
+ */
+export declare function setupSimulatorSessionPolicy(): Disposable;
+//# sourceMappingURL=simulator-session-policy.d.ts.map

package/dist/main/services/views/simulator-session-policy.js

@@ -0,0 +1,82 @@
+/**
+ * Referer + CORS webRequest policy for the simulator runtime's sessions.
+ *
+ * The native render/service hosts fetch the compiled `<appId>/…` resources
+ * cross-origin and need a WeChat-style page-frame `Referer`; this installs that
+ * policy on the shared fallback session AND on every per-project
+ * `persist:miniapp-<key>` partition (current + future) via the partition
+ * configurator registry, so isolated projects load resources identically.
+ *
+ * TEARDOWN: a `webRequest` listener is per-session and there is exactly one
+ * slot per (session, event) — re-installing replaces, never stacks. But the
+ * configurator registration itself leaks if discarded: re-creating the
+ * WorkbenchApp in the same process would register a second configurator that
+ * keeps firing for every future partition. So this returns a {@link Disposable}
+ * that unregisters the configurator AND clears the listeners off every session
+ * it touched. Wire it into the context registry like any other module.
+ */
+import { session } from 'electron';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+import { getSimulatorServicewechatReferer } from '../simulator/referer.js';
+import { registerMiniappSessionConfigurator, SHARED_MINIAPP_PARTITION, } from './miniapp-partition.js';
+/** Apply the simulator runtime's referer + CORS webRequest policy to one
+ * session. Each session installs its own listeners (a webRequest listener is
+ * per-session), so this runs once per partition. */
+function applySimulatorWebRequestPolicy(simulatorSession) {
+    simulatorSession.webRequest.onBeforeSendHeaders((details, callback) => {
+        const forcedReferer = getSimulatorServicewechatReferer();
+        if (forcedReferer) {
+            details.requestHeaders['Referer'] = forcedReferer;
+        }
+        callback({ requestHeaders: details.requestHeaders });
+    });
+    simulatorSession.webRequest.onHeadersReceived((details, callback) => {
+        const headers = details.responseHeaders ?? {};
+        // CORS for the native render/service hosts to fetch compiled app resources
+        // cross-origin. (The COOP/COEP cross-origin-isolation headers were only for
+        // the removed default-path SharedArrayBuffer sync Worker — dropped.)
+        headers['access-control-allow-origin'] = ['*'];
+        headers['access-control-allow-headers'] = ['*'];
+        headers['access-control-allow-methods'] = ['*'];
+        callback({ responseHeaders: headers });
+    });
+}
+/** Remove the policy listeners from a session (passing `null` clears the slot). */
+function clearSimulatorWebRequestPolicy(simulatorSession) {
+    try {
+        simulatorSession.webRequest.onBeforeSendHeaders(null);
+        simulatorSession.webRequest.onHeadersReceived(null);
+    }
+    catch {
+        // Session already gone (app shutdown) — nothing to clear.
+    }
+}
+/**
+ * Install the simulator referer/CORS policy on the shared fallback session and
+ * register a configurator so every per-project partition session gets it too.
+ * Returns a disposable that unregisters the configurator and clears the policy
+ * off every session it installed on — call its teardown when the owning
+ * context is disposed so re-creating the app never leaks a duplicate
+ * configurator/listener.
+ */
+export function setupSimulatorSessionPolicy() {
+    const configured = new Set();
+    function install(sess) {
+        if (configured.has(sess))
+            return;
+        configured.add(sess);
+        applySimulatorWebRequestPolicy(sess);
+    }
+    // Shared fallback session (pre-warm pool + unknown-appId path).
+    install(session.fromPartition(SHARED_MINIAPP_PARTITION));
+    // Every per-project miniapp partition session (current + future) gets the
+    // same referer/CORS policy so isolated projects load resources identically.
+    const unregister = registerMiniappSessionConfigurator((sess) => install(sess));
+    return toDisposable(() => {
+        unregister();
+        for (const sess of configured)
+            clearSimulatorWebRequestPolicy(sess);
+        configured.clear();
+    });
+}
+//# sourceMappingURL=simulator-session-policy.js.map

package/dist/main/services/views/view-manager.js

@@ -10,6 +10,8 @@ import { installElementsForward } from '../elements-forward/index.js';
 import * as layout from '../layout/index.js';
 import { handleCustomApiBridgeRequest, } from '../simulator/custom-apis.js';
 import { getDefaultTab } from '../workbench-context.js';
+import { configureMiniappSession, miniappPartition } from './miniapp-partition.js';
+import { parseRoute } from '../../../shared/simulator-route.js';
 /**
  * Build a ViewManager bound to the given context. The returned object is the
  * only component allowed to instantiate or add/remove overlay WebContentsViews.
@@ -760,12 +762,22 @@ export function createViewManager(ctx) {
             catch { /* ignore */ }
             nativeSimulatorView = null;
         }
+        // Derive THIS project's session partition from the simulator URL's appId so
+        // its cookies/localStorage/cache are isolated from every other project (P0
+        // debt). Same project → same partition (storage survives a relaunch);
+        // unknown appId → the shared fallback. Configure the partition's session
+        // (protocol handlers + CORS/referer policy) before any project content loads
+        // on it — idempotent per partition.
+        const route = parseRoute(simulatorUrl);
+        const partition = miniappPartition(route?.appId);
+        configureMiniappSession(partition);
         // The simulator preload is a CJS bundle; webPreferences.preload obeys the
         // `.js` + "type":"module" ESM rule (require would be undefined), so hand the
         // top-level WebContentsView the `.cjs` sibling. contextIsolation:false +
         // sandbox:false + webviewTag:true mirror what the default `<webview>` guest
-        // runs with, and `partition:'persist:simulator'` shares storage + the
-        // session-registered preload/CORS rules with the rest of the simulator.
+        // runs with, and the per-project `persist:miniapp-<key>` partition shares
+        // storage + the session-registered preload/CORS rules with the rest of THIS
+        // project's simulator (render guests + service host), never other projects'.
         const view = new WebContentsView({
             webPreferences: {
                 nodeIntegration: false,
@@ -773,7 +785,7 @@ export function createViewManager(ctx) {
                 sandbox: false,
                 webviewTag: true,
                 preload: cjsSiblingPreloadPath(ctx.preloadPath),
-                partition: 'persist:simulator',
+                partition,
             },
         });
         nativeSimulatorView = view;
@@ -788,14 +800,15 @@ export function createViewManager(ctx) {
         // `sendToHost` requests straight to `ctx.simulatorApis` from main.
         attachNativeCustomApiBridge(simWc);
         // DeviceShell mounts per-page render-host `<webview>`s INSIDE this view.
-        // Mirror windows/main-window/create.ts: pin them onto persist:simulator and
-        // run them with contextIsolation/sandbox off so the render runtime + its
-        // preload share the page realm. (A top-level WebContentsView can host these
-        // guests; a `<webview>` guest cannot — that's the whole point of Option A.)
+        // Pin them onto the SAME per-project partition as their host WCV (so render
+        // and the rest of this project share one localStorage/cookie jar) and run
+        // them with contextIsolation/sandbox off so the render runtime + its preload
+        // share the page realm. (A top-level WebContentsView can host these guests; a
+        // `<webview>` guest cannot — that's the whole point of Option A.)
         simWc.on('will-attach-webview', (_event, webPreferences, params) => {
             ;
-            webPreferences.partition = 'persist:simulator';
-            params.partition = 'persist:simulator';
+            webPreferences.partition = partition;
+            params.partition = partition;
             webPreferences.contextIsolation = false;
             webPreferences.sandbox = false;
         });

package/dist/main/windows/main-window/create.js

@@ -1,35 +1,9 @@
-import { app, BrowserWindow, View, session } from 'electron';
+import { app, BrowserWindow, View } from 'electron';
 import path from 'path';
-import { getSimulatorServicewechatReferer } from '../../services/simulator/referer.js';
 import { mainPreloadPath } from '../../utils/paths.js';
 import { themeBg } from '../../utils/theme.js';
 import { applyNavigationHardening } from '../navigation-hardening.js';
-let simulatorSessionConfigured = false;
-function configureSimulatorSession() {
-    if (simulatorSessionConfigured)
-        return;
-    simulatorSessionConfigured = true;
-    const simulatorSession = session.fromPartition('persist:simulator');
-    simulatorSession.webRequest.onBeforeSendHeaders((details, callback) => {
-        const forcedReferer = getSimulatorServicewechatReferer();
-        if (forcedReferer) {
-            details.requestHeaders['Referer'] = forcedReferer;
-        }
-        callback({ requestHeaders: details.requestHeaders });
-    });
-    simulatorSession.webRequest.onHeadersReceived((details, callback) => {
-        const headers = details.responseHeaders ?? {};
-        // CORS for the native render/service hosts to fetch compiled app resources
-        // cross-origin. (The COOP/COEP cross-origin-isolation headers were only for
-        // the removed default-path SharedArrayBuffer sync Worker — dropped.)
-        headers['access-control-allow-origin'] = ['*'];
-        headers['access-control-allow-headers'] = ['*'];
-        headers['access-control-allow-methods'] = ['*'];
-        callback({ responseHeaders: headers });
-    });
-}
 export function createMainWindow(opts) {
-    configureSimulatorSession();
     const mainWindow = new BrowserWindow({
         width: opts.width ?? 1280,
         height: opts.height ?? 980,