@dimina-kit/devtools 0.4.0-dev.20260728110120 → 0.4.0-dev.20260731100034

package/dist/main/services/simulator-storage/service-storage-ops.d.ts

@@ -1,40 +1,2 @@
-/**
- * service-storage-ops — localStorage primitives executed INSIDE the service-host
- * window (`wc`) via `executeJavaScript`, plus the wx-storage value encode/decode
- * pair.
- *
- * Under native-host the mini-app's storage lives on the service-host window's
- * `file://` origin (sync APIs write there via sync-impls/storage.ts, and the
- * unified async path routes there too). The Storage panel + the async-storage
- * runtime both read/write through here so there is exactly ONE store.
- *
- * The key/value scheme stays byte-compatible with
- * `src/service-host/sync-impls/storage.ts` (the authoritative wx storage impl):
- *   - key   = `${appId}_${key}`
- *   - value = `typeof data === 'object' ? JSON.stringify(data) : String(data)`
- *   - scoped clear removes every key whose name startsWith `${appId}_`
- *
- * Args are embedded via JSON.stringify so special characters can't break out of
- * the injected code. Reads tolerate failure (→ []/null); writes propagate so the
- * caller can fail the wx callback / surface the panel error.
- */
-import type { WebContents } from 'electron';
-/** Encode a wx storage value to its localStorage string form. Matches sync-impls/storage.ts. */
-export declare function encodeStorageValue(data: unknown): string;
-/** Decode a localStorage string back to a value (JSON.parse, falling back to the raw string). */
-export declare function decodeStorageValue(raw: string): unknown;
-export interface ServiceStorage {
-    /** All [fullKey, value] entries whose key startsWith `prefix`. */
-    readAll(prefix: string): Promise<Array<[string, string]>>;
-    /** Raw value for a full (already-prefixed) key, or null if absent. */
-    readOne(fullKey: string): Promise<string | null>;
-    writeOne(fullKey: string, value: string): Promise<void>;
-    removeOne(fullKey: string): Promise<void>;
-    /** Remove every key whose name startsWith `prefix`. */
-    clearPrefix(prefix: string): Promise<void>;
-    /** Origin-wide localStorage.clear(). */
-    clearAll(): Promise<void>;
-}
-/** localStorage ops executed inside `wc` (the service-host window) via executeJavaScript. */
-export declare function serviceStorage(wc: WebContents): ServiceStorage;
+export * from '@dimina-kit/electron-runtime/main/service-storage-ops';
 //# sourceMappingURL=service-storage-ops.d.ts.map

package/dist/main/services/simulator-storage/service-storage-ops.js

