@blac/logging-plugin 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# @blac/logging-plugin
+
+Logging and debugging plugin for BlaC state management. Logs instance lifecycle, state changes, events, and monitors for potential memory issues.
+
+## Installation
+
+```bash
+pnpm add @blac/logging-plugin
+```
+
+## Usage
+
+```typescript
+import { getPluginManager } from '@blac/core';
+import { LoggingPlugin } from '@blac/logging-plugin';
+
+getPluginManager().install(new LoggingPlugin(), {
+  environment: 'development',
+});
+```
+
+## Configuration
+
+```typescript
+new LoggingPlugin({
+  // Log verbosity: 'minimal' | 'info' | 'debug' | 'verbose'
+  level: 'info',
+
+  // Output format: 'simple' (one-line) | 'grouped' (console.group)
+  format: 'grouped',
+
+  // Filtering
+  include: ['CounterCubit', 'CartVertex'], // Only log these classes
+  exclude: ['AnalyticsCubit'], // Exclude these classes
+  filter: ({ className, isIsolated }) => !isIsolated, // Custom filter
+
+  // Feature toggles
+  logLifecycle: true, // Log create/dispose
+  logStateChanges: true, // Log state transitions
+  logEvents: true, // Log Vertex events
+  includeCallstack: false, // Include callstack in logs
+
+  // Memory monitoring
+  instanceCountWarningThreshold: 50, // Warn when exceeded
+  detectRapidLifecycles: true, // Detect create/dispose loops
+  rapidLifecycleWindowMs: 1000, // Time window for detection
+  rapidLifecycleThreshold: 5, // Cycles to trigger warning
+
+  // State change batching
+  debounceStateChanges: true, // Group rapid successive changes
+  debounceWindowMs: 100, // Time window for batching
+
+  // Customization
+  prefix: '[BlaC]', // Log prefix
+  logger: console, // Custom logger
+});
+```
+
+## Log Levels
+
+| Level     | Logs                                               |
+| --------- | -------------------------------------------------- |
+| `minimal` | Warnings only (memory issues, suspicious activity) |
+| `info`    | Lifecycle + warnings                               |
+| `debug`   | + state changes + events                           |
+| `verbose` | + callstacks + full state objects                  |
+
+## Output Examples
+
+**Simple format:**
+
+```
+[BlaC] Created CounterCubit#abc12345 (isolated)
+[BlaC] CounterCubit#abc12345 state: 0 → 1
+[BlaC] Disposed CounterCubit#abc12345 (lived 5.2s)
+```
+
+**Grouped format:**
+
+```
+▼ [BlaC] CounterCubit#abc12345 state changed
+    Previous: 0
+    Current: 1
+```
+
+**Batched state changes (when multiple changes happen rapidly):**
+
+```
+[BlaC] CounterCubit#abc12345 state: 0 → 5 (5 changes batched)
+```
+
+```
+▼ [BlaC] CounterCubit#abc12345 state changed (5 batched)
+    Initial: 0
+    Final: 5
+  ▼ All changes
+      1. 0 → 1
+      2. 1 → 2
+      3. 2 → 3
+      4. 3 → 4
+      5. 4 → 5
+```
+
+**Warnings:**
+
+```
+[BlaC] ⚠️ High instance count: FormCubit has 52 instances
+[BlaC] ⚠️ Rapid lifecycle: CounterCubit created/disposed 5 times in 1000ms
+[BlaC] ⚠️ Unused instance: FormCubit#abc12345 disposed without state changes
+```

package/dist/LoggingPlugin.d.ts

@@ -0,0 +1,32 @@
+import type { BlacPlugin, PluginContext, StateContainer, Vertex, DiscriminatedEvent } from '@blac/core';
+import type { LoggingPluginConfig } from './types';
+export declare class LoggingPlugin implements BlacPlugin {
+    readonly name = "LoggingPlugin";
+    readonly version = "1.0.0";
+    private config;
+    private context?;
+    private simpleFormatter;
+    private groupedFormatter;
+    private instanceCountMonitor;
+    private lifecycleMonitor;
+    private stateChangeCount;
+    private stateChangeWindowStart;
+    private stateChangeLoggingDisabled;
+    constructor(config?: LoggingPluginConfig);
+    onInstall(context: PluginContext): void;
+    onUninstall(): void;
+    onInstanceCreated(instance: StateContainer<any>, context: PluginContext): void;
+    onStateChanged<S extends object>(instance: StateContainer<S>, previousState: S, currentState: S, callstack: string | undefined, context: PluginContext): void;
+    onEventAdded<E extends DiscriminatedEvent>(vertex: Vertex<any, E>, event: E & {
+        timestamp?: number;
+        source?: string;
+    }, context: PluginContext): void;
+    onInstanceDisposed(instance: StateContainer<any>, context: PluginContext): void;
+    logStats(): void;
+    private shouldLog;
+    private shouldLogLifecycle;
+    private shouldLogStateChanges;
+    private shouldLogEvents;
+    private logWarning;
+}
+//# sourceMappingURL=LoggingPlugin.d.ts.map

package/dist/formatters/GroupedFormatter.d.ts

@@ -0,0 +1,27 @@
+import type { InstanceMetadata } from '@blac/core';
+import type { ResolvedConfig } from '../types';
+export declare class GroupedFormatter {
+    private logger;
+    private prefix;
+    constructor(config: ResolvedConfig);
+    private formatInstanceId;
+    private group;
+    private groupEnd;
+    logInstall(stats: {
+        registeredTypes: number;
+        totalInstances: number;
+    }): void;
+    logUninstall(): void;
+    logInstanceCreated(metadata: InstanceMetadata, initialState: unknown): void;
+    logInstanceDisposed(metadata: InstanceMetadata, lifespanMs: number, stateChangeCount: number): void;
+    logStateChanged(metadata: InstanceMetadata, previousState: unknown, currentState: unknown, callstack: string | undefined, includeCallstack: boolean): void;
+    logEventAdded(className: string, instanceId: string, eventType: string, event: unknown): void;
+    logWarning(message: string, details?: Record<string, unknown>): void;
+    logStats(stats: {
+        registeredTypes: number;
+        totalInstances: number;
+        typeBreakdown: Record<string, number>;
+    }): void;
+    private formatDuration;
+}
+//# sourceMappingURL=GroupedFormatter.d.ts.map

