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

package/dist/main/services/service-host-pool/pool.js

@@ -1,364 +1,2 @@
-import { BrowserWindow } from 'electron';
-/** Blank placeholder URL loaded while warming / after reset. */
-const BLANK_URL = 'about:blank';
-/** Hard ceiling on pool size regardless of requested size (see prewarm-webview.md). */
-const HARD_MAX_POOL_SIZE = 4;
-/** Storage buckets cleared on every release (see prewarm-webview.md's reset checklist). */
-const RESET_STORAGES = [
-    'cookies',
-    'localstorage',
-    'indexdb',
-    'serviceworkers',
-    'cachestorage',
-];
-export class ServiceHostPool {
-    entries = new Map();
-    currentSpec = null;
-    targetSize = 0;
-    maxPoolSize = 3;
-    nextId = 0;
-    disposed = false;
-    /**
-     * Warm `defaultPoolSize` entries with `defaultSpec`. Normally resolves once the
-     * pool has reached `defaultPoolSize` ready entries — even if a warming window
-     * crashes mid-init and is refilled. NOTE: `warmUpToTarget` caps its refill loop
-     * with a bounded guard, so under SUSTAINED warm crashes `init` resolves
-     * best-effort (possibly under-filled) rather than spinning forever — treat
-     * `getStats().ready` as advisory after init, not a hard invariant.
-     */
-    async init(opts) {
-        if (this.disposed)
-            return;
-        this.currentSpec = opts.defaultSpec;
-        this.maxPoolSize = Math.min(opts.maxPoolSize ?? 3, HARD_MAX_POOL_SIZE);
-        this.targetSize = Math.min(Math.max(opts.defaultPoolSize, 0), this.maxPoolSize);
-        await this.warmUpToTarget();
-    }
-    /**
-     * Hand a ready window matching `spec` to the caller. If none is ready, fall
-     * back to synchronously constructing a fresh window — never blocking on warm
-     * (see prewarm-webview.md's invariants section). Fallback windows carry `entryId === null` and
-     * are destroyed (not pooled) on release.
-     *
-     * A spec change (different `preloadPath`) tears down all *pooled* entries and
-     * re-targets the pool to the new spec; in-use entries are left to their owners
-     * and disposed when returned (see `release`).
-     */
-    async acquire(spec) {
-        if (this.currentSpec && this.currentSpec.preloadPath !== spec.preloadPath) {
-            this.onSpecChange(spec);
-        }
-        else if (!this.currentSpec) {
-            this.currentSpec = spec;
-        }
-        for (const entry of this.entries.values()) {
-            if (entry.state === 'ready' && this.matches(entry.spec, spec)) {
-                // A ready entry whose window died (closed/crashed) while idle must never
-                // be handed out — navigating a destroyed WebContents silently no-ops the
-                // spawn. Drop it (and refill) and keep scanning.
-                if (entry.win.isDestroyed()) {
-                    this.reclaim(entry, { destroyIfPooled: false, refill: false });
-                    continue;
-                }
-                entry.state = 'in-use';
-                return { win: entry.win, entryId: entry.id };
-            }
-        }
-        // Pool miss → fallback create. Not pooled; entryId null.
-        const win = this.createWindow(spec);
-        // Kick the load but do not await — acquire must not block.
-        void this.loadBlank(win);
-        return { win, entryId: null };
-    }
-    /**
-     * Return a window. Fallback windows (`entryId === null`) and entries whose
-     * spec no longer matches the current pool spec are torn down. Otherwise the
-     * window is reset (navigated to blank, then storage cleared) and re-pooled as
-     * `ready`, unless that would exceed `maxPoolSize`.
-     */
-    async release(entryId, win) {
-        if (entryId === null) {
-            this.destroyWindow(win);
-            return;
-        }
-        const entry = this.entries.get(entryId);
-        if (!entry) {
-            this.destroyWindow(win);
-            return;
-        }
-        if (this.disposed || !this.currentSpec || !this.matches(entry.spec, this.currentSpec)) {
-            this.disposeEntry(entry);
-            return;
-        }
-        entry.state = 'resetting';
-        await this.reset(entry);
-        // The entry may have been disposed/crashed/spec-changed/destroyed underneath
-        // the reset await; only re-pool if it is still the live, resetting entry with
-        // a live window. A destroyed window must never be re-marked `ready` (a later
-        // acquire would hand it out and the spawn would silently never boot).
-        if (this.disposed
-            || this.entries.get(entryId) !== entry
-            || entry.state !== 'resetting'
-            || entry.win.isDestroyed()) {
-            this.destroyWindow(entry.win);
-            this.entries.delete(entryId);
-            return;
-        }
-        // Honor the hard cap: if re-pooling would exceed maxPoolSize, drop it.
-        const otherPooled = this.warmCount() - (this.isWarm(entry) ? 1 : 0);
-        if (otherPooled >= this.maxPoolSize) {
-            this.disposeEntry(entry);
-            return;
-        }
-        entry.state = 'ready';
-    }
-    /**
-     * The owner of an acquired window reports it died externally (graceful close /
-     * crash) — reclaim its in-use slot so it isn't leaked in `entries` forever
-     * (bridge-router calls this on the `serviceAlreadyClosed` teardown path, where
-     * `release` is intentionally skipped). No-op for an unknown id; idempotent;
-     * never touches the (already-gone) window.
-     */
-    releaseDestroyed(entryId) {
-        if (entryId === null)
-            return;
-        const entry = this.entries.get(entryId);
-        if (!entry)
-            return;
-        this.reclaim(entry, { destroyIfPooled: false, refill: false });
-    }
-    /**
-     * Re-target the pool. `target` is clamped to `[0, maxPoolSize]`. Pooled
-     * entries beyond the target are disposed OLDEST-FIRST (see prewarm-webview.md); in-use
-     * entries are untouched. Does not warm new entries up (use `init` / refill).
-     */
-    resize(target) {
-        this.targetSize = Math.min(Math.max(target, 0), this.maxPoolSize);
-        // Map iteration is insertion order, so `pooled` is oldest-first. Dispose the
-        // oldest prefix and keep the `targetSize` most-recently-created entries.
-        const pooled = [...this.entries.values()].filter((e) => this.isWarm(e));
-        const surplus = pooled.length - this.targetSize;
-        if (surplus <= 0)
-            return;
-        for (const entry of pooled.slice(0, surplus)) {
-            this.disposeEntry(entry);
-        }
-    }
-    /** Occupancy snapshot. */
-    getStats() {
-        let ready = 0;
-        let inUse = 0;
-        let warming = 0;
-        let resetting = 0;
-        for (const entry of this.entries.values()) {
-            switch (entry.state) {
-                case 'ready':
-                    ready++;
-                    break;
-                case 'in-use':
-                    inUse++;
-                    break;
-                case 'warming':
-                    warming++;
-                    break;
-                case 'resetting':
-                    resetting++;
-                    break;
-            }
-        }
-        return { total: this.entries.size, ready, inUse, warming, resetting, spec: this.currentSpec };
-    }
-    /** Tear down every entry and stop accepting work. */
-    async dispose() {
-        this.disposed = true;
-        this.targetSize = 0;
-        for (const entry of [...this.entries.values()]) {
-            this.disposeEntry(entry);
-        }
-    }
-    // ── internals ──────────────────────────────────────────────────────────
-    matches(a, b) {
-        return a.preloadPath === b.preloadPath;
-    }
-    /** ready + warming + resetting entries are "pooled" (owned by the pool). */
-    isWarm(entry) {
-        return entry.state === 'ready' || entry.state === 'warming' || entry.state === 'resetting';
-    }
-    warmCount() {
-        let n = 0;
-        for (const entry of this.entries.values()) {
-            if (this.isWarm(entry))
-                n++;
-        }
-        return n;
-    }
-    readyCount() {
-        let n = 0;
-        for (const entry of this.entries.values()) {
-            if (entry.state === 'ready')
-                n++;
-        }
-        return n;
-    }
-    /**
-     * Drive the pool to `targetSize` ready entries and resolve only then. Loops so
-     * a crash that drops a warming entry mid-init (which refills asynchronously
-     * via `onGone`) is awaited too, instead of resolving on a stale snapshot. A
-     * generous iteration guard prevents an unbounded spin if windows keep dying.
-     */
-    async warmUpToTarget() {
-        if (!this.currentSpec)
-            return;
-        let guard = 0;
-        const maxIterations = this.targetSize * 8 + 8;
-        while (!this.disposed && this.readyCount() < this.targetSize && guard++ < maxIterations) {
-            while (this.warmCount() < this.targetSize) {
-                void this.warmOne(this.currentSpec);
-            }
-            const warming = [...this.entries.values()]
-                .filter((e) => e.state === 'warming')
-                .map((e) => e.ready);
-            if (warming.length === 0)
-                break;
-            await Promise.all(warming);
-        }
-    }
-    createWindow(spec) {
-        return new BrowserWindow({
-            show: false,
-            width: spec.size?.width,
-            height: spec.size?.height,
-            webPreferences: {
-                preload: spec.preloadPath,
-                partition: spec.partition,
-                // Mirror createServiceHostWindow's process model (create.ts:24-30): the
-                // service-host preload does `require('electron')` and writes globals
-                // onto the page realm, so it requires nodeIntegration:false,
-                // contextIsolation:false, sandbox:false. Default to that contract; let a
-                // caller override via the spec for a different runtime.
-                nodeIntegration: spec.nodeIntegration ?? false,
-                contextIsolation: spec.contextIsolation ?? false,
-                sandbox: spec.sandbox ?? false,
-            },
-        });
-    }
-    loadBlank(win) {
-        // `loadURL` resolves on did-finish-load in Electron; treat any failure as a
-        // settled load so a single bad warm never wedges the pool. The synchronous
-        // call ITSELF throws on an already-destroyed webContents (it isn't a
-        // rejection) — swallow that too, so reset/release of a window that died
-        // mid-flight resolves instead of rejecting (the "never wedges" contract).
-        try {
-            return Promise.resolve(win.webContents.loadURL(BLANK_URL)).then(() => undefined, () => undefined);
-        }
-        catch {
-            return Promise.resolve();
-        }
-    }
-    /** Construct + load a fresh pooled entry, registering crash recovery. */
-    warmOne(spec) {
-        const win = this.createWindow(spec);
-        const id = `pool-${++this.nextId}`;
-        const entry = { id, spec, state: 'warming', win, ready: Promise.resolve() };
-        this.entries.set(id, entry);
-        win.webContents.on('render-process-gone', () => this.onGone(entry));
-        // A window can also die by graceful close (app quit / manual close), which
-        // never fires render-process-gone. Observe it too so a pooled entry isn't
-        // leaked. reclaim is a no-op if WE disposed it (disposeEntry deletes the
-        // entry before its own destroy fires 'closed').
-        win.once('closed', () => this.reclaim(entry, { destroyIfPooled: false, refill: false }));
-        entry.ready = this.loadBlank(win).then(() => {
-            if (entry.state === 'warming')
-                entry.state = 'ready';
-        });
-        return entry.ready;
-    }
-    /**
-     * Reset a released window back to a clean, blank state. Order matters
-     * (see prewarm-webview.md's state-machine and reset-ordering sections): navigate to blank FIRST so the old document
-     * stops running and in-flight requests are aborted, THEN clear storage — so a
-     * still-live old page cannot re-populate storage after the clear.
-     */
-    async reset(entry) {
-        await this.loadBlank(entry.win);
-        // Consumers sharing a session opt out of the storage clear (see
-        // ServiceHostSpec.clearStorageOnReset): clearing a shared partition would wipe
-        // other live projects. Navigation-to-blank above still resets the JS realm.
-        if (entry.spec.clearStorageOnReset === false)
-            return;
-        // The window may have been destroyed during the load await; touching a dead
-        // webContents.session throws SYNCHRONOUSLY, which would reject release().
-        if (entry.win.isDestroyed())
-            return;
-        try {
-            const ses = entry.win.webContents.session;
-            await ses.clearStorageData({ storages: [...RESET_STORAGES] });
-            await ses.clearCache();
-        }
-        catch {
-            // Window/session torn down mid-reset — release() re-checks isDestroyed and
-            // disposes the entry, so swallowing here keeps release from rejecting.
-        }
-    }
-    /** A spec change tears down pooled entries and re-targets the pool. */
-    onSpecChange(spec) {
-        for (const entry of [...this.entries.values()]) {
-            if (this.isWarm(entry))
-                this.disposeEntry(entry);
-        }
-        this.currentSpec = spec;
-    }
-    /**
-     * Reclaim an entry whose window died externally (render crash, graceful close,
-     * or an owner-reported destruction). A POOLED death frees a spare → refill
-     * toward target; an IN-USE death is the caller's window → drop the bookkeeping
-     * WITHOUT destroying it from under them, and do not refill (the spare count is
-     * unaffected). `destroyIfPooled` destroys the husk for a pooled render crash
-     * (the BrowserWindow object can outlive a dead render process); skip it for a
-     * `'closed'`/owner-reported window that is already gone. No-op if the entry was
-     * already disposed by us (disposeEntry deletes before its own destroy fires
-     * `'closed'`, so this finds nothing).
-     */
-    reclaim(entry, opts) {
-        if (!this.entries.has(entry.id))
-            return;
-        const wasPooled = this.isWarm(entry);
-        entry.state = 'disposing';
-        this.entries.delete(entry.id);
-        if (wasPooled && opts.destroyIfPooled)
-            this.destroyWindow(entry.win);
-        // Refill ONLY on crash recovery (onGone). A graceful `'closed'` on a pooled
-        // window happens exclusively at app/project teardown (the windows are hidden;
-        // nothing else closes them) — refilling there would `new BrowserWindow` while
-        // Electron is trying to quit, recreating windows faster than they close and
-        // hanging the shutdown. So `refill` is opt-in per caller.
-        if (!opts.refill || this.disposed || !this.currentSpec || !wasPooled)
-            return;
-        while (this.warmCount() < this.targetSize) {
-            void this.warmOne(this.currentSpec);
-        }
-    }
-    /** A pooled window's render process died — reclaim + refill (destroy the husk). */
-    onGone(entry) {
-        this.reclaim(entry, { destroyIfPooled: true, refill: true });
-    }
-    disposeEntry(entry) {
-        entry.state = 'disposing';
-        this.entries.delete(entry.id);
-        this.destroyWindow(entry.win);
-    }
-    destroyWindow(win) {
-        try {
-            if (!win || (typeof win.isDestroyed === 'function' && win.isDestroyed()))
-                return;
-            if (typeof win.destroy === 'function')
-                win.destroy();
-            else if (typeof win.close === 'function')
-                win.close();
-        }
-        catch {
-            // A window already gone (e.g. crashed process) is fine to ignore.
-        }
-    }
-}
+export * from '@dimina-kit/electron-runtime/main/service-host-pool';
 //# sourceMappingURL=pool.js.map

