@pnpm/core-loggers 1100.2.4 → 1100.3.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @pnpm/core-loggers
 
+## 1100.3.0
+
+### Minor Changes
+
+- Restored the store block a first install prints, naming how packages were materialized and where the stores live [#13315](https://github.com/pnpm/pnpm/issues/13315):
+
+  ```text
+  Packages are hard linked from the content-addressable store to the virtual store.
+    Content-addressable store is at: ~/.local/share/pnpm/store/v11
+    Virtual store is at:             node_modules/.pnpm
+  ```
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/types@1101.7.0
+
+## 1100.2.5
+
+### Patch Changes
+
+- Republished every package: the tarballs published by the v11.13.1 through v11.16.0 releases were missing most of their compiled files due to a packing bug [#13164](https://github.com/pnpm/pnpm/issues/13164).
+
+- Updated dependencies:
+  - @pnpm/types@1101.6.0
+
 ## 1100.2.4
 
 ### Patch Changes

package/lib/all.d.ts

@@ -0,0 +1,27 @@
+export * from './contextLogger.js';
+export * from './deprecationLogger.js';
+export * from './executionTimeLogger.js';
+export * from './fetchingProgressLogger.js';
+export * from './hookLogger.js';
+export * from './ignoredScriptsLogger.js';
+export * from './installCheckLogger.js';
+export * from './installingConfigDeps.js';
+export * from './lifecycleLogger.js';
+export * from './linkLogger.js';
+export * from './lockfileVerificationLogger.js';
+export * from './packageImportMethodLogger.js';
+export * from './packageManifestLogger.js';
+export * from './peerDependencyIssues.js';
+export * from './progressLogger.js';
+export * from './promptLogger.js';
+export * from './registryLogger.js';
+export * from './removalLogger.js';
+export * from './reportPackageImported.js';
+export * from './requestRetryLogger.js';
+export * from './rootLogger.js';
+export * from './scopeLogger.js';
+export * from './skippedOptionalDependencyLogger.js';
+export * from './stageLogger.js';
+export * from './statsLogger.js';
+export * from './summaryLogger.js';
+export * from './updateCheckLogger.js';

package/lib/all.js

@@ -0,0 +1,28 @@
+export * from './contextLogger.js';
+export * from './deprecationLogger.js';
+export * from './executionTimeLogger.js';
+export * from './fetchingProgressLogger.js';
+export * from './hookLogger.js';
+export * from './ignoredScriptsLogger.js';
+export * from './installCheckLogger.js';
+export * from './installingConfigDeps.js';
+export * from './lifecycleLogger.js';
+export * from './linkLogger.js';
+export * from './lockfileVerificationLogger.js';
+export * from './packageImportMethodLogger.js';
+export * from './packageManifestLogger.js';
+export * from './peerDependencyIssues.js';
+export * from './progressLogger.js';
+export * from './promptLogger.js';
+export * from './registryLogger.js';
+export * from './removalLogger.js';
+export * from './reportPackageImported.js';
+export * from './requestRetryLogger.js';
+export * from './rootLogger.js';
+export * from './scopeLogger.js';
+export * from './skippedOptionalDependencyLogger.js';
+export * from './stageLogger.js';
+export * from './statsLogger.js';
+export * from './summaryLogger.js';
+export * from './updateCheckLogger.js';
+//# sourceMappingURL=all.js.map

package/lib/contextLogger.d.ts

@@ -0,0 +1,10 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const contextLogger: import("@pnpm/logger").Logger<unknown>;
+export interface ContextMessage {
+    currentLockfileExists: boolean;
+    storeDir: string;
+    virtualStoreDir: string;
+}
+export type ContextLog = {
+    name: 'pnpm:context';
+} & LogBase & ContextMessage;

package/lib/contextLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const contextLogger = logger('context');
+//# sourceMappingURL=contextLogger.js.map

package/lib/deprecationLogger.d.ts

@@ -0,0 +1,13 @@
+import { type LogBase, type Logger } from '@pnpm/logger';
+export declare const deprecationLogger: Logger<DeprecationMessage>;
+export interface DeprecationMessage {
+    pkgName: string;
+    pkgVersion: string;
+    pkgId: string;
+    prefix: string;
+    deprecated: string;
+    depth: number;
+}
+export type DeprecationLog = {
+    name: 'pnpm:deprecation';
+} & LogBase & DeprecationMessage;

package/lib/deprecationLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const deprecationLogger = logger('deprecation');
+//# sourceMappingURL=deprecationLogger.js.map

package/lib/executionTimeLogger.d.ts

@@ -0,0 +1,9 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const executionTimeLogger: import("@pnpm/logger").Logger<unknown>;
+export interface ExecutionTimeMessage {
+    startedAt: number;
+    endedAt: number;
+}
+export type ExecutionTimeLog = {
+    name: 'pnpm:execution-time';
+} & LogBase & ExecutionTimeMessage;

package/lib/executionTimeLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const executionTimeLogger = logger('execution-time');
+//# sourceMappingURL=executionTimeLogger.js.map

package/lib/fetchingProgressLogger.d.ts

@@ -0,0 +1,22 @@
+import { type LogBase, type Logger } from '@pnpm/logger';
+export declare const fetchingProgressLogger: Logger<FetchingProgressMessage>;
+export interface FetchingProgressMessageBase {
+    attempt?: number;
+    downloaded?: number;
+    packageId: string;
+    size?: number | null;
+    status?: 'started' | 'in_progress';
+}
+export interface FetchingProgressMessageStarted extends FetchingProgressMessageBase {
+    attempt: number;
+    size: number | null;
+    status: 'started';
+}
+export interface FetchingProgressMessageInProgress extends FetchingProgressMessageBase {
+    downloaded: number;
+    status: 'in_progress';
+}
+export type FetchingProgressMessage = FetchingProgressMessageStarted | FetchingProgressMessageInProgress;
+export type FetchingProgressLog = {
+    name: 'pnpm:fetching-progress';
+} & LogBase & FetchingProgressMessage;

package/lib/fetchingProgressLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const fetchingProgressLogger = logger('fetching-progress');
+//# sourceMappingURL=fetchingProgressLogger.js.map

package/lib/hookLogger.d.ts

@@ -0,0 +1,11 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const hookLogger: import("@pnpm/logger").Logger<unknown>;
+export interface HookMessage {
+    from: string;
+    hook: string;
+    message: string;
+    prefix: string;
+}
+export type HookLog = {
+    name: 'pnpm:hook';
+} & LogBase & HookMessage;

package/lib/hookLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const hookLogger = logger('hook');
+//# sourceMappingURL=hookLogger.js.map

package/lib/ignoredScriptsLogger.d.ts

@@ -0,0 +1,8 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const ignoredScriptsLogger: import("@pnpm/logger").Logger<unknown>;
+export interface IgnoredScriptsMessage {
+    packageNames: string[];
+}
+export type IgnoredScriptsLog = {
+    name: 'pnpm:ignored-scripts';
+} & LogBase & IgnoredScriptsMessage;

package/lib/ignoredScriptsLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const ignoredScriptsLogger = logger('ignored-scripts');
+//# sourceMappingURL=ignoredScriptsLogger.js.map

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import type { ContextLog, DeprecationLog, ExecutionTimeLog, FetchingProgressLog, HookLog, IgnoredScriptsLog, InstallCheckLog, InstallingConfigDepsLog, LifecycleLog, LinkLog, LockfileVerificationLog, PackageImportMethodLog, PackageManifestLog, PeerDependencyIssuesLog, ProgressLog, PromptLog, RegistryLog, RequestRetryLog, RootLog, ScopeLog, SkippedOptionalDependencyLog, StageLog, StatsLog, SummaryLog, UpdateCheckLog } from './all.js';
+export * from './all.js';
+export type Log = ContextLog | DeprecationLog | FetchingProgressLog | ExecutionTimeLog | HookLog | InstallCheckLog | InstallingConfigDepsLog | IgnoredScriptsLog | LifecycleLog | LinkLog | LockfileVerificationLog | PackageManifestLog | PackageImportMethodLog | PeerDependencyIssuesLog | ProgressLog | PromptLog | RegistryLog | RequestRetryLog | RootLog | ScopeLog | SkippedOptionalDependencyLog | StageLog | StatsLog | SummaryLog | UpdateCheckLog;

package/lib/installCheckLogger.d.ts

@@ -0,0 +1,9 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const installCheckLogger: import("@pnpm/logger").Logger<InstallCheckMessage>;
+export interface InstallCheckMessage {
+    code: string;
+    pkgId: string;
+}
+export type InstallCheckLog = {
+    name: 'pnpm:install-check';
+} & LogBase & InstallCheckMessage;

package/lib/installCheckLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const installCheckLogger = logger('install-check');
+//# sourceMappingURL=installCheckLogger.js.map

package/lib/installingConfigDeps.d.ts

@@ -0,0 +1,19 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const installingConfigDepsLogger: import("@pnpm/logger").Logger<InstallingConfigDepsMessage>;
+export interface InstallingConfigDepsMessageBase {
+    status?: 'started' | 'done';
+}
+export interface InstallingConfigDepsStartedMessage extends InstallingConfigDepsMessageBase {
+    status: 'started';
+}
+export interface InstallingConfigDepsDoneMessage extends InstallingConfigDepsMessageBase {
+    deps: Array<{
+        name: string;
+        version: string;
+    }>;
+    status: 'done';
+}
+export type InstallingConfigDepsMessage = InstallingConfigDepsStartedMessage | InstallingConfigDepsDoneMessage;
+export type InstallingConfigDepsLog = {
+    name: 'pnpm:installing-config-deps';
+} & LogBase & InstallingConfigDepsMessage;

package/lib/installingConfigDeps.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const installingConfigDepsLogger = logger('installing-config-deps');
+//# sourceMappingURL=installingConfigDeps.js.map

package/lib/lifecycleLogger.d.ts

@@ -0,0 +1,28 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const lifecycleLogger: import("@pnpm/logger").Logger<LifecycleMessage>;
+export interface LifecycleMessageBase {
+    depPath: string;
+    stage: string;
+    wd: string;
+    exitCode?: number;
+    line?: string;
+    optional?: boolean;
+    script?: string;
+    stdio?: 'stdout' | 'stderr';
+}
+export interface StdioLifecycleMessage extends LifecycleMessageBase {
+    line: string;
+    stdio: 'stdout' | 'stderr';
+}
+export interface ExitLifecycleMessage extends LifecycleMessageBase {
+    exitCode: number;
+    optional: boolean;
+}
+export interface ScriptLifecycleMessage extends LifecycleMessageBase {
+    script: string;
+    optional: boolean;
+}
+export type LifecycleMessage = StdioLifecycleMessage | ExitLifecycleMessage | ScriptLifecycleMessage;
+export type LifecycleLog = {
+    name: 'pnpm:lifecycle';
+} & LogBase & LifecycleMessage;

package/lib/lifecycleLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const lifecycleLogger = logger('lifecycle');
+//# sourceMappingURL=lifecycleLogger.js.map

package/lib/linkLogger.d.ts

@@ -0,0 +1,9 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const linkLogger: import("@pnpm/logger").Logger<LinkMessage>;
+export interface LinkMessage {
+    target: string;
+    link: string;
+}
+export type LinkLog = {
+    name: 'pnpm:link';
+} & LogBase & LinkMessage;

package/lib/linkLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const linkLogger = logger('link');
+//# sourceMappingURL=linkLogger.js.map

package/lib/lockfileVerificationLogger.d.ts

@@ -0,0 +1,57 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const lockfileVerificationLogger: import("@pnpm/logger").Logger<LockfileVerificationMessage>;
+export interface LockfileVerificationMessageBase {
+    status: 'started' | 'done' | 'failed' | 'cached';
+    /**
+     * Absolute path of the lockfile being verified. Omitted only when
+     * the verifier is invoked without a path (today only in unit tests
+     * that skip the cache wiring); production code paths always pass it.
+     */
+    lockfilePath?: string;
+}
+export interface LockfileVerificationStartedMessage extends LockfileVerificationMessageBase {
+    status: 'started';
+    /** Number of distinct (name, version, resolution) entries about to be verified. */
+    entries: number;
+}
+export interface LockfileVerificationDoneMessage extends LockfileVerificationMessageBase {
+    status: 'done';
+    /** Number of distinct (name, version, resolution) entries that were verified. */
+    entries: number;
+    /** Milliseconds elapsed between the matching `started` event and `done`. */
+    elapsedMs: number;
+}
+/**
+ * Terminal event emitted on every exit path that emitted `started` but
+ * didn't succeed — both policy violations (a `PnpmError` is about to be
+ * thrown with the breakdown) and unexpected throws from the registry
+ * fan-out. Lets the reporter close out the transient `started` frame
+ * in ansi-diff mode so it isn't left looking like a hung spinner above
+ * the failure output.
+ */
+export interface LockfileVerificationFailedMessage extends LockfileVerificationMessageBase {
+    status: 'failed';
+    /** Number of distinct (name, version, resolution) entries that were checked before the failure. */
+    entries: number;
+    /** Milliseconds elapsed between the matching `started` event and `failed`. */
+    elapsedMs: number;
+}
+/**
+ * Emitted instead of a `started`/`done` pair when the verification
+ * cache already holds a passing verdict for this lockfile content
+ * under the same (or stricter) policy, so the gate short-circuited
+ * without contacting the registry. Carries no `entries` count — the
+ * short-circuit happens before candidates are collected.
+ */
+export interface LockfileVerificationCachedMessage extends LockfileVerificationMessageBase {
+    status: 'cached';
+    /**
+     * ISO-8601 timestamp of the verification run the cached verdict was
+     * recorded by. Omitted when the cache record predates the field.
+     */
+    verifiedAt?: string;
+}
+export type LockfileVerificationMessage = LockfileVerificationStartedMessage | LockfileVerificationDoneMessage | LockfileVerificationFailedMessage | LockfileVerificationCachedMessage;
+export type LockfileVerificationLog = {
+    name: 'pnpm:lockfile-verification';
+} & LogBase & LockfileVerificationMessage;

package/lib/lockfileVerificationLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const lockfileVerificationLogger = logger('lockfile-verification');
+//# sourceMappingURL=lockfileVerificationLogger.js.map

package/lib/packageImportMethodLogger.d.ts

@@ -0,0 +1,8 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const packageImportMethodLogger: import("@pnpm/logger").Logger<unknown>;
+export interface PackageImportMethodMessage {
+    method: 'clone' | 'hardlink' | 'copy';
+}
+export type PackageImportMethodLog = {
+    name: 'pnpm:package-import-method';
+} & LogBase & PackageImportMethodMessage;

package/lib/packageImportMethodLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const packageImportMethodLogger = logger('package-import-method');
+//# sourceMappingURL=packageImportMethodLogger.js.map

package/lib/packageManifestLogger.d.ts

@@ -0,0 +1,18 @@
+import { type LogBase } from '@pnpm/logger';
+import type { ProjectManifest } from '@pnpm/types';
+export declare const packageManifestLogger: import("@pnpm/logger").Logger<PackageManifestMessage>;
+export interface PackageManifestMessageBase {
+    prefix: string;
+    initial?: ProjectManifest;
+    updated?: ProjectManifest;
+}
+export interface PackageManifestMessageInitial extends PackageManifestMessageBase {
+    initial: ProjectManifest;
+}
+export interface PackageManifestMessageUpdated extends PackageManifestMessageBase {
+    updated: ProjectManifest;
+}
+export type PackageManifestMessage = PackageManifestMessageInitial | PackageManifestMessageUpdated;
+export type PackageManifestLog = {
+    name: 'pnpm:package-manifest';
+} & LogBase & PackageManifestMessage;

package/lib/packageManifestLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const packageManifestLogger = logger('package-manifest');
+//# sourceMappingURL=packageManifestLogger.js.map

package/lib/peerDependencyIssues.d.ts

@@ -0,0 +1,9 @@
+import { type LogBase, type Logger } from '@pnpm/logger';
+import type { PeerDependencyIssuesByProjects } from '@pnpm/types';
+export declare const peerDependencyIssuesLogger: Logger<PeerDependencyIssuesMessage>;
+export interface PeerDependencyIssuesMessage {
+    issuesByProjects: PeerDependencyIssuesByProjects;
+}
+export type PeerDependencyIssuesLog = {
+    name: 'pnpm:peer-dependency-issues';
+} & LogBase & PeerDependencyIssuesMessage;

package/lib/peerDependencyIssues.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const peerDependencyIssuesLogger = logger('peer-dependency-issues');
+//# sourceMappingURL=peerDependencyIssues.js.map

package/lib/progressLogger.d.ts

@@ -0,0 +1,15 @@
+import { type LogBase, type Logger } from '@pnpm/logger';
+export declare const progressLogger: Logger<ProgressMessage>;
+export type ProgressMessage = {
+    packageId: string;
+    requester: string;
+    status: 'fetched' | 'found_in_store' | 'resolved';
+} | {
+    status: 'imported';
+    method: string;
+    requester: string;
+    to: string;
+};
+export type ProgressLog = {
+    name: 'pnpm:progress';
+} & LogBase & ProgressMessage;

package/lib/progressLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const progressLogger = logger('progress');
+//# sourceMappingURL=progressLogger.js.map

package/lib/promptLogger.d.ts

@@ -0,0 +1,13 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const promptLogger: import("@pnpm/logger").Logger<PromptMessage>;
+export interface PromptMessage {
+    /**
+     * Emitted around an interactive prompt so the default reporter can hold its
+     * progress redraws while the prompt owns the terminal — otherwise the next
+     * redraw erases the prompt rendered below the frame (pnpm/pnpm#13019).
+     */
+    action: 'start' | 'end';
+}
+export type PromptLog = {
+    name: 'pnpm:prompt';
+} & LogBase & PromptMessage;

package/lib/promptLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const promptLogger = logger('prompt');
+//# sourceMappingURL=promptLogger.js.map

package/lib/registryLogger.d.ts

@@ -0,0 +1,6 @@
+import type { LogBase } from '@pnpm/logger';
+export type RegistryLog = {
+    name: 'pnpm:registry';
+} & LogBase & {
+    message: string;
+};

package/lib/registryLogger.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=registryLogger.js.map

package/lib/removalLogger.d.ts

@@ -0,0 +1 @@
+export declare const removalLogger: import("@pnpm/logger").Logger<string>;

package/lib/removalLogger.js

@@ -0,0 +1,3 @@
+import { logger } from '@pnpm/logger';
+export const removalLogger = logger('removal');
+//# sourceMappingURL=removalLogger.js.map

package/lib/reportPackageImported.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Report one package materialized from the content-addressable store into
+ * the virtual store.
+ *
+ * The import itself runs in a `@pnpm/worker` thread, whose loggers are not
+ * connected to the reporter, so both channels are emitted here — in the main
+ * process — from the method the worker reported back. `pnpm:progress` drives
+ * the "imported" counter; `pnpm:package-import-method` tells the reporter
+ * which wording to use for the store block it prints on a first install.
+ */
+export declare function reportPackageImported(opts: {
+    method: string;
+    requester: string;
+    to: string;
+}): void;

package/lib/reportPackageImported.js

@@ -0,0 +1,27 @@
+import { packageImportMethodLogger } from './packageImportMethodLogger.js';
+import { progressLogger } from './progressLogger.js';
+/**
+ * Report one package materialized from the content-addressable store into
+ * the virtual store.
+ *
+ * The import itself runs in a `@pnpm/worker` thread, whose loggers are not
+ * connected to the reporter, so both channels are emitted here — in the main
+ * process — from the method the worker reported back. `pnpm:progress` drives
+ * the "imported" counter; `pnpm:package-import-method` tells the reporter
+ * which wording to use for the store block it prints on a first install.
+ */
+export function reportPackageImported(opts) {
+    progressLogger.debug({
+        method: opts.method,
+        requester: opts.requester,
+        status: 'imported',
+        to: opts.to,
+    });
+    if (isKnownImportMethod(opts.method)) {
+        packageImportMethodLogger.debug({ method: opts.method });
+    }
+}
+function isKnownImportMethod(method) {
+    return method === 'clone' || method === 'hardlink' || method === 'copy';
+}
+//# sourceMappingURL=reportPackageImported.js.map

package/lib/requestRetryLogger.d.ts

@@ -0,0 +1,25 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const requestRetryLogger: import("@pnpm/logger").Logger<RequestRetryMessage>;
+export interface RequestRetryError {
+    name?: string;
+    message?: string;
+    status?: number;
+    statusCode?: number;
+    errno?: number;
+    code?: string;
+    cause?: {
+        code?: string;
+        errno?: number;
+    };
+}
+export interface RequestRetryMessage {
+    attempt: number;
+    error: RequestRetryError;
+    maxRetries: number;
+    method: string;
+    timeout: number;
+    url: string;
+}
+export type RequestRetryLog = {
+    name: 'pnpm:request-retry';
+} & LogBase & RequestRetryMessage;

package/lib/requestRetryLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const requestRetryLogger = logger('request-retry');
+//# sourceMappingURL=requestRetryLogger.js.map

package/lib/rootLogger.d.ts

@@ -0,0 +1,25 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const rootLogger: import("@pnpm/logger").Logger<RootMessage>;
+export type DependencyType = 'prod' | 'dev' | 'optional';
+export type RootMessage = {
+    prefix: string;
+} & ({
+    added: {
+        id?: string;
+        name: string;
+        realName: string;
+        version?: string;
+        dependencyType?: DependencyType;
+        latest?: string;
+        linkedFrom?: string;
+    };
+} | {
+    removed: {
+        name: string;
+        version?: string;
+        dependencyType?: DependencyType;
+    };
+});
+export type RootLog = {
+    name: 'pnpm:root';
+} & LogBase & RootMessage;

package/lib/rootLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const rootLogger = logger('root');
+//# sourceMappingURL=rootLogger.js.map

package/lib/scopeLogger.d.ts

@@ -0,0 +1,10 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const scopeLogger: import("@pnpm/logger").Logger<ScopeMessage>;
+export interface ScopeMessage {
+    selected: number;
+    total?: number;
+    workspacePrefix?: string;
+}
+export type ScopeLog = {
+    name: 'pnpm:scope';
+} & LogBase & ScopeMessage;

package/lib/scopeLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const scopeLogger = logger('scope');
+//# sourceMappingURL=scopeLogger.js.map

package/lib/skippedOptionalDependencyLogger.d.ts

@@ -0,0 +1,29 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const skippedOptionalDependencyLogger: import("@pnpm/logger").Logger<SkippedOptionalDependencyMessage>;
+export type SkippedOptionalDependencyLog = {
+    name: 'pnpm:skipped-optional-dependency';
+} & LogBase & SkippedOptionalDependencyMessage;
+export type SkippedOptionalDependencyMessage = {
+    details?: string;
+    parents?: Array<{
+        id: string;
+        name: string;
+        version: string;
+    }>;
+    prefix: string;
+} & ({
+    package: {
+        id: string;
+        name: string;
+        version: string;
+    };
+    reason: 'unsupported_engine' | 'unsupported_platform' | 'build_failure';
+} | {
+    package: {
+        id?: never;
+        name: string | undefined;
+        version: string | undefined;
+        bareSpecifier: string;
+    };
+    reason: 'resolution_failure';
+});

package/lib/skippedOptionalDependencyLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const skippedOptionalDependencyLogger = logger('skipped-optional-dependency');
+//# sourceMappingURL=skippedOptionalDependencyLogger.js.map

package/lib/stageLogger.d.ts

@@ -0,0 +1,9 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const stageLogger: import("@pnpm/logger").Logger<StageMessage>;
+export interface StageMessage {
+    prefix: string;
+    stage: 'resolution_started' | 'resolution_done' | 'importing_started' | 'importing_done';
+}
+export type StageLog = {
+    name: 'pnpm:stage';
+} & LogBase & StageMessage;

package/lib/stageLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const stageLogger = logger('stage');
+//# sourceMappingURL=stageLogger.js.map

package/lib/statsLogger.d.ts

@@ -0,0 +1,19 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const statsLogger: import("@pnpm/logger").Logger<StatsMessage>;
+export interface StatsMessageBase {
+    prefix: string;
+    added?: number;
+    removed?: number;
+}
+export interface StatsMessageAdded extends StatsMessageBase {
+    added: number;
+    removed?: never;
+}
+export interface StatsMessageRemoved extends StatsMessageBase {
+    added?: never;
+    removed: number;
+}
+export type StatsMessage = StatsMessageAdded | StatsMessageRemoved;
+export type StatsLog = {
+    name: 'pnpm:stats';
+} & LogBase & StatsMessage;

package/lib/statsLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const statsLogger = logger('stats');
+//# sourceMappingURL=statsLogger.js.map

package/lib/summaryLogger.d.ts

@@ -0,0 +1,8 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const summaryLogger: import("@pnpm/logger").Logger<SummaryMessage>;
+export interface SummaryMessage {
+    prefix: string;
+}
+export type SummaryLog = {
+    name: 'pnpm:summary';
+} & LogBase & SummaryMessage;

package/lib/summaryLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const summaryLogger = logger('summary');
+//# sourceMappingURL=summaryLogger.js.map

package/lib/updateCheckLogger.d.ts

@@ -0,0 +1,9 @@
+import { type LogBase } from '@pnpm/logger';
+export declare const updateCheckLogger: import("@pnpm/logger").Logger<unknown>;
+export interface UpdateCheckMessage {
+    currentVersion: string;
+    latestVersion: string;
+}
+export type UpdateCheckLog = {
+    name: 'pnpm:update-check';
+} & LogBase & UpdateCheckMessage;

package/lib/updateCheckLogger.js

@@ -0,0 +1,3 @@
+import { logger, } from '@pnpm/logger';
+export const updateCheckLogger = logger('update-check');
+//# sourceMappingURL=updateCheckLogger.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/core-loggers",
-  "version": "1100.2.4",
+  "version": "1100.3.0",
   "description": "Core loggers of pnpm",
   "keywords": [
     "pnpm",
@@ -30,13 +30,13 @@
     "test": "test"
   },
   "dependencies": {
-    "@pnpm/types": "1101.5.0"
+    "@pnpm/types": "1101.7.0"
   },
   "peerDependencies": {
     "@pnpm/logger": "^1100.0.0"
   },
   "devDependencies": {
-    "@pnpm/core-loggers": "1100.2.4",
+    "@pnpm/core-loggers": "1100.3.0",
     "@pnpm/logger": "1100.0.0"
   },
   "engines": {