package/dist/formatters/SimpleFormatter.d.ts

@@ -0,0 +1,26 @@
+import type { InstanceMetadata } from '@blac/core';
+import type { ResolvedConfig } from '../types';
+export declare class SimpleFormatter {
+    private logger;
+    private prefix;
+    constructor(config: ResolvedConfig);
+    private formatInstanceId;
+    logInstall(stats: {
+        registeredTypes: number;
+        totalInstances: number;
+    }): void;
+    logUninstall(): void;
+    logInstanceCreated(metadata: InstanceMetadata): void;
+    logInstanceDisposed(metadata: InstanceMetadata, lifespanMs: number): void;
+    logStateChanged(metadata: InstanceMetadata, previousState: unknown, currentState: unknown, _callstack: string | undefined, includeCallstack: boolean): void;
+    logEventAdded(className: string, instanceId: string, eventType: string, payload: unknown): void;
+    logWarning(message: string): void;
+    logStats(stats: {
+        registeredTypes: number;
+        totalInstances: number;
+        typeBreakdown: Record<string, number>;
+    }): void;
+    private formatState;
+    private formatDuration;
+}
+//# sourceMappingURL=SimpleFormatter.d.ts.map

package/dist/formatters/index.d.ts

@@ -0,0 +1,3 @@
+export { SimpleFormatter } from './SimpleFormatter';
+export { GroupedFormatter } from './GroupedFormatter';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.cjs