package/dist/main/services/simulator/custom-apis.d.ts

@@ -1,43 +1,2 @@
-export type SimulatorApiHandler = (params: unknown) => unknown | Promise<unknown>;
-export interface SimulatorApiRegistry {
-    register(name: string, handler: SimulatorApiHandler): () => void;
-    list(): string[];
-    has(name: string): boolean;
-    invoke(name: string, params: unknown): Promise<unknown>;
-    clear(): void;
-}
-/**
- * Bridge request/response shapes shared by the simulator-side preload
- * (`src/preload/runtime/custom-apis.ts`) and the two host-side dispatchers that
- * service it (the trusted main-window renderer proxy was the original path; the
- * native-host top-level WebContentsView dispatcher in the ViewManager is the
- * current one). Kept here next to the registry so both stay in lockstep with
- * the preload contract.
- */
-export type CustomApiBridgeRequest = {
-    id: number;
-    op: 'list';
-} | {
-    id: number;
-    op: 'invoke';
-    name: string;
-    params: unknown;
-};
-export type CustomApiBridgeResponse = {
-    id: number;
-    result: unknown;
-} | {
-    id: number;
-    error: string;
-};
-/**
- * Run a single custom-apis bridge request against the given registry and return
- * the id-correlated response the preload's pending-map expects. Never throws:
- * a handler rejection / malformed request becomes an `{ id, error }` response so
- * the caller only has to ship it back over the bridge channel. The one shared
- * implementation behind both the `SimulatorCustomApiChannel` IPC handlers and
- * the native-host `ipc-message-host` dispatcher.
- */
-export declare function handleCustomApiBridgeRequest(apis: Pick<SimulatorApiRegistry, 'list' | 'invoke'>, req: CustomApiBridgeRequest): Promise<CustomApiBridgeResponse>;
-export declare function createSimulatorApiRegistry(): SimulatorApiRegistry;
+export * from '@dimina-kit/electron-runtime/main/custom-apis';
 //# sourceMappingURL=custom-apis.d.ts.map

