@dimina-kit/devtools 0.4.0-dev.20260729062524 → 0.4.0-dev.20260801163345

package/dist/main/services/simulator-temp-files/request-handler.js

@@ -1,178 +1,2 @@
-/**
- * Pure dispatcher for `difile://` URL requests.
- *
- * Spec: `packages/devtools/docs/file-system.md`.
- *
- * The shipping implementation in `index.ts` registers a thin
- * `simSession.protocol.handle('difile')` wrapper that delegates here; the race
- * waiter on `_tmp/*` lives in `index.ts` because it owns the IPC lifecycle.
- * For unit tests we assume the bytes are already in the store.
- *
- * Response shape:
- *   - 200: full body, with Content-Type, Cache-Control (immutable), ETag
- *   - 206: range slice, plus Content-Range
- *   - 304: empty body when `If-None-Match` matches the on-disk ETag. Per RFC
- *     9110 §13.1.2 If-None-Match wins over Range.
- *   - 404: anything `resolveVPath` rejects, plus disk-side ENOENT and any
- *     other I/O error. The protocol handler in `index.ts` translates this
- *     into the renderer's network failure surface; we deliberately do not
- *     leak errno strings.
- */
-import { resolveVPath } from '../../../shared/vpath.js';
-import { readDiskFile } from './disk.js';
-const CACHE_CONTROL = 'public, max-age=31536000, immutable';
-function getHeader(headers, name) {
-    if (!headers)
-        return undefined;
-    const lc = name.toLowerCase();
-    for (const k of Object.keys(headers)) {
-        if (k.toLowerCase() === lc)
-            return headers[k];
-    }
-    return undefined;
-}
-/**
- * Weak ETag comparison per RFC 9110 §8.8.3.2: strip the optional `W/` prefix
- * from each side before comparing. Both our generated ETags and conditional
- * headers may or may not include the weak prefix; the comparison must accept
- * `W/"abc"` and `"abc"` as equivalent.
- */
-function etagsMatch(a, b) {
-    if (!a)
-        return false;
-    const stripped = (s) => (s.startsWith('W/') ? s.slice(2) : s);
-    return stripped(a.trim()) === stripped(b);
-}
-/**
- * Parse a `Range: bytes=<start>-<end>` header into an inclusive `{start,end}`.
- * Returns `null` if absent or malformed (callers should treat that as "no
- * range" — a full 200 response, not a 416). `totalSize` clamps the end.
- */
-function parseRange(header, totalSize) {
-    if (!header)
-        return null;
-    const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
-    if (!m)
-        return null;
-    const startStr = m[1];
-    const endStr = m[2];
-    if (startStr === '' && endStr === '')
-        return null;
-    if (startStr === '') {
-        // Suffix range: last N bytes.
-        const n = Number(endStr);
-        if (!Number.isFinite(n) || n <= 0)
-            return null;
-        const start = Math.max(0, totalSize - n);
-        return { start, end: totalSize - 1 };
-    }
-    const start = Number(startStr);
-    if (!Number.isFinite(start) || start < 0)
-        return null;
-    const end = endStr === '' ? totalSize - 1 : Number(endStr);
-    if (!Number.isFinite(end))
-        return null;
-    return { start, end };
-}
-function notFound() {
-    return new Response(null, { status: 404 });
-}
-function notModified(etag) {
-    return new Response(null, {
-        status: 304,
-        headers: {
-            ETag: etag,
-            'Cache-Control': CACHE_CONTROL,
-            'Access-Control-Allow-Origin': '*',
-        },
-    });
-}
-function bufferToBody(bytes) {
-    // Copy into a fresh ArrayBuffer so the result is definitely typed as
-    // `ArrayBuffer` (not `ArrayBufferLike` / `SharedArrayBuffer`) and is
-    // safe to hand to Response without aliasing the Node Buffer pool.
-    const out = new ArrayBuffer(bytes.byteLength);
-    new Uint8Array(out).set(bytes);
-    return out;
-}
-function tempBody(bytes, mime) {
-    return new Response(bufferToBody(bytes), {
-        status: 200,
-        headers: {
-            'Content-Type': mime,
-            'Cache-Control': CACHE_CONTROL,
-            'Access-Control-Allow-Origin': '*',
-        },
-    });
-}
-export async function handleDifileRequest(ctx, req) {
-    const v = resolveVPath(req.url);
-    if (!v)
-        return notFound();
-    if (v.kind === 'tmp') {
-        const record = ctx.tempStore.get(req.url);
-        if (!record)
-            return notFound();
-        return tempBody(record.bytes, record.mime || 'application/octet-stream');
-    }
-    if (!v.realPath)
-        return notFound();
-    // Disk-backed: _store or usr.
-    try {
-        // Probe first to learn the ETag/size so If-None-Match can short-circuit
-        // without reading the body. The probe also doubles as our existence /
-        // permission check, so anything that throws here (ENOENT, EACCES, ...)
-        // surfaces as a 404.
-        const probe = await readDiskFile(v.realPath);
-        const etag = probe.etag;
-        const totalSize = probe.totalSize;
-        const mime = probe.mime;
-        const ifNoneMatch = getHeader(req.headers, 'If-None-Match');
-        if (etagsMatch(ifNoneMatch, etag)) {
-            return notModified(etag);
-        }
-        const rangeHeader = getHeader(req.headers, 'Range');
-        const range = parseRange(rangeHeader, totalSize);
-        if (range) {
-            // Range out of bounds → 416 (Range Not Satisfiable) per RFC 9110 §15.4.
-            // Distinct from 404 so callers can tell "wrong file" from "wrong slice".
-            if (range.start < 0 || range.start >= totalSize || range.end < range.start) {
-                return new Response(null, {
-                    status: 416,
-                    headers: {
-                        'Content-Range': `bytes */${totalSize}`,
-                        'Access-Control-Allow-Origin': '*',
-                    },
-                });
-            }
-            const clampedEnd = Math.min(range.end, totalSize - 1);
-            const sliced = await readDiskFile(v.realPath, { range: { start: range.start, end: clampedEnd } });
-            const { bytes } = sliced;
-            const lastByte = range.start + bytes.length - 1;
-            return new Response(bufferToBody(bytes), {
-                status: 206,
-                headers: {
-                    'Content-Type': mime,
-                    'Content-Length': String(bytes.length),
-                    'Content-Range': `bytes ${range.start}-${lastByte}/${totalSize}`,
-                    'Cache-Control': CACHE_CONTROL,
-                    ETag: etag,
-                    'Access-Control-Allow-Origin': '*',
-                },
-            });
-        }
-        return new Response(bufferToBody(probe.bytes), {
-            status: 200,
-            headers: {
-                'Content-Type': mime,
-                'Cache-Control': CACHE_CONTROL,
-                ETag: etag,
-                'Access-Control-Allow-Origin': '*',
-            },
-        });
-    }
-    catch {
-        return notFound();
-    }
-}
+export * from '@dimina-kit/electron-runtime/main/temp-files/request-handler';
 //# sourceMappingURL=request-handler.js.map

