@dimina-kit/devtools 0.4.0-dev.20260702182435 → 0.4.0-dev.20260703051110

package/dist/main/services/projects/create-project-service.js

@@ -15,55 +15,67 @@
 import fs from 'node:fs';
 import path from 'node:path';
 const DEFAULT_TEMPLATE_ID = 'blank';
-export async function createProject(input, ctx) {
-    // 1. name validation
-    const name = (input.name ?? '').trim();
+/** Non-empty-after-trim `input.name`, or throws. */
+function resolveName(rawName) {
+    const name = (rawName ?? '').trim();
     if (name.length === 0) {
         throw new Error('Project name cannot be empty');
     }
-    // 2. path validation: does-not-exist OR exists+empty.
-    const target = input.path;
+    return name;
+}
+/** `input.path` does-not-exist OR exists+empty, or throws. */
+function validateTargetPath(target) {
     if (!target || typeof target !== 'string') {
         throw new Error('Project path is required');
     }
-    if (fs.existsSync(target)) {
-        const stat = fs.statSync(target);
-        if (!stat.isDirectory()) {
-            throw new Error(`Project path exists and is not a directory: ${target}`);
-        }
-        const entries = fs.readdirSync(target);
-        if (entries.length > 0) {
-            throw new Error(`Project path is not empty (refusing to overwrite): ${target}`);
-        }
+    if (!fs.existsSync(target))
+        return;
+    const stat = fs.statSync(target);
+    if (!stat.isDirectory()) {
+        throw new Error(`Project path exists and is not a directory: ${target}`);
+    }
+    const entries = fs.readdirSync(target);
+    if (entries.length > 0) {
+        throw new Error(`Project path is not empty (refusing to overwrite): ${target}`);
     }
-    // 3. template lookup (default 'blank')
-    const templateId = input.templateId ?? DEFAULT_TEMPLATE_ID;
-    const template = ctx.templates.find((t) => t.id === templateId);
+}
+/** Look up `templateId` (default 'blank') and confirm it can materialise a project. */
+function resolveTemplate(templates, templateId) {
+    const id = templateId ?? DEFAULT_TEMPLATE_ID;
+    const template = templates.find((t) => t.id === id);
     if (!template) {
-        throw new Error(`Template not found: ${templateId}`);
+        throw new Error(`Template not found: ${id}`);
     }
     if (!template.source && !template.generate) {
-        throw new Error(`Template '${templateId}' has neither a source directory nor a generate function`);
+        throw new Error(`Template '${id}' has neither a source directory nor a generate function`);
     }
-    // 4. materialise: ensure target exists, then copy or generate.
+    return template;
+}
+/** Ensure `target` exists, then copy the template's `source` tree or run its `generate`. */
+async function materializeTemplate(target, template, name) {
     fs.mkdirSync(target, { recursive: true });
     if (template.generate) {
         await template.generate(target, { name });
+        return;
     }
-    else if (template.source) {
-        if (!fs.existsSync(template.source.path)) {
-            throw new Error(`Template source missing on disk: ${template.source.path}`);
-        }
-        // `recursive: true` makes cpSync mirror the entire tree (files,
-        // subdirs, symlinks). `force: true` mirrors over an empty target.
-        fs.cpSync(template.source.path, target, {
-            recursive: true,
-            force: true,
-        });
+    if (!template.source)
+        return;
+    if (!fs.existsSync(template.source.path)) {
+        throw new Error(`Template source missing on disk: ${template.source.path}`);
     }
-    // 5. rewrite project.config.json projectname (best-effort: create the file
-    // if the template didn't ship one — gives the user a working starting
-    // point even for tiny generators).
+    // `recursive: true` makes cpSync mirror the entire tree (files,
+    // subdirs, symlinks). `force: true` mirrors over an empty target.
+    fs.cpSync(template.source.path, target, {
+        recursive: true,
+        force: true,
+    });
+}
+/**
+ * Rewrite `<target>/project.config.json`'s `projectname` (best-effort: create
+ * the file if the template didn't ship one — gives the user a working
+ * starting point even for tiny generators).
+ */
+function writeProjectConfig(target, name) {
     const cfgPath = path.join(target, 'project.config.json');
     let cfg = {};
     if (fs.existsSync(cfgPath)) {
@@ -76,7 +88,15 @@ export async function createProject(input, ctx) {
     }
     cfg.projectname = name;
     fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
-    // 6. register with provider — this is what makes the new project appear
+}
+export async function createProject(input, ctx) {
+    const name = resolveName(input.name);
+    const target = input.path;
+    validateTargetPath(target);
+    const template = resolveTemplate(ctx.templates, input.templateId);
+    await materializeTemplate(target, template, name);
+    writeProjectConfig(target, name);
+    // register with provider — this is what makes the new project appear
     // in the list immediately after the dialog closes.
     const created = await ctx.projectsProvider.addProject(target);
     return created;

package/dist/main/services/projects/types.d.ts

@@ -7,6 +7,7 @@
 import type { CompileConfig } from '../../../shared/types.js';
 import type { Project } from './project-repository.js';
 export type { Project };
+export type { ProjectTemplate, CreateProjectInput } from '../../../shared/types.js';
 /**
  * Default compile config returned by WorkspaceService when the injected
  * provider omits `getCompileConfig`, or when no record exists for a path.
@@ -81,38 +82,6 @@ export interface ProjectsProvider {
      */
     getThumbnail?(dirPath: string): string | null | Promise<string | null>;
 }
-/**
- * A template the user can pick from in the "新建项目" dialog. Exactly one of
- * `source` or `generate` should be supplied; if both are omitted, the
- * service refuses to materialise the template.
- */
-export interface ProjectTemplate {
-    /** Stable identifier. Used by host whitelists and the `templateId` field of CreateProjectInput. */
-    id: string;
-    /** Human-readable label shown in the dialog. */
-    name: string;
-    description?: string;
-    icon?: string;
-    /** Copy-tree source. `path` must be absolute. */
-    source?: {
-        type: 'directory';
-        path: string;
-    };
-    /** Programmatic generator. `target` is the absolute destination directory. */
-    generate?: (target: string, opts: {
-        name: string;
-    }) => Promise<void>;
-}
-/**
- * Payload returned from the create-project dialog. The service uses this to
- * scaffold disk content and to register the project with the provider.
- */
-export interface CreateProjectInput {
-    name: string;
-    path: string;
-    templateId?: string;
-    extra?: Record<string, unknown>;
-}
 /** Built-in template policy. */
 export type BuiltinTemplatesMode = 'all' | 'none' | readonly string[];
 //# sourceMappingURL=types.d.ts.map

package/dist/main/services/service-console/console-api.js

@@ -34,35 +34,25 @@ export function mapConsoleApiType(type) {
 }
 const BIGINT_LITERAL = /^-?\d+n$/;
 /**
- * A single RemoteObject → a JSON-serializable value WITHOUT a CDP round-trip
- * (shallow). Objects that need their full contents are flagged by
- * {@link needsDeepFetch} and deep-serialized by the caller; this is the
- * inline/best-effort fallback.
+ * A CDP `unserializableValue` string (specials that can't ride in `value`,
+ * e.g. `Infinity`/`NaN`/bigint literals) → the JS value it denotes. Unknown
+ * literals pass through as-is (e.g. a bigint literal stays a string).
  */
-export function remoteObjectToValue(ro) {
-    if (!ro)
-        return ro;
-    // 1. An inlined value (CDP includes `value` for JSON-serializable primitives
-    //    and small arrays). Use `in` so falsy values (0, '', false) and an
-    //    explicit `null` are honoured rather than falling through.
-    if ('value' in ro)
-        return ro.value;
-    // 2. Specials that can't ride in `value`.
-    if (typeof ro.unserializableValue === 'string') {
-        const u = ro.unserializableValue;
-        if (u === 'Infinity')
-            return Infinity;
-        if (u === '-Infinity')
-            return -Infinity;
-        if (u === 'NaN')
-            return NaN;
-        if (u === '-0')
-            return -0;
-        if (BIGINT_LITERAL.test(u))
-            return u;
+function unserializableToValue(u) {
+    if (u === 'Infinity')
+        return Infinity;
+    if (u === '-Infinity')
+        return -Infinity;
+    if (u === 'NaN')
+        return NaN;
+    if (u === '-0')
+        return -0;
+    if (BIGINT_LITERAL.test(u))
         return u;
-    }
-    // 3. Fall back by type.
+    return u;
+}
+/** Fallback serialization by `RemoteObject.type` when neither `value` nor `unserializableValue` is present. */
+function typeFallbackToValue(ro) {
     switch (ro.type) {
         case 'undefined':
             return undefined;
@@ -78,6 +68,25 @@ export function remoteObjectToValue(ro) {
             return ro.description ?? '[Unknown]';
     }
 }
+/**
+ * A single RemoteObject → a JSON-serializable value WITHOUT a CDP round-trip
+ * (shallow). Objects that need their full contents are flagged by
+ * {@link needsDeepFetch} and deep-serialized by the caller; this is the
+ * inline/best-effort fallback.
+ */
+export function remoteObjectToValue(ro) {
+    if (!ro)
+        return ro;
+    // An inlined value (CDP includes `value` for JSON-serializable primitives
+    // and small arrays). Use `in` so falsy values (0, '', false) and an
+    // explicit `null` are honoured rather than falling through.
+    if ('value' in ro)
+        return ro.value;
+    if (typeof ro.unserializableValue === 'string') {
+        return unserializableToValue(ro.unserializableValue);
+    }
+    return typeFallbackToValue(ro);
+}
 /**
  * Whether this RemoteObject must be deep-fetched via `Runtime.callFunctionOn`
  * (returnByValue) to be fully serialized — i.e. a real object/array referenced

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

@@ -62,49 +62,63 @@ const EXT_MIME = {
     '.pdf': 'application/pdf',
     '.zip': 'application/zip',
 };
-function sniffMime(head) {
-    if (head.length >= 8
+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) {
-        return 'image/png';
-    }
-    if (head.length >= 3 && head[0] === 0xff && head[1] === 0xd8 && head[2] === 0xff) {
-        return 'image/jpeg';
-    }
-    if (head.length >= 6
+        && 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) {
-        return 'image/gif';
-    }
-    if (head.length >= 12
+        && 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) {
-        return 'image/webp';
-    }
-    if (head.length >= 12
-        && head[4] === 0x66 && head[5] === 0x74 && head[6] === 0x79 && head[7] === 0x70) {
-        // MP4 ftyp box: brand bytes vary, treat all as video/mp4 for now.
-        return 'video/mp4';
-    }
-    if (head.length >= 4
-        && head[0] === 0x25 && head[1] === 0x50 && head[2] === 0x44 && head[3] === 0x46) {
-        return 'application/pdf';
-    }
-    if (head.length >= 2 && head[0] === 0x42 && head[1] === 0x4d) {
-        return 'image/bmp';
-    }
-    if (head.length >= 4
-        && head[0] === 0x50 && head[1] === 0x4b && head[2] === 0x03 && head[3] === 0x04) {
-        return 'application/zip';
-    }
-    if (head.length >= 3 && head[0] === 0x49 && head[1] === 0x44 && head[2] === 0x33) {
-        // ID3-tagged MP3.
-        return 'audio/mpeg';
-    }
-    if (head.length >= 4 && head[0] === 0x4f && head[1] === 0x67 && head[2] === 0x67 && head[3] === 0x53) {
-        return 'audio/ogg';
-    }
-    return null;
+        && 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();
@@ -126,6 +140,54 @@ 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 {
@@ -133,52 +195,13 @@ export async function readDiskFile(realPath, opts) {
         const totalSize = st.size;
         const mtimeMs = st.mtimeMs;
         const range = opts?.range;
-        let sliceStart = 0;
-        let sliceLen = totalSize;
-        if (range) {
-            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);
-            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. We need the head bytes from
-        // position 0 to label Content-Type correctly even on a tail Range
-        // request. For full reads the head is part of the body so we re-use
-        // it without a second read.
-        const head = Buffer.alloc(Math.min(12, totalSize));
-        if (head.length > 0) {
-            await handle.read(head, 0, head.length, 0);
-        }
-        let bytes;
-        if (!range) {
-            bytes = Buffer.alloc(totalSize);
-            if (totalSize > 0) {
-                if (totalSize <= head.length) {
-                    head.copy(bytes, 0, 0, totalSize);
-                }
-                else {
-                    head.copy(bytes, 0, 0, head.length);
-                    await handle.read(bytes, head.length, totalSize - head.length, head.length);
-                }
-            }
-        }
-        else {
-            bytes = Buffer.alloc(sliceLen);
-            if (sliceLen > 0) {
-                await handle.read(bytes, 0, sliceLen, sliceStart);
-            }
-        }
+        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),

package/dist/main/services/workbench-coi-server.js

@@ -188,6 +188,59 @@ function fsErrorStatus(e) {
         return 404;
     return 500;
 }
+async function fsStat(ctx) {
+    const st = await statWithin(ctx.projectRoot, ctx.rel);
+    jsonRes(ctx.res, 200, { type: st.isDirectory() ? 2 : 1, size: st.size, ctime: st.ctimeMs, mtime: st.mtimeMs });
+}
+async function fsReaddir(ctx) {
+    const entries = await readdirWithin(ctx.projectRoot, ctx.rel);
+    jsonRes(ctx.res, 200, entries.map((e) => [e.name, e.isDirectory() ? 2 : 1]));
+}
+async function fsRead(ctx) {
+    const buf = await readFileBufferWithin(ctx.projectRoot, ctx.rel);
+    ctx.res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Content-Length': buf.length });
+    ctx.res.end(buf);
+}
+async function fsWrite(ctx) {
+    let buf;
+    try {
+        buf = await readBody(ctx.req);
+    }
+    catch (e) {
+        if (e instanceof BodyTooLargeError)
+            return jsonRes(ctx.res, 413, { error: e.message });
+        throw e;
+    }
+    await writeFileWithin(ctx.projectRoot, ctx.rel, buf);
+    ctx.res.writeHead(204);
+    ctx.res.end();
+}
+async function fsMkdir(ctx) {
+    await mkdirWithin(ctx.projectRoot, ctx.rel);
+    ctx.res.writeHead(204);
+    ctx.res.end();
+}
+async function fsDelete(ctx) {
+    await deleteWithin(ctx.projectRoot, ctx.rel);
+    ctx.res.writeHead(204);
+    ctx.res.end();
+}
+async function fsRename(ctx) {
+    const toRel = (ctx.url.searchParams.get('to') ?? '').replace(/^\/+/, '');
+    await renameWithin(ctx.projectRoot, ctx.rel, toRel);
+    ctx.res.writeHead(204);
+    ctx.res.end();
+}
+/** One handler per supported `/__fs/<action>` — keyed lookup replaces an if-chain. */
+const FS_ACTIONS = {
+    stat: fsStat,
+    readdir: fsReaddir,
+    read: fsRead,
+    write: fsWrite,
+    mkdir: fsMkdir,
+    delete: fsDelete,
+    rename: fsRename,
+};
 /**
  * `/__fs/<action>?p=<rel>` bridge onto the live active project root.
  * `p`/`to` are POSIX paths relative to the project root, resolved through the
@@ -205,54 +258,14 @@ async function handleFsRequest(req, res, projectRoot, url) {
             return jsonRes(res, rejectStatus, { error: 'mutating fs action requires a non-GET same-origin request' });
         }
     }
-    try {
-        if (action === 'stat') {
-            const st = await statWithin(projectRoot, rel);
-            return jsonRes(res, 200, { type: st.isDirectory() ? 2 : 1, size: st.size, ctime: st.ctimeMs, mtime: st.mtimeMs });
-        }
-        if (action === 'readdir') {
-            const entries = await readdirWithin(projectRoot, rel);
-            return jsonRes(res, 200, entries.map((e) => [e.name, e.isDirectory() ? 2 : 1]));
-        }
-        if (action === 'read') {
-            const buf = await readFileBufferWithin(projectRoot, rel);
-            res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Content-Length': buf.length });
-            return void res.end(buf);
-        }
-        if (action === 'write') {
-            let buf;
-            try {
-                buf = await readBody(req);
-            }
-            catch (e) {
-                if (e instanceof BodyTooLargeError)
-                    return jsonRes(res, 413, { error: e.message });
-                throw e;
-            }
-            await writeFileWithin(projectRoot, rel, buf);
-            res.writeHead(204);
-            return void res.end();
-        }
-        if (action === 'mkdir') {
-            await mkdirWithin(projectRoot, rel);
-            res.writeHead(204);
-            return void res.end();
-        }
-        if (action === 'delete') {
-            await deleteWithin(projectRoot, rel);
-            res.writeHead(204);
-            return void res.end();
-        }
-        if (action === 'rename') {
-            const toRel = (url.searchParams.get('to') ?? '').replace(/^\/+/, '');
-            await renameWithin(projectRoot, rel, toRel);
-            res.writeHead(204);
-            return void res.end();
-        }
+    const handler = FS_ACTIONS[action];
+    if (!handler)
         return jsonRes(res, 404, { error: 'unknown fs action: ' + action });
+    try {
+        await handler({ req, res, projectRoot, rel, url });
     }
     catch (e) {
-        return jsonRes(res, fsErrorStatus(e), { error: String(e.message), code: e.code });
+        jsonRes(res, fsErrorStatus(e), { error: String(e.message), code: e.code });
     }
 }
 /**

package/dist/main/utils/logger.d.ts

@@ -1,15 +1,8 @@
-type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export interface Logger {
-    debug(message: string, ...args: unknown[]): void;
-    info(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    error(message: string, ...args: unknown[]): void;
-}
 /**
- * Create a tagged logger for a specific module.
- * All output goes to console with structured prefix.
+ * Tagged console logger. The implementation lives in
+ * `@dimina-kit/electron-deck/main` (single source — the two packages share one
+ * logger); this module re-exports it so devtools-internal imports keep their
+ * stable `utils/logger` path.
  */
-export declare function createLogger(tag: string): Logger;
-export declare function setLogLevel(level: LogLevel): void;
-export {};
+export { createLogger, setLogLevel, type Logger } from '@dimina-kit/electron-deck/main';
 //# sourceMappingURL=logger.d.ts.map

package/dist/main/utils/logger.js

@@ -1,48 +1,8 @@
-const LEVEL_PRIORITY = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-};
-const LEVEL_PREFIX = {
-    debug: '[DEBUG]',
-    info: '[INFO]',
-    warn: '[WARN]',
-    error: '[ERROR]',
-};
-let currentLevel = 'debug';
-function shouldLog(level) {
-    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[currentLevel];
-}
-function formatMessage(level, tag, message) {
-    const ts = new Date().toISOString();
-    return `${ts} ${LEVEL_PREFIX[level]} [${tag}] ${message}`;
-}
 /**
- * Create a tagged logger for a specific module.
- * All output goes to console with structured prefix.
+ * Tagged console logger. The implementation lives in
+ * `@dimina-kit/electron-deck/main` (single source — the two packages share one
+ * logger); this module re-exports it so devtools-internal imports keep their
+ * stable `utils/logger` path.
  */
-export function createLogger(tag) {
-    return {
-        debug(message, ...args) {
-            if (shouldLog('debug'))
-                console.debug(formatMessage('debug', tag, message), ...args);
-        },
-        info(message, ...args) {
-            if (shouldLog('info'))
-                console.info(formatMessage('info', tag, message), ...args);
-        },
-        warn(message, ...args) {
-            if (shouldLog('warn'))
-                console.warn(formatMessage('warn', tag, message), ...args);
-        },
-        error(message, ...args) {
-            if (shouldLog('error'))
-                console.error(formatMessage('error', tag, message), ...args);
-        },
-    };
-}
-export function setLogLevel(level) {
-    currentLevel = level;
-}
+export { createLogger, setLogLevel } from '@dimina-kit/electron-deck/main';
 //# sourceMappingURL=logger.js.map