package/dist/main/services/simulator/custom-apis.js

@@ -1,47 +1,2 @@
-/**
- * Run a single custom-apis bridge request against the given registry and return
- * the id-correlated response the preload's pending-map expects. Never throws:
- * a handler rejection / malformed request becomes an `{ id, error }` response so
- * the caller only has to ship it back over the bridge channel. The one shared
- * implementation behind both the `SimulatorCustomApiChannel` IPC handlers and
- * the native-host `ipc-message-host` dispatcher.
- */
-export async function handleCustomApiBridgeRequest(apis, req) {
-    try {
-        const result = req.op === 'list'
-            ? apis.list()
-            : await apis.invoke(req.name, req.params);
-        return { id: req.id, result };
-    }
-    catch (err) {
-        return { id: req.id, error: err instanceof Error ? err.message : String(err) };
-    }
-}
-export function createSimulatorApiRegistry() {
-    const handlers = new Map();
-    return {
-        register(name, handler) {
-            handlers.set(name, handler);
-            return () => {
-                if (handlers.get(name) === handler)
-                    handlers.delete(name);
-            };
-        },
-        list() {
-            return Array.from(handlers.keys());
-        },
-        has(name) {
-            return handlers.has(name);
-        },
-        async invoke(name, params) {
-            const handler = handlers.get(name);
-            if (!handler)
-                throw new Error(`Simulator API "${name}" is not registered`);
-            return await handler(params);
-        },
-        clear() {
-            handlers.clear();
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/custom-apis';
 //# sourceMappingURL=custom-apis.js.map

package/dist/main/services/simulator/referer.d.ts

@@ -1,10 +1,2 @@
-/**
- * WeChat-style page-frame referer for HTTPS requests proxied from the simulator session.
- * Format: https://servicewechat.com/{appId}/{version}/page-frame.html
- */
-export declare function buildServicewechatPageFrameReferer(appId: string, version?: string): string;
-/** Called when a project session is active so protocol.handle can force Referer. */
-export declare function setSimulatorServicewechatReferer(appId: string, version?: string): void;
-export declare function clearSimulatorServicewechatReferer(): void;
-export declare function getSimulatorServicewechatReferer(): string | null;
+export * from '@dimina-kit/electron-runtime/main/referer';
 //# sourceMappingURL=referer.d.ts.map

package/dist/main/services/simulator/referer.js

@@ -1,20 +1,2 @@
-/**
- * WeChat-style page-frame referer for HTTPS requests proxied from the simulator session.
- * Format: https://servicewechat.com/{appId}/{version}/page-frame.html
- */
-const DEFAULT_VERSION = 'develop';
-let cachedRefererUrl = null;
-export function buildServicewechatPageFrameReferer(appId, version = DEFAULT_VERSION) {
-    return `https://servicewechat.com/${appId}/${version}/page-frame.html`;
-}
-/** Called when a project session is active so protocol.handle can force Referer. */
-export function setSimulatorServicewechatReferer(appId, version) {
-    cachedRefererUrl = buildServicewechatPageFrameReferer(appId, version && version.length > 0 ? version : DEFAULT_VERSION);
-}
-export function clearSimulatorServicewechatReferer() {
-    cachedRefererUrl = null;
-}
-export function getSimulatorServicewechatReferer() {
-    return cachedRefererUrl;
-}
+export * from '@dimina-kit/electron-runtime/main/referer';
 //# sourceMappingURL=referer.js.map

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