@@ -1,67 +1,2 @@
-/** Encode a wx storage value to its localStorage string form. Matches sync-impls/storage.ts. */
-export function encodeStorageValue(data) {
-    return typeof data === 'object' ? JSON.stringify(data) : String(data);
-}
-/** Decode a localStorage string back to a value (JSON.parse, falling back to the raw string). */
-export function decodeStorageValue(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return raw;
-    }
-}
-/** localStorage ops executed inside `wc` (the service-host window) via executeJavaScript. */
-export function serviceStorage(wc) {
-    return {
-        async readAll(prefix) {
-            const code = `(() => {
-        const out = []
-        const p = ${JSON.stringify(prefix)}
-        for (let i = 0; i < localStorage.length; i++) {
-          const k = localStorage.key(i)
-          if (k && k.startsWith(p)) out.push([k, localStorage.getItem(k)])
-        }
-        return out
-      })()`;
-            try {
-                const result = await wc.executeJavaScript(code);
-                return Array.isArray(result) ? result : [];
-            }
-            catch {
-                return [];
-            }
-        },
-        async readOne(fullKey) {
-            try {
-                const result = await wc.executeJavaScript(`localStorage.getItem(${JSON.stringify(fullKey)})`);
-                return result === null || result === undefined ? null : String(result);
-            }
-            catch {
-                return null;
-            }
-        },
-        async writeOne(fullKey, value) {
-            await wc.executeJavaScript(`localStorage.setItem(${JSON.stringify(fullKey)}, ${JSON.stringify(value)})`);
-        },
-        async removeOne(fullKey) {
-            await wc.executeJavaScript(`localStorage.removeItem(${JSON.stringify(fullKey)})`);
-        },
-        async clearPrefix(prefix) {
-            const code = `(() => {
-        const p = ${JSON.stringify(prefix)}
-        const doomed = []
-        for (let i = 0; i < localStorage.length; i++) {
-          const k = localStorage.key(i)
-          if (k && k.startsWith(p)) doomed.push(k)
-        }
-        doomed.forEach((k) => localStorage.removeItem(k))
-      })()`;
-            await wc.executeJavaScript(code);
-        },
-        async clearAll() {
-            await wc.executeJavaScript('localStorage.clear()');
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/service-storage-ops';
 //# sourceMappingURL=service-storage-ops.js.map

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

@@ -1,55 +1,2 @@
-/**
- * Main-process disk reader/writer backing `difile://_store/*` and
- * `difile://<usr-rel>` URLs.
- *
- * Spec: `packages/devtools/docs/file-system.md`.
- *
- *   - `readDiskFile(realPath, opts?)`: read a (possibly ranged) slice of a
- *     file inside the USER_DATA_PATH sandbox. Returns `bytes` plus the
- *     content metadata callers need to assemble an HTTP response without a
- *     second `fs.stat` round-trip (`mime`, `etag`, `totalSize`).
- *   - `writeDiskFile(realPath, bytes)`: write bytes into the sandbox,
- *     creating parent directories on demand. Accepts both `Buffer` and
- *     `ArrayBuffer`.
- *   - `readDiskDir(realPath)`: list immediate children, no '.' / '..'.
- *   - `statDiskFile(realPath)`: minimal stat surface (size/mtime/mode/flags).
- *
- * The caller is responsible for canonicalizing `realPath` through
- * `resolveVPath` *before* invoking these helpers — disk.ts assumes the
- * argument is already known to be inside the sandbox base.
- *
- * MIME resolution prefers magic-byte sniffing (first ~12 bytes) over file
- * extension, falling back to `application/octet-stream` for both unknown
- * extensions and unknown magic.
- *
- * ETag shape is `W/"<mtime-ms>-<size>"` — weak validator, both axes folded
- * into one token so byte-equal rewrites at the same timestamp still match.
- */
-export interface DiskReadResult {
-    bytes: Buffer;
-    mime: string;
-    /** Weak ETag of the form `W/"<mtime>-<size>"`. */
-    etag: string;
-    /** Full file size in bytes, regardless of whether a Range slice was returned. */
-    totalSize: number;
-}
-export interface DiskReadOptions {
-    /** Inclusive byte range `[start, end]`. Omit to read the whole file. */
-    range?: {
-        start: number;
-        end: number;
-    };
-}
-export interface DiskStat {
-    size: number;
-    /** Unix milliseconds. */
-    mtime: number;
-    mode: number;
-    isFile: boolean;
-    isDirectory: boolean;
-}
-export declare function readDiskFile(realPath: string, opts?: DiskReadOptions): Promise<DiskReadResult>;
-export declare function writeDiskFile(realPath: string, bytes: Buffer | ArrayBuffer): Promise<void>;
-export declare function readDiskDir(realPath: string): Promise<string[]>;
-export declare function statDiskFile(realPath: string): Promise<DiskStat>;
+export * from '@dimina-kit/electron-runtime/main/temp-files/disk';
 //# sourceMappingURL=disk.d.ts.map

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

@@ -1,238 +1,2 @@
-/**
- * Main-process disk reader/writer backing `difile://_store/*` and
- * `difile://<usr-rel>` URLs.
- *
- * Spec: `packages/devtools/docs/file-system.md`.
- *
- *   - `readDiskFile(realPath, opts?)`: read a (possibly ranged) slice of a
- *     file inside the USER_DATA_PATH sandbox. Returns `bytes` plus the
- *     content metadata callers need to assemble an HTTP response without a
- *     second `fs.stat` round-trip (`mime`, `etag`, `totalSize`).
- *   - `writeDiskFile(realPath, bytes)`: write bytes into the sandbox,
- *     creating parent directories on demand. Accepts both `Buffer` and
- *     `ArrayBuffer`.
- *   - `readDiskDir(realPath)`: list immediate children, no '.' / '..'.
- *   - `statDiskFile(realPath)`: minimal stat surface (size/mtime/mode/flags).
- *
- * The caller is responsible for canonicalizing `realPath` through
- * `resolveVPath` *before* invoking these helpers — disk.ts assumes the
- * argument is already known to be inside the sandbox base.
- *
- * MIME resolution prefers magic-byte sniffing (first ~12 bytes) over file
- * extension, falling back to `application/octet-stream` for both unknown
- * extensions and unknown magic.
- *
- * ETag shape is `W/"<mtime-ms>-<size>"` — weak validator, both axes folded
- * into one token so byte-equal rewrites at the same timestamp still match.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-// -- MIME detection ---------------------------------------------------------
-/**
- * Extension-based MIME fallback. Kept deliberately small — anything more
- * exotic should land in the magic-byte sniffer above. Lowercase keys only.
- */
-const EXT_MIME = {
-    '.txt': 'text/plain',
-    '.log': 'text/plain',
-    '.md': 'text/markdown',
-    '.html': 'text/html',
-    '.htm': 'text/html',
-    '.css': 'text/css',
-    '.csv': 'text/csv',
-    '.json': 'application/json',
-    '.xml': 'application/xml',
-    '.js': 'application/javascript',
-    '.mjs': 'application/javascript',
-    '.svg': 'image/svg+xml',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif',
-    '.webp': 'image/webp',
-    '.bmp': 'image/bmp',
-    '.ico': 'image/x-icon',
-    '.mp4': 'video/mp4',
-    '.m4v': 'video/mp4',
-    '.webm': 'video/webm',
-    '.mov': 'video/quicktime',
-    '.mp3': 'audio/mpeg',
-    '.wav': 'audio/wav',
-    '.ogg': 'audio/ogg',
-    '.pdf': 'application/pdf',
-    '.zip': 'application/zip',
-};
-function isPng(head) {
-    return head.length >= 8
-        && head[0] === 0x89 && head[1] === 0x50 && head[2] === 0x4e && head[3] === 0x47
-        && head[4] === 0x0d && head[5] === 0x0a && head[6] === 0x1a && head[7] === 0x0a;
-}
-function isJpeg(head) {
-    return head.length >= 3 && head[0] === 0xff && head[1] === 0xd8 && head[2] === 0xff;
-}
-function isGif(head) {
-    return head.length >= 6
-        && head[0] === 0x47 && head[1] === 0x49 && head[2] === 0x46
-        && head[3] === 0x38 && (head[4] === 0x37 || head[4] === 0x39) && head[5] === 0x61;
-}
-function isWebp(head) {
-    return head.length >= 12
-        && head[0] === 0x52 && head[1] === 0x49 && head[2] === 0x46 && head[3] === 0x46
-        && head[8] === 0x57 && head[9] === 0x45 && head[10] === 0x42 && head[11] === 0x50;
-}
-/** MP4 ftyp box: brand bytes vary, treat all as video/mp4 for now. */
-function isMp4(head) {
-    return head.length >= 12
-        && head[4] === 0x66 && head[5] === 0x74 && head[6] === 0x79 && head[7] === 0x70;
-}
-function isPdf(head) {
-    return head.length >= 4
-        && head[0] === 0x25 && head[1] === 0x50 && head[2] === 0x44 && head[3] === 0x46;
-}
-function isBmp(head) {
-    return head.length >= 2 && head[0] === 0x42 && head[1] === 0x4d;
-}
-function isZip(head) {
-    return head.length >= 4
-        && head[0] === 0x50 && head[1] === 0x4b && head[2] === 0x03 && head[3] === 0x04;
-}
-/** ID3-tagged MP3. */
-function isId3Mp3(head) {
-    return head.length >= 3 && head[0] === 0x49 && head[1] === 0x44 && head[2] === 0x33;
-}
-function isOgg(head) {
-    return head.length >= 4 && head[0] === 0x4f && head[1] === 0x67 && head[2] === 0x67 && head[3] === 0x53;
-}
-/** Magic-byte sniffers in priority order — first match wins. */
-const MAGIC_SNIFFERS = [
-    { mime: 'image/png', match: isPng },
-    { mime: 'image/jpeg', match: isJpeg },
-    { mime: 'image/gif', match: isGif },
-    { mime: 'image/webp', match: isWebp },
-    { mime: 'video/mp4', match: isMp4 },
-    { mime: 'application/pdf', match: isPdf },
-    { mime: 'image/bmp', match: isBmp },
-    { mime: 'application/zip', match: isZip },
-    { mime: 'audio/mpeg', match: isId3Mp3 },
-    { mime: 'audio/ogg', match: isOgg },
-];
-function sniffMime(head) {
-    const hit = MAGIC_SNIFFERS.find((sniffer) => sniffer.match(head));
-    return hit ? hit.mime : null;
-}
-function extMime(realPath) {
-    const ext = path.extname(realPath).toLowerCase();
-    if (!ext)
-        return null;
-    return EXT_MIME[ext] ?? null;
-}
-function detectMime(realPath, head) {
-    const sniffed = sniffMime(head);
-    if (sniffed)
-        return sniffed;
-    const byExt = extMime(realPath);
-    if (byExt)
-        return byExt;
-    return 'application/octet-stream';
-}
-// -- ETag -------------------------------------------------------------------
-function etagOf(mtimeMs, size) {
-    return `W/"${Math.floor(mtimeMs)}-${size}"`;
-}
-// -- read -------------------------------------------------------------------
-/** Validate `range` against `totalSize` and resolve it to a byte slice, or throws. */
-function resolveRange(range, totalSize) {
-    const { start, end } = range;
-    if (!Number.isFinite(start) || !Number.isFinite(end)) {
-        throw new RangeError(`invalid range: ${start}-${end}`);
-    }
-    if (start < 0)
-        throw new RangeError(`range start out of bounds: ${start}`);
-    if (start > end)
-        throw new RangeError(`range start > end: ${start} > ${end}`);
-    if (start >= totalSize) {
-        throw new RangeError(`range start beyond file size: ${start} >= ${totalSize}`);
-    }
-    const clampedEnd = Math.min(end, totalSize - 1);
-    return { sliceStart: start, sliceLen: clampedEnd - start + 1 };
-}
-/**
- * Read at most the first 12 bytes for magic sniffing, regardless of whether
- * the caller asked for a range. The head bytes from position 0 are needed to
- * label Content-Type correctly even on a tail Range request.
- */
-async function readHeadBytes(handle, totalSize) {
-    const head = Buffer.alloc(Math.min(12, totalSize));
-    if (head.length > 0) {
-        await handle.read(head, 0, head.length, 0);
-    }
-    return head;
-}
-/** Full-file body, re-using `head` (already read) instead of a second read for the leading bytes. */
-async function readFullBody(handle, head, totalSize) {
-    const bytes = Buffer.alloc(totalSize);
-    if (totalSize === 0)
-        return bytes;
-    if (totalSize <= head.length) {
-        head.copy(bytes, 0, 0, totalSize);
-        return bytes;
-    }
-    head.copy(bytes, 0, 0, head.length);
-    await handle.read(bytes, head.length, totalSize - head.length, head.length);
-    return bytes;
-}
-async function readRangeBody(handle, sliceStart, sliceLen) {
-    const bytes = Buffer.alloc(sliceLen);
-    if (sliceLen > 0) {
-        await handle.read(bytes, 0, sliceLen, sliceStart);
-    }
-    return bytes;
-}
-export async function readDiskFile(realPath, opts) {
-    const handle = await fs.open(realPath, 'r');
-    try {
-        const st = await handle.stat();
-        const totalSize = st.size;
-        const mtimeMs = st.mtimeMs;
-        const range = opts?.range;
-        const { sliceStart, sliceLen } = range
-            ? resolveRange(range, totalSize)
-            : { sliceStart: 0, sliceLen: totalSize };
-        const head = await readHeadBytes(handle, totalSize);
-        const bytes = range
-            ? await readRangeBody(handle, sliceStart, sliceLen)
-            : await readFullBody(handle, head, totalSize);
-        return {
-            bytes,
-            mime: detectMime(realPath, head),
-            etag: etagOf(mtimeMs, totalSize),
-            totalSize,
-        };
-    }
-    finally {
-        await handle.close();
-    }
-}
-// -- write ------------------------------------------------------------------
-export async function writeDiskFile(realPath, bytes) {
-    const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-    await fs.mkdir(path.dirname(realPath), { recursive: true });
-    await fs.writeFile(realPath, buf);
-}
-// -- dir --------------------------------------------------------------------
-export async function readDiskDir(realPath) {
-    const entries = await fs.readdir(realPath);
-    return entries;
-}
-// -- stat -------------------------------------------------------------------
-export async function statDiskFile(realPath) {
-    const st = await fs.stat(realPath);
-    return {
-        size: st.size,
-        mtime: Math.floor(st.mtimeMs),
-        mode: st.mode,
-        isFile: st.isFile(),
-        isDirectory: st.isDirectory(),
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/temp-files/disk';
 //# sourceMappingURL=disk.js.map

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

@@ -1,69 +1,2 @@
-/**
- * Main-process `simulator:fs:*` IPC channel handlers.
- *
- * Spec: `packages/devtools/docs/file-system.md`.
- *
- * Each handler is the pure function that backs one IPC channel:
- *
- *   simulator:fs:read    → handleFsRead
- *   simulator:fs:write   → handleFsWrite
- *   simulator:fs:stat    → handleFsStat
- *   simulator:fs:readdir → handleFsReaddir
- *   simulator:fs:unlink  → handleFsUnlink
- *   simulator:fs:mkdir   → handleFsMkdir
- *
- * Every handler MUST defensively re-assert that `realPath` lies inside the
- * USER_DATA_PATH sandbox base (`DIMINA_HOME`-aware). The IPC boundary cannot
- * trust the caller — a hostile preload or fuzzed payload could send a path
- * that points outside the base. The renderer-side `resolveVPath` is one
- * layer; this is the second.
- *
- * MIME / ETag / Range semantics mirror `disk.ts`; see `disk.test.ts` for
- * the full contract on those axes.
- */
-import { type DiskStat } from './disk.js';
-export interface FsReadRequest {
-    realPath: string;
-    range?: {
-        start: number;
-        end: number;
-    };
-}
-export interface FsReadResult {
-    bytes: Buffer | ArrayBuffer;
-    mime: string;
-    /** Weak ETag of the form `W/"<mtime>-<size>"`. */
-    etag: string;
-    /** Full file size in bytes, regardless of whether a Range slice was returned. */
-    totalSize: number;
-}
-export interface FsWriteRequest {
-    realPath: string;
-    bytes: Buffer | ArrayBuffer;
-}
-export interface FsStatRequest {
-    realPath: string;
-}
-export interface FsReaddirRequest {
-    realPath: string;
-}
-export interface FsUnlinkRequest {
-    realPath: string;
-}
-export interface FsMkdirRequest {
-    realPath: string;
-    recursive?: boolean;
-}
-export declare function handleFsRead(req: FsReadRequest): Promise<FsReadResult>;
-export declare function handleFsWrite(req: FsWriteRequest): Promise<{
-    ok: true;
-}>;
-export declare function handleFsStat(req: FsStatRequest): Promise<DiskStat>;
-export declare function handleFsReaddir(req: FsReaddirRequest): Promise<string[]>;
-export declare function handleFsUnlink(req: FsUnlinkRequest): Promise<{
-    ok: true;
-}>;
-export declare function handleFsMkdir(req: FsMkdirRequest): Promise<{
-    ok: true;
-}>;
+export * from '@dimina-kit/electron-runtime/main/temp-files/fs-channels';
 //# sourceMappingURL=fs-channels.d.ts.map

package/dist/main/services/simulator-temp-files/fs-channels.js

@@ -1,108 +1,2 @@
-/**
- * Main-process `simulator:fs:*` IPC channel handlers.
- *
- * Spec: `packages/devtools/docs/file-system.md`.
- *
- * Each handler is the pure function that backs one IPC channel:
- *
- *   simulator:fs:read    → handleFsRead
- *   simulator:fs:write   → handleFsWrite
- *   simulator:fs:stat    → handleFsStat
- *   simulator:fs:readdir → handleFsReaddir
- *   simulator:fs:unlink  → handleFsUnlink
- *   simulator:fs:mkdir   → handleFsMkdir
- *
- * Every handler MUST defensively re-assert that `realPath` lies inside the
- * USER_DATA_PATH sandbox base (`DIMINA_HOME`-aware). The IPC boundary cannot
- * trust the caller — a hostile preload or fuzzed payload could send a path
- * that points outside the base. The renderer-side `resolveVPath` is one
- * layer; this is the second.
- *
- * MIME / ETag / Range semantics mirror `disk.ts`; see `disk.test.ts` for
- * the full contract on those axes.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { sandboxBase } from '../../../shared/vpath.js';
-import { readDiskDir, readDiskFile, statDiskFile, writeDiskFile, } from './disk.js';
-/**
- * Defense-in-depth: a hostile preload could synthesize a `realPath` that
- * resolveVPath would never produce. Re-canonicalize and re-anchor under the
- * sandbox base every time, throwing if the result escapes.
- *
- * Two-layer check:
- *  1. Lexical: `path.normalize` then `startsWith(base + sep)`.
- *  2. Filesystem: `fs.realpath` to follow symlinks and re-assert containment.
- *
- * The symlink check is best-effort — if the path does not yet exist (e.g. a
- * write/mkdir target), `fs.realpath` throws ENOENT and we fall back to
- * checking the deepest existing ancestor instead. A symlinked ancestor that
- * points outside the sandbox still gets caught that way.
- */
-async function enforceSandbox(realPath) {
-    if (typeof realPath !== 'string' || realPath.length === 0) {
-        throw new Error('sandbox: realPath must be a non-empty string');
-    }
-    const base = sandboxBase();
-    const baseReal = await fs.realpath(base).catch(() => base);
-    const normalized = path.normalize(realPath);
-    if (normalized !== base && !normalized.startsWith(base + path.sep)) {
-        throw new Error('sandbox: realPath escapes the user-data base');
-    }
-    // Walk up until we find an existing path, realpath it, and assert the
-    // resolved ancestor stays under the sandbox base. This catches symlinks
-    // anywhere along the chain — both the leaf (read/stat) and the parent
-    // (write/mkdir creating a new file under a symlinked dir).
-    let probe = normalized;
-    while (probe !== path.parse(probe).root) {
-        try {
-            const resolved = await fs.realpath(probe);
-            if (resolved !== baseReal && !resolved.startsWith(baseReal + path.sep)) {
-                throw new Error('sandbox: realPath escapes the user-data base via symlink');
-            }
-            break;
-        }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                probe = path.dirname(probe);
-                continue;
-            }
-            throw err;
-        }
-    }
-    return normalized;
-}
-export async function handleFsRead(req) {
-    const safe = await enforceSandbox(req.realPath);
-    const result = await readDiskFile(safe, req.range ? { range: req.range } : undefined);
-    return {
-        bytes: result.bytes,
-        mime: result.mime,
-        etag: result.etag,
-        totalSize: result.totalSize,
-    };
-}
-export async function handleFsWrite(req) {
-    const safe = await enforceSandbox(req.realPath);
-    await writeDiskFile(safe, req.bytes);
-    return { ok: true };
-}
-export async function handleFsStat(req) {
-    const safe = await enforceSandbox(req.realPath);
-    return statDiskFile(safe);
-}
-export async function handleFsReaddir(req) {
-    const safe = await enforceSandbox(req.realPath);
-    return readDiskDir(safe);
-}
-export async function handleFsUnlink(req) {
-    const safe = await enforceSandbox(req.realPath);
-    await fs.unlink(safe);
-    return { ok: true };
-}
-export async function handleFsMkdir(req) {
-    const safe = await enforceSandbox(req.realPath);
-    await fs.mkdir(safe, { recursive: !!req.recursive });
-    return { ok: true };
-}
+export * from '@dimina-kit/electron-runtime/main/temp-files/fs-channels';
 //# sourceMappingURL=fs-channels.js.map

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

@@ -1,33 +1,2 @@
-/**
- * Wires the `difile://_tmp/*` protocol handler on the simulator session
- * and bridges renderer-side `setTempFileSink` callbacks to the main-process
- * byte store. Returned disposable clears the store, unregisters the protocol
- * handler, and tears down its private IPC channels.
- *
- * SENDER POLICY: The default workbench sender-policy intentionally rejects
- * the simulator `<webview>` (see `utils/sender-policy.ts`). The simulator
- * is the only legitimate writer for these channels, so this module installs
- * its own narrow policy that accepts a sender only when its WebContents
- * belongs to the simulator `Session` we were handed. This bypasses the
- * default policy without widening trust to any other source.
- *
- * WRITE-vs-RENDER RACE: `createTempFilePath` is synchronous on the renderer,
- * but the bytes travel here through `blob.arrayBuffer().then(ipcRenderer.send)`
- * — async. The simulator can race ahead: in `chooseMedia` the renderer
- * assigns `img.src = tempFilePath` (via `readImageMetadata`) immediately
- * after `createTempFilePath` returns, which fires a `difile://` GET before
- * our IPC write arrives. The protocol handler therefore parks a request on
- * a per-url waiter for up to PENDING_TIMEOUT_MS; the IPC `write` handler
- * drains the waiter on arrival.
- *
- * QUOTA: A single in-memory store backs all simulator sessions for the
- * lifetime of the WorkbenchApp instance. We cap it at MAX_STORE_ENTRIES
- * (FIFO eviction). Project switches do NOT clear the store on their own —
- * stale entries from a previous project simply age out as new ones land.
- * This is the same eviction shape WeChat uses for tmp files (LRU under a
- * size cap), simplified for a dev-tools session scope.
- */
-import type { Session } from 'electron';
-import { type Disposable } from '@dimina-kit/electron-deck/main';
-export declare function setupSimulatorTempFiles(simSession: Session): Disposable;
+export * from '@dimina-kit/electron-runtime/main/temp-files';
 //# sourceMappingURL=index.d.ts.map