package/dist/main/services/simulator-temp-files/resolver.d.ts

@@ -1,22 +1,2 @@
-/**
- * Pure lookup helper backing the main-process `difile://_tmp/*` protocol
- * handler. Receives the shared {@link TempFileStore} that the
- * `simulator:temp-file:*` IPC channels populate from the renderer.
- *
- * The full URL (including scheme + host) is used as the Map key — the resolver
- * never re-parses or normalises it, so any URL with a wrong scheme or host
- * misses regardless of suffix similarity.
- */
-export interface TempFileRecord {
-    bytes: Buffer;
-    mime: string;
-}
-export type TempFileStore = Map<string, TempFileRecord>;
-export declare function resolveTempFile(store: TempFileStore, url: string): {
-    status: 200;
-    bytes: Buffer;
-    mime: string;
-} | {
-    status: 404;
-};
+export * from '@dimina-kit/electron-runtime/main/temp-files/resolver';
 //# sourceMappingURL=resolver.d.ts.map

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

@@ -1,22 +1,2 @@
-/**
- * Pure lookup helper backing the main-process `difile://_tmp/*` protocol
- * handler. Receives the shared {@link TempFileStore} that the
- * `simulator:temp-file:*` IPC channels populate from the renderer.
- *
- * The full URL (including scheme + host) is used as the Map key — the resolver
- * never re-parses or normalises it, so any URL with a wrong scheme or host
- * misses regardless of suffix similarity.
- */
-export function resolveTempFile(store, url) {
-    if (!url.startsWith('difile://_tmp/'))
-        return { status: 404 };
-    const record = store.get(url);
-    if (!record)
-        return { status: 404 };
-    return {
-        status: 200,
-        bytes: record.bytes,
-        mime: record.mime || 'application/octet-stream',
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/temp-files/resolver';
 //# sourceMappingURL=resolver.js.map

package/dist/main/services/simulator-temp-files/store.d.ts

@@ -1,14 +1,2 @@
-/**
- * Mutators for the shared {@link TempFileStore}. The renderer-side bridge
- * forwards every `createTempFilePath` / `registerTempFilePath` /
- * `revokeTempFilePath` / `revokeAllTempFilePaths` call over IPC, and these
- * helpers translate the payloads into Map writes.
- *
- * ArrayBuffer inputs are normalised to Buffer at the boundary so the
- * resolver hot path can return the bytes directly without re-wrapping.
- */
-import type { TempFileStore } from './resolver.js';
-export declare function registerTempFile(store: TempFileStore, path: string, mime: string, bytes: ArrayBuffer | Buffer): void;
-export declare function revokeTempFile(store: TempFileStore, path: string): void;
-export declare function revokeAllTempFiles(store: TempFileStore): void;
+export * from '@dimina-kit/electron-runtime/main/temp-files/store';
 //# sourceMappingURL=store.d.ts.map

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

@@ -1,24 +1,2 @@
-/**
- * Mutators for the shared {@link TempFileStore}. The renderer-side bridge
- * forwards every `createTempFilePath` / `registerTempFilePath` /
- * `revokeTempFilePath` / `revokeAllTempFilePaths` call over IPC, and these
- * helpers translate the payloads into Map writes.
- *
- * ArrayBuffer inputs are normalised to Buffer at the boundary so the
- * resolver hot path can return the bytes directly without re-wrapping.
- */
-export function registerTempFile(store, path, mime, bytes) {
-    const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-    // delete-then-set so an existing entry's insertion order is refreshed.
-    // Without this, a FIFO cap eviction over `store.keys()` could drop a
-    // recently re-written path.
-    store.delete(path);
-    store.set(path, { bytes: buf, mime });
-}
-export function revokeTempFile(store, path) {
-    store.delete(path);
-}
-export function revokeAllTempFiles(store) {
-    store.clear();
-}
+export * from '@dimina-kit/electron-runtime/main/temp-files/store';
 //# sourceMappingURL=store.js.map

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

@@ -1,90 +1,2 @@
-/**
- * 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`) PLUS the project path. appId alone is insufficient —
- * it comes from the project manifest, so two DIFFERENT project paths can declare
- * the SAME appId and would otherwise share a partition; folding the path in
- * isolates them. Same project (same appId + path) → 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.
- *
- * MIGRATION (intentional one-time reset): folding the project path into the key
- * means a project that previously ran on the appId-only `persist:miniapp-<appId>`
- * now runs on `persist:miniapp-<appId>-p<hash>` and starts with empty
- * cookies/localStorage/cache. Old data is NOT migrated — a best-effort copy
- * could carry already-cross-contaminated state into the newly isolated space,
- * which defeats the isolation. The reset is accepted as a one-time cost.
- */
-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, projectPath?: string | null): 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, projectPath?: string | null): 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 {};
+export * from '@dimina-kit/electron-runtime/main/miniapp-partition';
 //# sourceMappingURL=miniapp-partition.d.ts.map

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