@@ -0,0 +1,392 @@
+
+//#region src/formatters/SimpleFormatter.ts
+var SimpleFormatter = class {
+	constructor(config) {
+		this.logger = config.logger;
+		this.prefix = config.prefix;
+	}
+	formatInstanceId(className, id) {
+		return `${className}#${id.length > 8 ? id.slice(0, 8) : id}`;
+	}
+	logInstall(stats) {
+		this.logger.log(`${this.prefix} Plugin installed (${stats.registeredTypes} types, ${stats.totalInstances} instances)`);
+	}
+	logUninstall() {
+		this.logger.log(`${this.prefix} Plugin uninstalled`);
+	}
+	logInstanceCreated(metadata) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		const isolated = metadata.isIsolated ? " (isolated)" : "";
+		this.logger.log(`${this.prefix} Created ${instanceId}${isolated}`);
+	}
+	logInstanceDisposed(metadata, lifespanMs) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		const lifespan = this.formatDuration(lifespanMs);
+		this.logger.log(`${this.prefix} Disposed ${instanceId} (lived ${lifespan})`);
+	}
+	logStateChanged(metadata, previousState, currentState, _callstack, includeCallstack) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		const prev = this.formatState(previousState);
+		const curr = this.formatState(currentState);
+		this.logger.log(`${this.prefix} ${instanceId} state: ${prev} → ${curr}`);
+		if (includeCallstack && _callstack) this.logger.log(`${this.prefix}   Callstack: ${_callstack}`);
+	}
+	logEventAdded(className, instanceId, eventType, payload) {
+		const id = this.formatInstanceId(className, instanceId);
+		const payloadStr = this.formatState(payload);
+		this.logger.log(`${this.prefix} ${id} event: ${eventType} ${payloadStr}`);
+	}
+	logWarning(message) {
+		this.logger.warn(`${this.prefix} ⚠️ ${message}`);
+	}
+	logStats(stats) {
+		this.logger.log(`${this.prefix} Stats: ${stats.totalInstances} instances across ${stats.registeredTypes} types`);
+	}
+	formatState(state) {
+		if (state === null) return "null";
+		if (state === void 0) return "undefined";
+		if (typeof state === "object") try {
+			const str = JSON.stringify(state);
+			return str.length > 50 ? str.slice(0, 50) + "..." : str;
+		} catch {
+			return "[Object]";
+		}
+		return String(state);
+	}
+	formatDuration(ms) {
+		if (ms < 1e3) return `${ms}ms`;
+		if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+		return `${(ms / 6e4).toFixed(1)}m`;
+	}
+};
+
+//#endregion
+//#region src/formatters/GroupedFormatter.ts
+var GroupedFormatter = class {
+	constructor(config) {
+		this.logger = config.logger;
+		this.prefix = config.prefix;
+	}
+	formatInstanceId(className, id) {
+		return `${className}#${id.length > 8 ? id.slice(0, 8) : id}`;
+	}
+	group(label, collapsed = true) {
+		if (collapsed && this.logger.groupCollapsed) this.logger.groupCollapsed(label);
+		else if (this.logger.group) this.logger.group(label);
+		else this.logger.log(label);
+	}
+	groupEnd() {
+		if (this.logger.groupEnd) this.logger.groupEnd();
+	}
+	logInstall(stats) {
+		this.group(`${this.prefix} Plugin installed`);
+		this.logger.log("Registered types:", stats.registeredTypes);
+		this.logger.log("Total instances:", stats.totalInstances);
+		this.groupEnd();
+	}
+	logUninstall() {
+		this.logger.log(`${this.prefix} Plugin uninstalled`);
+	}
+	logInstanceCreated(metadata, initialState) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		this.group(`${this.prefix} Created ${instanceId}`);
+		this.logger.log("Class:", metadata.className);
+		this.logger.log("Instance ID:", metadata.id);
+		this.logger.log("Isolated:", metadata.isIsolated);
+		this.logger.log("Initial state:", initialState);
+		if (metadata.callstack) this.logger.log("Callstack:", metadata.callstack);
+		this.groupEnd();
+	}
+	logInstanceDisposed(metadata, lifespanMs, stateChangeCount) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		this.group(`${this.prefix} Disposed ${instanceId}`);
+		this.logger.log("Lifespan:", this.formatDuration(lifespanMs));
+		this.logger.log("State changes:", stateChangeCount);
+		this.logger.log("Final state:", metadata.state);
+		this.groupEnd();
+	}
+	logStateChanged(metadata, previousState, currentState, callstack, includeCallstack) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		this.group(`${this.prefix} ${instanceId} state changed`);
+		this.logger.log("Previous:", previousState);
+		this.logger.log("Current:", currentState);
+		if (includeCallstack && callstack) this.logger.log("Callstack:", callstack);
+		this.groupEnd();
+	}
+	logEventAdded(className, instanceId, eventType, event) {
+		const id = this.formatInstanceId(className, instanceId);
+		this.group(`${this.prefix} ${id} event: ${eventType}`);
+		this.logger.log("Event:", event);
+		this.groupEnd();
+	}
+	logWarning(message, details) {
+		if (details) {
+			this.group(`${this.prefix} ⚠️ ${message}`, false);
+			for (const [key, value] of Object.entries(details)) this.logger.log(`${key}:`, value);
+			this.groupEnd();
+		} else this.logger.warn(`${this.prefix} ⚠️ ${message}`);
+	}
+	logStats(stats) {
+		this.group(`${this.prefix} Stats`);
+		this.logger.log("Registered types:", stats.registeredTypes);
+		this.logger.log("Total instances:", stats.totalInstances);
+		this.logger.log("Breakdown:", stats.typeBreakdown);
+		this.groupEnd();
+	}
+	formatDuration(ms) {
+		if (ms < 1e3) return `${ms}ms`;
+		if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+		return `${(ms / 6e4).toFixed(1)}m`;
+	}
+};
+
+//#endregion
+//#region src/monitors/InstanceCountMonitor.ts
+var InstanceCountMonitor = class {
+	constructor(config, onWarning) {
+		this.instanceCounts = /* @__PURE__ */ new Map();
+		this.warnedClasses = /* @__PURE__ */ new Set();
+		this.threshold = config.instanceCountWarningThreshold;
+		this.onWarning = onWarning;
+	}
+	onInstanceCreated(className) {
+		const count = (this.instanceCounts.get(className) ?? 0) + 1;
+		this.instanceCounts.set(className, count);
+		if (count >= this.threshold && !this.warnedClasses.has(className)) {
+			this.warnedClasses.add(className);
+			this.onWarning(`High instance count: ${className} has ${count} instances`, {
+				className,
+				count,
+				threshold: this.threshold
+			});
+		}
+	}
+	onInstanceDisposed(className) {
+		const count = this.instanceCounts.get(className) ?? 0;
+		if (count > 0) this.instanceCounts.set(className, count - 1);
+		if (count - 1 < this.threshold) this.warnedClasses.delete(className);
+	}
+	getStats() {
+		return new Map(this.instanceCounts);
+	}
+	reset() {
+		this.instanceCounts.clear();
+		this.warnedClasses.clear();
+	}
+};
+
+//#endregion
+//#region src/monitors/LifecycleMonitor.ts
+var LifecycleMonitor = class {
+	constructor(config, onWarning) {
+		this.lifecycleHistory = /* @__PURE__ */ new Map();
+		this.instanceInfo = /* @__PURE__ */ new Map();
+		this.warnedClasses = /* @__PURE__ */ new Set();
+		this.windowMs = config.rapidLifecycleWindowMs;
+		this.threshold = config.rapidLifecycleThreshold;
+		this.enabled = config.detectRapidLifecycles;
+		this.onWarning = onWarning;
+	}
+	onInstanceCreated(className, instanceId) {
+		if (!this.enabled) return;
+		this.instanceInfo.set(instanceId, {
+			createdAt: Date.now(),
+			stateChangeCount: 0
+		});
+		this.recordEvent(className, "created");
+		this.checkRapidLifecycle(className);
+	}
+	onInstanceDisposed(className, instanceId) {
+		if (!this.enabled) return;
+		this.instanceInfo.delete(instanceId);
+		this.recordEvent(className, "disposed");
+		this.checkRapidLifecycle(className);
+	}
+	onStateChanged(instanceId) {
+		const info = this.instanceInfo.get(instanceId);
+		if (info) info.stateChangeCount++;
+	}
+	getInstanceInfo(instanceId) {
+		return this.instanceInfo.get(instanceId);
+	}
+	recordEvent(className, type) {
+		const now = Date.now();
+		const events = this.lifecycleHistory.get(className) ?? [];
+		events.push({
+			timestamp: now,
+			type
+		});
+		const cutoff = now - this.windowMs;
+		const filtered = events.filter((e) => e.timestamp > cutoff);
+		this.lifecycleHistory.set(className, filtered);
+	}
+	checkRapidLifecycle(className) {
+		const events = this.lifecycleHistory.get(className) ?? [];
+		const cycleCount = Math.min(events.filter((e) => e.type === "created").length, events.filter((e) => e.type === "disposed").length);
+		if (cycleCount >= this.threshold && !this.warnedClasses.has(className)) {
+			this.warnedClasses.add(className);
+			this.onWarning(`Rapid lifecycle: ${className} created/disposed ${cycleCount} times in ${this.windowMs}ms`, {
+				className,
+				cycleCount,
+				windowMs: this.windowMs,
+				threshold: this.threshold
+			});
+			setTimeout(() => {
+				this.warnedClasses.delete(className);
+			}, this.windowMs);
+		}
+	}
+	reset() {
+		this.lifecycleHistory.clear();
+		this.instanceInfo.clear();
+		this.warnedClasses.clear();
+	}
+};
+
+//#endregion
+//#region src/types.ts
+function resolveConfig(config = {}) {
+	return {
+		level: config.level ?? "info",
+		format: config.format ?? "grouped",
+		logger: config.logger ?? console,
+		filter: config.filter,
+		include: config.include,
+		exclude: config.exclude,
+		logLifecycle: config.logLifecycle ?? true,
+		logStateChanges: config.logStateChanges ?? true,
+		logEvents: config.logEvents ?? true,
+		includeCallstack: config.includeCallstack ?? false,
+		instanceCountWarningThreshold: config.instanceCountWarningThreshold ?? 50,
+		detectRapidLifecycles: config.detectRapidLifecycles ?? true,
+		rapidLifecycleWindowMs: config.rapidLifecycleWindowMs ?? 1e3,
+		rapidLifecycleThreshold: config.rapidLifecycleThreshold ?? 5,
+		prefix: config.prefix ?? "[BlaC]"
+	};
+}
+
+//#endregion
+//#region src/LoggingPlugin.ts
+const STATE_CHANGE_RATE_LIMIT = 1e3;
+var LoggingPlugin = class {
+	constructor(config = {}) {
+		this.name = "LoggingPlugin";
+		this.version = "1.0.0";
+		this.stateChangeCount = 0;
+		this.stateChangeWindowStart = Date.now();
+		this.stateChangeLoggingDisabled = false;
+		this.config = resolveConfig(config);
+		const warningHandler = (message, details) => {
+			this.logWarning(message, details);
+		};
+		this.simpleFormatter = new SimpleFormatter(this.config);
+		this.groupedFormatter = new GroupedFormatter(this.config);
+		this.instanceCountMonitor = new InstanceCountMonitor(this.config, warningHandler);
+		this.lifecycleMonitor = new LifecycleMonitor(this.config, warningHandler);
+	}
+	onInstall(context) {
+		this.context = context;
+		const stats = context.getStats();
+		if (this.config.format === "simple") this.simpleFormatter.logInstall(stats);
+		else this.groupedFormatter.logInstall(stats);
+	}
+	onUninstall() {
+		if (this.config.format === "simple") this.simpleFormatter.logUninstall();
+		else this.groupedFormatter.logUninstall();
+		this.instanceCountMonitor.reset();
+		this.lifecycleMonitor.reset();
+		this.stateChangeCount = 0;
+		this.stateChangeWindowStart = Date.now();
+		this.stateChangeLoggingDisabled = false;
+		this.context = void 0;
+	}
+	onInstanceCreated(instance, context) {
+		const metadata = context.getInstanceMetadata(instance);
+		if (!this.shouldLog(instance, metadata.className, metadata.id, metadata.isIsolated)) return;
+		this.instanceCountMonitor.onInstanceCreated(metadata.className);
+		this.lifecycleMonitor.onInstanceCreated(metadata.className, metadata.id);
+		if (!this.shouldLogLifecycle()) return;
+		if (this.config.format === "simple") this.simpleFormatter.logInstanceCreated(metadata);
+		else this.groupedFormatter.logInstanceCreated(metadata, context.getState(instance));
+	}
+	onStateChanged(instance, previousState, currentState, callstack, context) {
+		const metadata = context.getInstanceMetadata(instance);
+		if (!this.shouldLog(instance, metadata.className, metadata.id, metadata.isIsolated)) return;
+		this.lifecycleMonitor.onStateChanged(metadata.id);
+		if (!this.shouldLogStateChanges()) return;
+		if (this.stateChangeLoggingDisabled) return;
+		const now = Date.now();
+		if (now - this.stateChangeWindowStart >= 1e3) {
+			this.stateChangeCount = 0;
+			this.stateChangeWindowStart = now;
+		}
+		this.stateChangeCount++;
+		if (this.stateChangeCount > STATE_CHANGE_RATE_LIMIT) {
+			this.stateChangeLoggingDisabled = true;
+			this.logWarning(`State change logging disabled: exceeded ${STATE_CHANGE_RATE_LIMIT} changes/second`);
+			return;
+		}
+		if (this.config.format === "simple") this.simpleFormatter.logStateChanged(metadata, previousState, currentState, callstack, this.config.includeCallstack);
+		else this.groupedFormatter.logStateChanged(metadata, previousState, currentState, callstack, this.config.includeCallstack);
+	}
+	onEventAdded(vertex, event, context) {
+		const metadata = context.getInstanceMetadata(vertex);
+		if (!this.shouldLog(vertex, metadata.className, metadata.id, metadata.isIsolated)) return;
+		if (!this.shouldLogEvents()) return;
+		const eventType = event.type ?? "UnknownEvent";
+		if (this.config.format === "simple") this.simpleFormatter.logEventAdded(metadata.className, metadata.id, eventType, event);
+		else this.groupedFormatter.logEventAdded(metadata.className, metadata.id, eventType, event);
+	}
+	onInstanceDisposed(instance, context) {
+		const metadata = context.getInstanceMetadata(instance);
+		if (!this.shouldLog(instance, metadata.className, metadata.id, metadata.isIsolated)) return;
+		const info = this.lifecycleMonitor.getInstanceInfo(metadata.id);
+		const lifespanMs = info ? Date.now() - info.createdAt : 0;
+		const stateChangeCount = info?.stateChangeCount ?? 0;
+		this.instanceCountMonitor.onInstanceDisposed(metadata.className);
+		this.lifecycleMonitor.onInstanceDisposed(metadata.className, metadata.id);
+		if (!this.shouldLogLifecycle()) return;
+		if (this.config.format === "simple") this.simpleFormatter.logInstanceDisposed(metadata, lifespanMs);
+		else this.groupedFormatter.logInstanceDisposed(metadata, lifespanMs, stateChangeCount);
+	}
+	logStats() {
+		if (!this.context) return;
+		const stats = this.context.getStats();
+		if (this.config.format === "simple") this.simpleFormatter.logStats(stats);
+		else this.groupedFormatter.logStats(stats);
+	}
+	shouldLog(instance, className, instanceId, isIsolated) {
+		if (this.config.include && !this.config.include.includes(className)) return false;
+		if (this.config.exclude?.includes(className)) return false;
+		if (this.config.filter) {
+			const ctx = {
+				instance,
+				className,
+				instanceId,
+				isIsolated
+			};
+			return this.config.filter(ctx);
+		}
+		return true;
+	}
+	shouldLogLifecycle() {
+		if (!this.config.logLifecycle) return false;
+		return this.config.level !== "minimal";
+	}
+	shouldLogStateChanges() {
+		if (!this.config.logStateChanges) return false;
+		return this.config.level === "info" || this.config.level === "debug" || this.config.level === "verbose";
+	}
+	shouldLogEvents() {
+		if (!this.config.logEvents) return false;
+		return this.config.level === "debug" || this.config.level === "verbose";
+	}
+	logWarning(message, details) {
+		if (this.config.format === "simple") this.simpleFormatter.logWarning(message);
+		else this.groupedFormatter.logWarning(message, details);
+	}
+};
+
+//#endregion
+exports.LoggingPlugin = LoggingPlugin;
+//# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export { LoggingPlugin } from './LoggingPlugin';
+export type { LoggingPluginConfig, LogLevel, LogFormat, Logger, FilterContext, FilterFn, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { LoggingPlugin } from './LoggingPlugin';
+export type { LoggingPluginConfig, LogLevel, LogFormat, Logger, FilterContext, FilterFn, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,391 @@
+//#region src/formatters/SimpleFormatter.ts
+var SimpleFormatter = class {
+	constructor(config) {
+		this.logger = config.logger;
+		this.prefix = config.prefix;
+	}
+	formatInstanceId(className, id) {
+		return `${className}#${id.length > 8 ? id.slice(0, 8) : id}`;
+	}
+	logInstall(stats) {
+		this.logger.log(`${this.prefix} Plugin installed (${stats.registeredTypes} types, ${stats.totalInstances} instances)`);
+	}
+	logUninstall() {
+		this.logger.log(`${this.prefix} Plugin uninstalled`);
+	}
+	logInstanceCreated(metadata) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		const isolated = metadata.isIsolated ? " (isolated)" : "";
+		this.logger.log(`${this.prefix} Created ${instanceId}${isolated}`);
+	}
+	logInstanceDisposed(metadata, lifespanMs) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		const lifespan = this.formatDuration(lifespanMs);
+		this.logger.log(`${this.prefix} Disposed ${instanceId} (lived ${lifespan})`);
+	}
+	logStateChanged(metadata, previousState, currentState, _callstack, includeCallstack) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		const prev = this.formatState(previousState);
+		const curr = this.formatState(currentState);
+		this.logger.log(`${this.prefix} ${instanceId} state: ${prev} → ${curr}`);
+		if (includeCallstack && _callstack) this.logger.log(`${this.prefix}   Callstack: ${_callstack}`);
+	}
+	logEventAdded(className, instanceId, eventType, payload) {
+		const id = this.formatInstanceId(className, instanceId);
+		const payloadStr = this.formatState(payload);
+		this.logger.log(`${this.prefix} ${id} event: ${eventType} ${payloadStr}`);
+	}
+	logWarning(message) {
+		this.logger.warn(`${this.prefix} ⚠️ ${message}`);
+	}
+	logStats(stats) {
+		this.logger.log(`${this.prefix} Stats: ${stats.totalInstances} instances across ${stats.registeredTypes} types`);
+	}
+	formatState(state) {
+		if (state === null) return "null";
+		if (state === void 0) return "undefined";
+		if (typeof state === "object") try {
+			const str = JSON.stringify(state);
+			return str.length > 50 ? str.slice(0, 50) + "..." : str;
+		} catch {
+			return "[Object]";
+		}
+		return String(state);
+	}
+	formatDuration(ms) {
+		if (ms < 1e3) return `${ms}ms`;
+		if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+		return `${(ms / 6e4).toFixed(1)}m`;
+	}
+};
+
+//#endregion
+//#region src/formatters/GroupedFormatter.ts
+var GroupedFormatter = class {
+	constructor(config) {
+		this.logger = config.logger;
+		this.prefix = config.prefix;
+	}
+	formatInstanceId(className, id) {
+		return `${className}#${id.length > 8 ? id.slice(0, 8) : id}`;
+	}
+	group(label, collapsed = true) {
+		if (collapsed && this.logger.groupCollapsed) this.logger.groupCollapsed(label);
+		else if (this.logger.group) this.logger.group(label);
+		else this.logger.log(label);
+	}
+	groupEnd() {
+		if (this.logger.groupEnd) this.logger.groupEnd();
+	}
+	logInstall(stats) {
+		this.group(`${this.prefix} Plugin installed`);
+		this.logger.log("Registered types:", stats.registeredTypes);
+		this.logger.log("Total instances:", stats.totalInstances);
+		this.groupEnd();
+	}
+	logUninstall() {
+		this.logger.log(`${this.prefix} Plugin uninstalled`);
+	}
+	logInstanceCreated(metadata, initialState) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		this.group(`${this.prefix} Created ${instanceId}`);
+		this.logger.log("Class:", metadata.className);
+		this.logger.log("Instance ID:", metadata.id);
+		this.logger.log("Isolated:", metadata.isIsolated);
+		this.logger.log("Initial state:", initialState);
+		if (metadata.callstack) this.logger.log("Callstack:", metadata.callstack);
+		this.groupEnd();
+	}
+	logInstanceDisposed(metadata, lifespanMs, stateChangeCount) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		this.group(`${this.prefix} Disposed ${instanceId}`);
+		this.logger.log("Lifespan:", this.formatDuration(lifespanMs));
+		this.logger.log("State changes:", stateChangeCount);
+		this.logger.log("Final state:", metadata.state);
+		this.groupEnd();
+	}
+	logStateChanged(metadata, previousState, currentState, callstack, includeCallstack) {
+		const instanceId = this.formatInstanceId(metadata.className, metadata.id);
+		this.group(`${this.prefix} ${instanceId} state changed`);
+		this.logger.log("Previous:", previousState);
+		this.logger.log("Current:", currentState);
+		if (includeCallstack && callstack) this.logger.log("Callstack:", callstack);
+		this.groupEnd();
+	}
+	logEventAdded(className, instanceId, eventType, event) {
+		const id = this.formatInstanceId(className, instanceId);
+		this.group(`${this.prefix} ${id} event: ${eventType}`);
+		this.logger.log("Event:", event);
+		this.groupEnd();
+	}
+	logWarning(message, details) {
+		if (details) {
+			this.group(`${this.prefix} ⚠️ ${message}`, false);
+			for (const [key, value] of Object.entries(details)) this.logger.log(`${key}:`, value);
+			this.groupEnd();
+		} else this.logger.warn(`${this.prefix} ⚠️ ${message}`);
+	}
+	logStats(stats) {
+		this.group(`${this.prefix} Stats`);
+		this.logger.log("Registered types:", stats.registeredTypes);
+		this.logger.log("Total instances:", stats.totalInstances);
+		this.logger.log("Breakdown:", stats.typeBreakdown);
+		this.groupEnd();
+	}
+	formatDuration(ms) {
+		if (ms < 1e3) return `${ms}ms`;
+		if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+		return `${(ms / 6e4).toFixed(1)}m`;
+	}
+};
+
+//#endregion
+//#region src/monitors/InstanceCountMonitor.ts
+var InstanceCountMonitor = class {
+	constructor(config, onWarning) {
+		this.instanceCounts = /* @__PURE__ */ new Map();
+		this.warnedClasses = /* @__PURE__ */ new Set();
+		this.threshold = config.instanceCountWarningThreshold;
+		this.onWarning = onWarning;
+	}
+	onInstanceCreated(className) {
+		const count = (this.instanceCounts.get(className) ?? 0) + 1;
+		this.instanceCounts.set(className, count);
+		if (count >= this.threshold && !this.warnedClasses.has(className)) {
+			this.warnedClasses.add(className);
+			this.onWarning(`High instance count: ${className} has ${count} instances`, {
+				className,
+				count,
+				threshold: this.threshold
+			});
+		}
+	}
+	onInstanceDisposed(className) {
+		const count = this.instanceCounts.get(className) ?? 0;
+		if (count > 0) this.instanceCounts.set(className, count - 1);
+		if (count - 1 < this.threshold) this.warnedClasses.delete(className);
+	}
+	getStats() {
+		return new Map(this.instanceCounts);
+	}
+	reset() {
+		this.instanceCounts.clear();
+		this.warnedClasses.clear();
+	}
+};
+
+//#endregion
+//#region src/monitors/LifecycleMonitor.ts
+var LifecycleMonitor = class {
+	constructor(config, onWarning) {
+		this.lifecycleHistory = /* @__PURE__ */ new Map();
+		this.instanceInfo = /* @__PURE__ */ new Map();
+		this.warnedClasses = /* @__PURE__ */ new Set();
+		this.windowMs = config.rapidLifecycleWindowMs;
+		this.threshold = config.rapidLifecycleThreshold;
+		this.enabled = config.detectRapidLifecycles;
+		this.onWarning = onWarning;
+	}
+	onInstanceCreated(className, instanceId) {
+		if (!this.enabled) return;
+		this.instanceInfo.set(instanceId, {
+			createdAt: Date.now(),
+			stateChangeCount: 0
+		});
+		this.recordEvent(className, "created");
+		this.checkRapidLifecycle(className);
+	}
+	onInstanceDisposed(className, instanceId) {
+		if (!this.enabled) return;
+		this.instanceInfo.delete(instanceId);
+		this.recordEvent(className, "disposed");
+		this.checkRapidLifecycle(className);
+	}
+	onStateChanged(instanceId) {
+		const info = this.instanceInfo.get(instanceId);
+		if (info) info.stateChangeCount++;
+	}
+	getInstanceInfo(instanceId) {
+		return this.instanceInfo.get(instanceId);
+	}
+	recordEvent(className, type) {
+		const now = Date.now();
+		const events = this.lifecycleHistory.get(className) ?? [];
+		events.push({
+			timestamp: now,
+			type
+		});
+		const cutoff = now - this.windowMs;
+		const filtered = events.filter((e) => e.timestamp > cutoff);
+		this.lifecycleHistory.set(className, filtered);
+	}
+	checkRapidLifecycle(className) {
+		const events = this.lifecycleHistory.get(className) ?? [];
+		const cycleCount = Math.min(events.filter((e) => e.type === "created").length, events.filter((e) => e.type === "disposed").length);
+		if (cycleCount >= this.threshold && !this.warnedClasses.has(className)) {
+			this.warnedClasses.add(className);
+			this.onWarning(`Rapid lifecycle: ${className} created/disposed ${cycleCount} times in ${this.windowMs}ms`, {
+				className,
+				cycleCount,
+				windowMs: this.windowMs,
+				threshold: this.threshold
+			});
+			setTimeout(() => {
+				this.warnedClasses.delete(className);
+			}, this.windowMs);
+		}
+	}
+	reset() {
+		this.lifecycleHistory.clear();
+		this.instanceInfo.clear();
+		this.warnedClasses.clear();
+	}
+};
+
+//#endregion
+//#region src/types.ts
+function resolveConfig(config = {}) {
+	return {
+		level: config.level ?? "info",
+		format: config.format ?? "grouped",
+		logger: config.logger ?? console,
+		filter: config.filter,
+		include: config.include,
+		exclude: config.exclude,
+		logLifecycle: config.logLifecycle ?? true,
+		logStateChanges: config.logStateChanges ?? true,
+		logEvents: config.logEvents ?? true,
+		includeCallstack: config.includeCallstack ?? false,
+		instanceCountWarningThreshold: config.instanceCountWarningThreshold ?? 50,
+		detectRapidLifecycles: config.detectRapidLifecycles ?? true,
+		rapidLifecycleWindowMs: config.rapidLifecycleWindowMs ?? 1e3,
+		rapidLifecycleThreshold: config.rapidLifecycleThreshold ?? 5,
+		prefix: config.prefix ?? "[BlaC]"
+	};
+}
+
+//#endregion
+//#region src/LoggingPlugin.ts
+const STATE_CHANGE_RATE_LIMIT = 1e3;
+var LoggingPlugin = class {
+	constructor(config = {}) {
+		this.name = "LoggingPlugin";
+		this.version = "1.0.0";
+		this.stateChangeCount = 0;
+		this.stateChangeWindowStart = Date.now();
+		this.stateChangeLoggingDisabled = false;
+		this.config = resolveConfig(config);
+		const warningHandler = (message, details) => {
+			this.logWarning(message, details);
+		};
+		this.simpleFormatter = new SimpleFormatter(this.config);
+		this.groupedFormatter = new GroupedFormatter(this.config);
+		this.instanceCountMonitor = new InstanceCountMonitor(this.config, warningHandler);
+		this.lifecycleMonitor = new LifecycleMonitor(this.config, warningHandler);
+	}
+	onInstall(context) {
+		this.context = context;
+		const stats = context.getStats();
+		if (this.config.format === "simple") this.simpleFormatter.logInstall(stats);
+		else this.groupedFormatter.logInstall(stats);
+	}
+	onUninstall() {
+		if (this.config.format === "simple") this.simpleFormatter.logUninstall();
+		else this.groupedFormatter.logUninstall();
+		this.instanceCountMonitor.reset();
+		this.lifecycleMonitor.reset();
+		this.stateChangeCount = 0;
+		this.stateChangeWindowStart = Date.now();
+		this.stateChangeLoggingDisabled = false;
+		this.context = void 0;
+	}
+	onInstanceCreated(instance, context) {
+		const metadata = context.getInstanceMetadata(instance);
+		if (!this.shouldLog(instance, metadata.className, metadata.id, metadata.isIsolated)) return;
+		this.instanceCountMonitor.onInstanceCreated(metadata.className);
+		this.lifecycleMonitor.onInstanceCreated(metadata.className, metadata.id);
+		if (!this.shouldLogLifecycle()) return;
+		if (this.config.format === "simple") this.simpleFormatter.logInstanceCreated(metadata);
+		else this.groupedFormatter.logInstanceCreated(metadata, context.getState(instance));
+	}
+	onStateChanged(instance, previousState, currentState, callstack, context) {
+		const metadata = context.getInstanceMetadata(instance);
+		if (!this.shouldLog(instance, metadata.className, metadata.id, metadata.isIsolated)) return;
+		this.lifecycleMonitor.onStateChanged(metadata.id);
+		if (!this.shouldLogStateChanges()) return;
+		if (this.stateChangeLoggingDisabled) return;
+		const now = Date.now();
+		if (now - this.stateChangeWindowStart >= 1e3) {
+			this.stateChangeCount = 0;
+			this.stateChangeWindowStart = now;
+		}
+		this.stateChangeCount++;
+		if (this.stateChangeCount > STATE_CHANGE_RATE_LIMIT) {
+			this.stateChangeLoggingDisabled = true;
+			this.logWarning(`State change logging disabled: exceeded ${STATE_CHANGE_RATE_LIMIT} changes/second`);
+			return;
+		}
+		if (this.config.format === "simple") this.simpleFormatter.logStateChanged(metadata, previousState, currentState, callstack, this.config.includeCallstack);
+		else this.groupedFormatter.logStateChanged(metadata, previousState, currentState, callstack, this.config.includeCallstack);
+	}
+	onEventAdded(vertex, event, context) {
+		const metadata = context.getInstanceMetadata(vertex);
+		if (!this.shouldLog(vertex, metadata.className, metadata.id, metadata.isIsolated)) return;
+		if (!this.shouldLogEvents()) return;
+		const eventType = event.type ?? "UnknownEvent";
+		if (this.config.format === "simple") this.simpleFormatter.logEventAdded(metadata.className, metadata.id, eventType, event);
+		else this.groupedFormatter.logEventAdded(metadata.className, metadata.id, eventType, event);
+	}
+	onInstanceDisposed(instance, context) {
+		const metadata = context.getInstanceMetadata(instance);
+		if (!this.shouldLog(instance, metadata.className, metadata.id, metadata.isIsolated)) return;
+		const info = this.lifecycleMonitor.getInstanceInfo(metadata.id);
+		const lifespanMs = info ? Date.now() - info.createdAt : 0;
+		const stateChangeCount = info?.stateChangeCount ?? 0;
+		this.instanceCountMonitor.onInstanceDisposed(metadata.className);
+		this.lifecycleMonitor.onInstanceDisposed(metadata.className, metadata.id);
+		if (!this.shouldLogLifecycle()) return;
+		if (this.config.format === "simple") this.simpleFormatter.logInstanceDisposed(metadata, lifespanMs);
+		else this.groupedFormatter.logInstanceDisposed(metadata, lifespanMs, stateChangeCount);
+	}
+	logStats() {
+		if (!this.context) return;
+		const stats = this.context.getStats();
+		if (this.config.format === "simple") this.simpleFormatter.logStats(stats);
+		else this.groupedFormatter.logStats(stats);
+	}
+	shouldLog(instance, className, instanceId, isIsolated) {
+		if (this.config.include && !this.config.include.includes(className)) return false;
+		if (this.config.exclude?.includes(className)) return false;
+		if (this.config.filter) {
+			const ctx = {
+				instance,
+				className,
+				instanceId,
+				isIsolated
+			};
+			return this.config.filter(ctx);
+		}
+		return true;
+	}
+	shouldLogLifecycle() {
+		if (!this.config.logLifecycle) return false;
+		return this.config.level !== "minimal";
+	}
+	shouldLogStateChanges() {
+		if (!this.config.logStateChanges) return false;
+		return this.config.level === "info" || this.config.level === "debug" || this.config.level === "verbose";
+	}
+	shouldLogEvents() {
+		if (!this.config.logEvents) return false;
+		return this.config.level === "debug" || this.config.level === "verbose";
+	}
+	logWarning(message, details) {
+		if (this.config.format === "simple") this.simpleFormatter.logWarning(message);
+		else this.groupedFormatter.logWarning(message, details);
+	}
+};
+
+//#endregion
+export { LoggingPlugin };
+//# sourceMappingURL=index.js.map

