@vmz/vmz 0.2.3 → 0.2.5

package/dist/cli/cli.js

@@ -2,7 +2,6 @@
  * Node CLI command implementations .
  */
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { createCli } from '@vmz/commander';
 import { registerApplicationCommands } from './application-cmd.js';
@@ -20,6 +19,8 @@ import { emitLocaleRuntimeModules, localeHasErrors } from '../locale/locale-chec
 import { registerLocaleCommands } from '../locale/locale-cmd.js';
 import { emitLocaleRouteRealization } from '../locale/locale-route-emit.js';
 import { log } from '../workspace/log.js';
+import { resolveCliLogLevel, setCliLogLevel } from '../workspace/log-level.js';
+import { parseCliLogStyle, setCliLogStyle } from '../workspace/log-style.js';
 import { packFromDeploymentIr } from '../workspace/pack.js';
 import { registerPlanCommands } from './plan-cmd.js';
 import { loadVmzConfig } from '../workspace/plugin-host.js';
@@ -64,7 +65,11 @@ function buildProductCli(opts = {}) {
         .option('--build', 'cli.opt.build')
         .option('--check', 'cli.opt.check')
         .option('--deny-warnings', 'cli.opt.deny-warnings');
-    withWorkspaceOpts(cli.command('check', 'cli.cmd.check')).action((options) => cmdCheck(options));
+    withWorkspaceOpts(cli.command('check', 'cli.cmd.check'))
+        .option('--level <level>', 'cli.opt.level')
+        .option('--info', 'cli.opt.info-level')
+        .option('--style <style>', 'cli.opt.diag-style')
+        .action((options) => cmdCheck(options));
     withWorkspaceOpts(cli.command('build', 'cli.cmd.build')).action((options) => cmdBuild(options));
     withWorkspaceOpts(cli.command('serve', 'cli.cmd.serve')).action((options) => cmdServe(options));
     withWorkspaceOpts(cli.command('dev', 'cli.cmd.dev')).action((options) => cmdDev(options));
@@ -73,7 +78,11 @@ function buildProductCli(opts = {}) {
         .option('--no-rust', 'cli.opt.format-no-rust')
         .option('--no-vmz', 'cli.opt.format-no-vmz')
         .action((options) => cmdFormat(options));
-    withWorkspaceOpts(cli.command('lint', 'cli.cmd.lint')).action((options) => cmdLint(options));
+    withWorkspaceOpts(cli.command('lint', 'cli.cmd.lint'))
+        .option('--level <level>', 'cli.opt.level')
+        .option('--info', 'cli.opt.info-level')
+        .option('--style <style>', 'cli.opt.diag-style')
+        .action((options) => cmdLint(options));
     registerTestCommand(cli);
     registerDocumentCommands(cli.command('document|docs', 'cli.cmd.document'));
     registerLocaleCommands(cli.command('locale|locales', 'cli.cmd.locale'));
@@ -117,7 +126,25 @@ function cmdVersion() {
     console.log(`native host=${native.hostProtocol} compiler=${native.compilerProtocol} program_ir=${native.programIrSchema} plugin=${native.pluginProtocol}`);
     return 0;
 }
+function applyInspectLogOptions(args) {
+    const level = resolveCliLogLevel({ level: args.level, info: Boolean(args.info) });
+    if (level == null) {
+        log.errorId('cli.err.invalid_level', { level: String(args.level ?? '') });
+        return 1;
+    }
+    setCliLogLevel(level);
+    const style = parseCliLogStyle(args.style);
+    if (style == null) {
+        log.errorId('cli.err.invalid_style', { style: String(args.style ?? '') });
+        return 1;
+    }
+    setCliLogStyle(style);
+    return null;
+}
 async function cmdCheck(args) {
+    const optsErr = applyInspectLogOptions(args);
+    if (optsErr != null)
+        return optsErr;
     const pathArg = args._[0] ?? '.';
     const { project, outDir } = resolveWorkspaceDirs({
         path: pathArg,
@@ -358,7 +385,7 @@ async function cmdServe(args) {
     }
     const outDir = resolveProfileArtifactDir(outDirRoot, selected.profile);
     const hostJs = path.join(outDir, 'vmz-serve-host.mjs');
-    if (!existsSync(hostJs)) {
+    {
         try {
             materializeServeHostRuntime(outDir);
             log.info(`materialized ${hostJs} from @vmz/core (release builds omit it)`);
@@ -498,6 +525,9 @@ async function cmdFormat(args) {
     });
 }
 function cmdLint(args) {
+    const optsErr = applyInspectLogOptions(args);
+    if (optsErr != null)
+        return optsErr;
     const pathArg = args._[0] ?? '.';
     const { project, outDir } = resolveWorkspaceDirs({
         path: pathArg,

package/dist/workspace/diagnostic-context.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Source cache + OffsetIndex-backed PositionContext for CLI pretty diagnostics.
+ */
+import type { PositionContext } from '@vmz/diagnostic';
+/** Read and memoize a source file for snippet rendering. */
+export declare function readDiagnosticSource(path: string): string | undefined;
+/** OffsetIndex PositionContext for one source buffer (memoized per path). */
+export declare function positionContextForSource(path: string, sourceText: string): PositionContext;
+/** Clear caches between CLI invocations in long-lived hosts. */
+export declare function resetDiagnosticContext(): void;

package/dist/workspace/diagnostic-context.js

@@ -0,0 +1,53 @@
+/**
+ * Source cache + OffsetIndex-backed PositionContext for CLI pretty diagnostics.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { loadNative } from './public-api.js';
+const sourceCache = new Map();
+const positionCache = new Map();
+function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
+/** Read and memoize a source file for snippet rendering. */
+export function readDiagnosticSource(path) {
+    const key = normalizePath(path);
+    if (sourceCache.has(key))
+        return sourceCache.get(key);
+    if (!path || !existsSync(path))
+        return undefined;
+    try {
+        const text = readFileSync(path, 'utf8');
+        sourceCache.set(key, text);
+        return text;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** OffsetIndex PositionContext for one source buffer (memoized per path). */
+export function positionContextForSource(path, sourceText) {
+    const key = normalizePath(path);
+    const cached = positionCache.get(key);
+    if (cached)
+        return cached;
+    const native = loadNative();
+    if (typeof native.offsetIndexLineCol !== 'function') {
+        const fallback = { lineCol: () => ({ line: 1, column: 1 }) };
+        positionCache.set(key, fallback);
+        return fallback;
+    }
+    const source = String(sourceText ?? '');
+    const ctx = {
+        lineCol(offset) {
+            const row = native.offsetIndexLineCol(source, Math.max(0, Number(offset) || 0) >>> 0);
+            return { line: row.line, column: row.column };
+        },
+    };
+    positionCache.set(key, ctx);
+    return ctx;
+}
+/** Clear caches between CLI invocations in long-lived hosts. */
+export function resetDiagnosticContext() {
+    sourceCache.clear();
+    positionCache.clear();
+}

package/dist/workspace/log-level.d.ts

@@ -0,0 +1,25 @@
+/**
+ * CLI output verbosity for diagnostics and progress lines.
+ *
+ * `error` — errors only
+ * `warn`  — errors + warnings (default)
+ * `info`  — errors + warnings + advice, plus progress lines
+ */
+export type CliLogLevel = 'error' | 'warn' | 'info';
+/** Active CLI log level (default `warn`). */
+export declare function getCliLogLevel(): CliLogLevel;
+/** Set active CLI log level for the current command invocation. */
+export declare function setCliLogLevel(level: CliLogLevel): void;
+/** Parse `--level` values; `null` when unrecognized. */
+export declare function parseCliLogLevel(raw: unknown): CliLogLevel | null;
+/** Resolve level from `check` / `lint` flags (`--info` overrides `--level`). */
+export declare function resolveCliLogLevel(args: {
+    level?: unknown;
+    info?: boolean;
+}): CliLogLevel | null;
+/** Whether a diagnostic severity should be printed at `level`. */
+export declare function diagnosticVisible(severity: string | undefined, level: CliLogLevel): boolean;
+/** Progress / summary lines (`log.info`) only at `info`. */
+export declare function progressVisible(level: CliLogLevel): boolean;
+/** Non-diagnostic warn lines at `warn` and above. */
+export declare function warnVisible(level: CliLogLevel): boolean;

package/dist/workspace/log-level.js

@@ -0,0 +1,64 @@
+/**
+ * CLI output verbosity for diagnostics and progress lines.
+ *
+ * `error` — errors only
+ * `warn`  — errors + warnings (default)
+ * `info`  — errors + warnings + advice, plus progress lines
+ */
+const LEVEL_RANK = {
+    error: 0,
+    warn: 1,
+    info: 2,
+};
+let currentLevel = 'warn';
+/** Active CLI log level (default `warn`). */
+export function getCliLogLevel() {
+    return currentLevel;
+}
+/** Set active CLI log level for the current command invocation. */
+export function setCliLogLevel(level) {
+    currentLevel = level;
+}
+/** Parse `--level` values; `null` when unrecognized. */
+export function parseCliLogLevel(raw) {
+    if (raw == null || raw === '')
+        return 'warn';
+    const s = String(raw).trim().toLowerCase();
+    if (s === 'error')
+        return 'error';
+    if (s === 'warn' || s === 'warning')
+        return 'warn';
+    if (s === 'info' || s === 'advice')
+        return 'info';
+    return null;
+}
+/** Resolve level from `check` / `lint` flags (`--info` overrides `--level`). */
+export function resolveCliLogLevel(args) {
+    if (args.info)
+        return 'info';
+    return parseCliLogLevel(args.level);
+}
+function normalizeDiagnosticSeverity(severity) {
+    if (severity === 'warning')
+        return 'warning';
+    if (severity === 'advice')
+        return 'advice';
+    return 'error';
+}
+/** Whether a diagnostic severity should be printed at `level`. */
+export function diagnosticVisible(severity, level) {
+    const sev = normalizeDiagnosticSeverity(severity);
+    if (sev === 'error')
+        return true;
+    if (sev === 'warning')
+        return LEVEL_RANK[level] >= LEVEL_RANK.warn;
+    return LEVEL_RANK[level] >= LEVEL_RANK.info;
+}
+/** Progress / summary lines (`log.info`) only at `info`. */
+export function progressVisible(level) {
+    return level === 'info';
+}
+/** Non-diagnostic warn lines at `warn` and above. */
+export function warnVisible(level) {
+    return LEVEL_RANK[level] >= LEVEL_RANK.warn;
+}

package/dist/workspace/log-style.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI diagnostic layout: `pretty` (snippets) vs `compact` (single-line, CI-friendly).
+ */
+export type CliLogStyle = 'pretty' | 'compact';
+export declare function getCliLogStyle(): CliLogStyle;
+export declare function setCliLogStyle(style: CliLogStyle): void;
+export declare function parseCliLogStyle(raw: unknown): CliLogStyle | null;

package/dist/workspace/log-style.js

@@ -0,0 +1,20 @@
+/**
+ * CLI diagnostic layout: `pretty` (snippets) vs `compact` (single-line, CI-friendly).
+ */
+let currentStyle = 'pretty';
+export function getCliLogStyle() {
+    return currentStyle;
+}
+export function setCliLogStyle(style) {
+    currentStyle = style;
+}
+export function parseCliLogStyle(raw) {
+    if (raw == null || raw === '')
+        return 'pretty';
+    const s = String(raw).trim().toLowerCase();
+    if (s === 'pretty')
+        return 'pretty';
+    if (s === 'compact')
+        return 'compact';
+    return null;
+}

package/dist/workspace/log.d.ts

@@ -1,6 +1,7 @@
 /**
  * Unified CLI logging / diagnostics via `@vmz/diagnostic` + product catalog.
  */
+import { type CliLogLevel } from './log-level.js';
 export type DiagnosticLike = {
     severity?: string;
     path?: string;
@@ -12,15 +13,19 @@ export type DiagnosticLike = {
         end: number;
     };
 };
+export type DiagnosticLogOptions = {
+    denyWarnings?: boolean;
+    level?: CliLogLevel;
+};
 export declare const log: {
     info(...args: unknown[]): void;
     warn(...args: unknown[]): void;
     error(...args: unknown[]): void;
     /** Localized framework error (`cli.err.*`). */
     errorId(id: string, args?: Record<string, string>): void;
-    diagnostic(d: DiagnosticLike): void;
-    /** Failing count: errors, and warnings when `denyWarnings`. */
-    diagnostics(diagnostics: DiagnosticLike[] | null | undefined, opts?: {
-        denyWarnings?: boolean;
-    }): number;
+    diagnostic(d: DiagnosticLike, opts?: {
+        level?: CliLogLevel;
+    }): boolean;
+    /** Failing count: errors, and warnings when `denyWarnings` (independent of print level). */
+    diagnostics(diagnostics: DiagnosticLike[] | null | undefined, opts?: DiagnosticLogOptions): number;
 };

package/dist/workspace/log.js

@@ -3,32 +3,48 @@
  */
 import { formatDiagnostic } from '@vmz/diagnostic';
 import { loadCliCatalog, resolveVmzLocale, vmzCliLocalize } from '../cli/cli-localize.js';
-function stamp(level) {
-    return `vmz ${level}`;
+import { positionContextForSource, readDiagnosticSource } from './diagnostic-context.js';
+import { diagnosticVisible, getCliLogLevel, progressVisible, warnVisible } from './log-level.js';
+import { getCliLogStyle } from './log-style.js';
+function normalizeSeverity(severity) {
+    if (severity === 'warning')
+        return 'warning';
+    if (severity === 'advice')
+        return 'advice';
+    return 'error';
 }
 export const log = {
     info(...args) {
-        console.error(stamp('info'), ...args);
+        if (!progressVisible(getCliLogLevel()))
+            return;
+        console.error(...args);
     },
     warn(...args) {
-        console.error(stamp('warn'), ...args);
+        if (!warnVisible(getCliLogLevel()))
+            return;
+        console.error(...args);
     },
     error(...args) {
-        console.error(stamp('error'), ...args);
+        console.error(...args);
     },
     /** Localized framework error (`cli.err.*`). */
     errorId(id, args) {
-        console.error(stamp('error'), vmzCliLocalize.t(id, args));
+        console.error(vmzCliLocalize.t(id, args));
     },
-    diagnostic(d) {
-        const severity = d.severity === 'warning' || d.severity === 'advice' || d.severity === 'error' ? d.severity : 'error';
-        // Only invent transitional `diag.message` when wire has no code; never remap a real code.
+    diagnostic(d, opts = {}) {
+        const level = opts.level ?? getCliLogLevel();
+        const severity = normalizeSeverity(d.severity);
+        if (!diagnosticVisible(severity, level))
+            return false;
         const hasCode = Boolean(d.code && String(d.code).length);
         const code = hasCode ? String(d.code) : 'diag.message';
         const locale = resolveVmzLocale();
         const catalog = loadCliCatalog(locale);
+        const path = d.path || '';
+        const style = getCliLogStyle();
+        const sourceText = style === 'pretty' && path ? readDiagnosticSource(path) : undefined;
         const line = formatDiagnostic({
-            path: d.path || '',
+            path,
             severity,
             code,
             args: d.args ?? (!hasCode && d.message ? { message: String(d.message) } : undefined),
@@ -37,14 +53,26 @@ export const log = {
         }, {
             locale,
             catalog,
+            sourceText,
+            position: sourceText ? positionContextForSource(path, sourceText) : undefined,
+            style,
         });
-        console.error(stamp(severity === 'warning' ? 'warn' : severity === 'error' ? 'error' : 'diag'), line);
+        console.error(line);
+        return true;
     },
-    /** Failing count: errors, and warnings when `denyWarnings`. */
+    /** Failing count: errors, and warnings when `denyWarnings` (independent of print level). */
     diagnostics(diagnostics, opts = {}) {
+        const level = opts.level ?? getCliLogLevel();
+        const style = getCliLogStyle();
         let failing = 0;
-        for (const d of diagnostics ?? []) {
-            this.diagnostic(d);
+        const items = diagnostics ?? [];
+        const visible = items.filter((d) => diagnosticVisible(normalizeSeverity(d.severity), level));
+        for (let i = 0; i < visible.length; i += 1) {
+            this.diagnostic(visible[i], { level });
+            if (style === 'pretty' && i + 1 < visible.length)
+                console.error('');
+        }
+        for (const d of items) {
             if (d.severity === 'error')
                 failing += 1;
             else if (opts.denyWarnings && d.severity === 'warning')

package/dist/workspace/pack-client-packages.js

@@ -8,7 +8,7 @@
  *
  * Not full oxc chunk-split/minify (`oxc-pending` remains for release minify).
  */
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { resolvePackageRoot } from './packages.js';
@@ -29,15 +29,15 @@ export function packClientBareImports(outDir, opts = {}) {
     const skippedVmz = [];
     for (const file of listClientJs(outDir)) {
         for (const spec of collectBareSpecs(readFileSync(file, 'utf8'))) {
-            if (!bareQueue.includes(spec))
-                bareQueue.push(spec);
+            bareQueue.push({ spec: String(spec), from: file });
         }
     }
     while (bareQueue.length) {
-        const spec = bareQueue.shift();
+        const item = bareQueue.shift();
+        const { spec } = item;
         if (bareToVendor.has(spec))
             continue;
-        const resolved = resolveBareToSource(projectRoot, spec);
+        const resolved = resolveBareToSource(projectRoot, spec, item.from);
         if (!resolved) {
             if (!unresolved.includes(spec))
                 unresolved.push(spec);
@@ -59,7 +59,12 @@ export function packClientBareImports(outDir, opts = {}) {
     for (const file of [...listClientJs(outDir), ...listVendorJs(outDir)]) {
         const before = readFileSync(file, 'utf8');
         let after = rewriteBareImports(before, file, bareToVendor);
-        after = rewriteRelativeTsSpecs(after);
+        try {
+            after = rewriteRelativeTsSpecs(after);
+        }
+        catch (error) {
+            throw new Error(`pack module ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
         if (after !== before) {
             writeFileSync(file, after, 'utf8');
             rewritten.push(path.relative(outDir, file).replace(/\\/g, '/'));
@@ -105,10 +110,8 @@ function materializeSourceTree(outDir, resolved, materializedSources, bareQueue)
         writeFileSync(destAbs, js, 'utf8');
         if (sourceFile === resolved.sourceFile)
             entryDest = destAbs;
-        for (const bare of collectBareSpecs(js)) {
-            if (!bareQueue.includes(bare))
-                bareQueue.push(bare);
-        }
+        for (const bare of collectBareSpecs(js))
+            bareQueue.push({ spec: String(bare), from: sourceFile });
         for (const rel of collectRelativeSpecs(js)) {
             const target = resolveRelativeSource(path.dirname(sourceFile), rel);
             if (target && !materializedSources.has(target))
@@ -208,9 +211,25 @@ function isRelativeOrAbsolute(spec) {
 function shouldSkipBare(spec) {
     return SKIP_PREFIXES.some((p) => spec.startsWith(p));
 }
-function resolveBareToSource(projectRoot, spec) {
+function resolveBareToSource(projectRoot, spec, fromFile) {
     const { pkgName, subpath } = splitPackageSpec(spec);
-    let pkgRoot = resolvePackageRoot(projectRoot, pkgName);
+    let pkgRoot = null;
+    if (fromFile && existsSync(fromFile)) {
+        let cur = path.dirname(realpathSync(fromFile));
+        for (let i = 0; i < 12; i++) {
+            const nested = path.join(cur, 'node_modules', ...pkgName.split('/'));
+            if (existsSync(path.join(nested, 'package.json'))) {
+                pkgRoot = nested;
+                break;
+            }
+            const parent = path.dirname(cur);
+            if (parent === cur)
+                break;
+            cur = parent;
+        }
+    }
+    if (!pkgRoot)
+        pkgRoot = resolvePackageRoot(projectRoot, pkgName);
     if (!pkgRoot) {
         let cur = projectRoot;
         for (let i = 0; i < 8; i++) {
@@ -303,9 +322,16 @@ function packageDirName(pkgName) {
 function materializeModule(sourceFile) {
     const ext = path.extname(sourceFile).toLowerCase();
     const raw = readFileSync(sourceFile, 'utf8');
+    if (ext === '.json')
+        return raw;
     if (ext === '.ts' || ext === '.tsx')
         return transpileTs(raw, sourceFile);
-    return rewriteRelativeTsSpecs(raw);
+    try {
+        return rewriteRelativeTsSpecs(raw);
+    }
+    catch (error) {
+        throw new Error(`pack source ${sourceFile}: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
 function transpileTs(source, filename) {
     try {

package/locales/en-US/cli.json

@@ -62,6 +62,9 @@
     "cli.opt.build": "Build before serve",
     "cli.opt.check": "Format check-only / extract fail on CJK",
     "cli.opt.deny-warnings": "Treat warnings as errors",
+    "cli.opt.level": "Diagnostic verbosity: error | warn | info (default warn)",
+    "cli.opt.info-level": "Show advice diagnostics and progress (same as --level info)",
+    "cli.opt.diag-style": "Diagnostic layout: pretty | compact (default pretty)",
     "cli.opt.json": "Write JSON to stdout or file",
     "cli.opt.root": "Project root",
     "cli.opt.out": "Output directory",
@@ -101,6 +104,8 @@
     "cli.err.unknown_plan_kind": "unknown plan kind `{kind}` (locale | document-route)",
     "cli.err.gha.mode": "unknown --mode {mode} (status | wait)",
     "cli.err.gha.repo": "set --owner/--repo or GITHUB_REPOSITORY (owner/repo)",
+    "cli.err.invalid_level": "unknown --level `{level}` (error | warn | info)",
+    "cli.err.invalid_style": "unknown --style `{style}` (pretty | compact)",
     "cli.err.unknown_target": "unknown --target {target} (browser | mini-program-wechat)",
     "cli.err.document_build_aborted": "document build aborted due to diagnostics",
     "cli.err.locale_rename_usage": "usage: vmz locale rename <from-message-id> <to-message-id>",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/vmz",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "type": "module",
   "description": "VMZ Node toolchain — N-API workspace session + CLI (publish name @vmz/vmz)",
   "license": "MIT",
@@ -48,16 +48,16 @@
     }
   },
   "dependencies": {
-    "@vmz/commander": "0.2.3",
-    "@vmz/core": "0.2.3",
-    "@vmz/diagnostic": "0.2.3",
-    "@vmz/plugin": "0.2.3",
-    "@vmz/protocol": "0.2.3",
+    "@vmz/commander": "0.2.5",
+    "@vmz/core": "0.2.5",
+    "@vmz/diagnostic": "0.2.5",
+    "@vmz/plugin": "0.2.5",
+    "@vmz/protocol": "0.2.5",
     "jiti": "^2.6.1"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.2.3",
-    "@vmz/test": "0.2.3",
+    "@vmz/plugin-markdown-it": "0.2.5",
+    "@vmz/test": "0.2.5",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -92,12 +92,12 @@
     "cli"
   ],
   "optionalDependencies": {
-    "@vmz/vmz-win32-x64": "0.2.3",
-    "@vmz/vmz-win32-arm64": "0.2.3",
-    "@vmz/vmz-darwin-x64": "0.2.3",
-    "@vmz/vmz-darwin-arm64": "0.2.3",
-    "@vmz/vmz-linux-x64": "0.2.3",
-    "@vmz/vmz-linux-arm64": "0.2.3"
+    "@vmz/vmz-win32-x64": "0.2.5",
+    "@vmz/vmz-win32-arm64": "0.2.5",
+    "@vmz/vmz-darwin-x64": "0.2.5",
+    "@vmz/vmz-darwin-arm64": "0.2.5",
+    "@vmz/vmz-linux-x64": "0.2.5",
+    "@vmz/vmz-linux-arm64": "0.2.5"
   },
   "publishConfig": {
     "access": "public"