@@ -1,159 +1,2 @@
-/**
- * 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`) PLUS the project path. appId alone is insufficient —
- * it comes from the project manifest, so two DIFFERENT project paths can declare
- * the SAME appId and would otherwise share a partition; folding the path in
- * isolates them. Same project (same appId + path) → 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.
- *
- * MIGRATION (intentional one-time reset): folding the project path into the key
- * means a project that previously ran on the appId-only `persist:miniapp-<appId>`
- * now runs on `persist:miniapp-<appId>-p<hash>` and starts with empty
- * cookies/localStorage/cache. Old data is NOT migrated — a best-effort copy
- * could carry already-cross-contaminated state into the newly isolated space,
- * which defeats the isolation. The reset is accepted as a one-time cost.
- */
-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, projectPath) {
-    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.
-    const base = safe === appId && safe.length > 0
-        ? safe
-        : safe.length > 0
-            ? `${safe}-${djb2(appId).toString(36)}`
-            : djb2(appId).toString(36);
-    // `appId` comes from the project manifest, not the path — two DIFFERENT
-    // project paths can declare the SAME appId. Fold the project path into the key
-    // so those projects get isolated partitions (no storage/cache cross-talk),
-    // while the same path always yields the same suffix (a relaunch reuses its
-    // storage). Path characters aren't partition-safe, so always hash. Omitting
-    // projectPath preserves the legacy appId-only key (pre-warm pool / callers
-    // that have no project identity).
-    if (!projectPath)
-        return base;
-    return `${base}-p${djb2(projectPath).toString(36)}`;
-}
-/**
- * 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, projectPath) {
-    if (!appId)
-        return SHARED_MINIAPP_PARTITION;
-    return `${PARTITION_PREFIX}${miniappPartitionKey(appId, projectPath)}`;
-}
-/** 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();
-}
+export * from '@dimina-kit/electron-runtime/main/miniapp-partition';
 //# sourceMappingURL=miniapp-partition.js.map

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

@@ -1,28 +1,2 @@
-/**
- * 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;
+export * from '@dimina-kit/electron-runtime/main/session-policy';
 //# sourceMappingURL=simulator-session-policy.d.ts.map

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

@@ -1,99 +1,2 @@
-/**
- * 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';
-/** The response headers this policy owns outright (compared lowercase). */
-const CORS_OVERRIDE_HEADERS = new Set([
-    'access-control-allow-origin',
-    'access-control-allow-headers',
-    'access-control-allow-methods',
-]);
-/** 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.)
-        //
-        // This policy is the single authority for these three headers: any value
-        // the server itself sent must be REPLACED, not shadowed. responseHeaders
-        // keys keep the server's original casing, so assigning the lowercase key
-        // beside an existing `Access-Control-Allow-Origin` puts BOTH on the wire —
-        // Chromium then rejects the response for carrying multiple ACAO values
-        // (`*, *`), breaking every fetch against a CORS-compliant backend.
-        for (const key of Object.keys(headers)) {
-            if (CORS_OVERRIDE_HEADERS.has(key.toLowerCase()))
-                delete headers[key];
-        }
-        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();
-    });
-}
+export * from '@dimina-kit/electron-runtime/main/session-policy';
 //# sourceMappingURL=simulator-session-policy.js.map