package/dist/monitors/InstanceCountMonitor.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedConfig } from '../types';
+export declare class InstanceCountMonitor {
+    private instanceCounts;
+    private warnedClasses;
+    private threshold;
+    private onWarning;
+    constructor(config: ResolvedConfig, onWarning: (message: string, details?: Record<string, unknown>) => void);
+    onInstanceCreated(className: string): void;
+    onInstanceDisposed(className: string): void;
+    getStats(): Map<string, number>;
+    reset(): void;
+}
+//# sourceMappingURL=InstanceCountMonitor.d.ts.map

package/dist/monitors/LifecycleMonitor.d.ts

@@ -0,0 +1,24 @@
+import type { ResolvedConfig } from '../types';
+interface InstanceInfo {
+    createdAt: number;
+    stateChangeCount: number;
+}
+export declare class LifecycleMonitor {
+    private lifecycleHistory;
+    private instanceInfo;
+    private windowMs;
+    private threshold;
+    private enabled;
+    private warnedClasses;
+    private onWarning;
+    constructor(config: ResolvedConfig, onWarning: (message: string, details?: Record<string, unknown>) => void);
+    onInstanceCreated(className: string, instanceId: string): void;
+    onInstanceDisposed(className: string, instanceId: string): void;
+    onStateChanged(instanceId: string): void;
+    getInstanceInfo(instanceId: string): InstanceInfo | undefined;
+    private recordEvent;
+    private checkRapidLifecycle;
+    reset(): void;
+}
+export {};
+//# sourceMappingURL=LifecycleMonitor.d.ts.map

package/dist/monitors/index.d.ts

@@ -0,0 +1,3 @@
+export { InstanceCountMonitor } from './InstanceCountMonitor';
+export { LifecycleMonitor } from './LifecycleMonitor';
+//# sourceMappingURL=index.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,69 @@
+import type { StateContainer } from '@blac/core';
+export type LogLevel = 'minimal' | 'info' | 'debug' | 'verbose';
+export type LogFormat = 'simple' | 'grouped';
+export interface Logger {
+    log(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    group?(label: string): void;
+    groupEnd?(): void;
+    groupCollapsed?(label: string): void;
+}
+export interface FilterContext {
+    instance: StateContainer<any>;
+    className: string;
+    instanceId: string;
+    isIsolated: boolean;
+}
+export type FilterFn = (ctx: FilterContext) => boolean;
+export interface LoggingPluginConfig {
+    /** Log verbosity level (default: 'info') */
+    level?: LogLevel;
+    /** Output format (default: 'grouped') */
+    format?: LogFormat;
+    /** Custom logger implementation (default: console) */
+    logger?: Logger;
+    /** Filter which instances to log */
+    filter?: FilterFn;
+    /** Include class names to log (whitelist) */
+    include?: string[];
+    /** Exclude class names from logging (blacklist) */
+    exclude?: string[];
+    /** Log instance creation/disposal (default: true) */
+    logLifecycle?: boolean;
+    /** Log state changes (default: true) */
+    logStateChanges?: boolean;
+    /** Log Vertex events (default: true) */
+    logEvents?: boolean;
+    /** Include callstack in state change logs (default: false) */
+    includeCallstack?: boolean;
+    /** Warn when instance count exceeds threshold (default: 50) */
+    instanceCountWarningThreshold?: number;
+    /** Warn on rapid init/dispose cycles (default: true) */
+    detectRapidLifecycles?: boolean;
+    /** Time window for rapid lifecycle detection in ms (default: 1000) */
+    rapidLifecycleWindowMs?: number;
+    /** Number of cycles in window to trigger warning (default: 5) */
+    rapidLifecycleThreshold?: number;
+    /** Log prefix (default: '[BlaC]') */
+    prefix?: string;
+}
+export interface ResolvedConfig {
+    level: LogLevel;
+    format: LogFormat;
+    logger: Logger;
+    filter: FilterFn | undefined;
+    include: string[] | undefined;
+    exclude: string[] | undefined;
+    logLifecycle: boolean;
+    logStateChanges: boolean;
+    logEvents: boolean;
+    includeCallstack: boolean;
+    instanceCountWarningThreshold: number;
+    detectRapidLifecycles: boolean;
+    rapidLifecycleWindowMs: number;
+    rapidLifecycleThreshold: number;
+    prefix: string;
+}
+export declare function resolveConfig(config?: LoggingPluginConfig): ResolvedConfig;
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@blac/logging-plugin",
+  "version": "2.0.0",
+  "type": "module",
+  "license": "MIT",
+  "author": "Brendan Mullins <jsnanigans@gmail.com>",
+  "description": "Logging and debugging plugin for BlaC state management",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsnanigans/blac.git",
+    "directory": "packages/logging-plugin"
+  },
+  "homepage": "https://github.com/jsnanigans/blac#readme",
+  "bugs": {
+    "url": "https://github.com/jsnanigans/blac/issues"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.cjs",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.cts",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "blac",
+    "logging",
+    "debugging",
+    "state-management",
+    "devtools"
+  ],
+  "peerDependencies": {
+    "@blac/core": "2.0.0"
+  },
+  "devDependencies": {
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "vitest": "3.2.4",
+    "tsdown": "^0.15.7",
+    "@blac/core": "2.0.0"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown && tsc -p tsconfig.build.json && cp dist/index.d.ts dist/index.d.cts",
+    "clean": "rm -rf dist",
+    "format": "prettier --write \".\"",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "typecheck": "tsc --noEmit",
+    "deploy": "pnpm publish --access public"
+  }
+}