console-bridge-sveltekit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chintan Thakkar
+
+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,152 @@
+# console-bridge-sveltekit
+
+Forward frontend console logs to your SvelteKit backend for easier debugging. Perfect for AI agents and developers who want to see all logs in one place.
+
+## Features
+
+- ✅ Forward frontend console logs to backend
+- ✅ See frontend + backend logs in single terminal
+- ✅ Dev-only (zero production overhead)
+- ✅ Batched requests for efficiency
+- ✅ Recursive-safe
+- ✅ Configurable log levels
+- ✅ TypeScript support
+- ✅ Stack trace capture for errors
+- ✅ Capture fetch + XHR network calls
+- ✅ Capture global errors/unhandled rejections
+- ✅ Optional response body capture w limits
+- ✅ URL include/ignore filters
+
+## Installation
+
+```bash
+npm install console-bridge-sveltekit
+# or
+pnpm add console-bridge-sveltekit
+# or
+yarn add console-bridge-sveltekit
+```
+
+## Usage
+
+### 1. Create API Endpoint
+
+Create `src/routes/api/console-bridge/+server.ts`:
+
+```typescript
+import { createConsoleBridgeEndpoint } from 'console-bridge-sveltekit/server';
+
+export const POST = createConsoleBridgeEndpoint();
+```
+
+### 2. Initialize in Layout
+
+In `src/routes/+layout.svelte`:
+
+```svelte
+<script>
+  import { onMount } from 'svelte';
+  import { initConsolebridge } from 'console-bridge-sveltekit/client';
+
+  onMount(() => {
+    initConsolebridge();
+  });
+</script>
+```
+
+That's it! Now all frontend console logs will appear in your server terminal.
+
+## Configuration
+
+### Client Options
+
+```typescript
+initConsolebridge({
+  endpoint: '/api/console-bridge',  // API endpoint
+  batchSize: 10,                    // Logs per batch
+  batchDelay: 100,                  // Batch delay (ms)
+  levels: ['error', 'warn'],        // Only forward errors and warnings
+  captureNetwork: true,             // Capture fetch/XHR
+  captureErrors: true,              // Capture global errors
+  networkBodyLimit: 500,            // Truncate response body length
+  networkInclude: [],               // Only these URLs
+  networkIgnore: []                 // Skip these URLs
+});
+```
+
+### Server Options
+
+```typescript
+export const POST = createConsoleBridgeEndpoint({
+  prefix: '[FRONTEND',  // Log prefix
+  formatter: (level, url, timestamp, args) => {
+    return `[CUSTOM] ${level} from ${url}`;
+  },
+  onLog: (level, url, timestamp, args) => {
+    // Custom handler (e.g., send to external service)
+    if (level === 'error') {
+      sendToSentry(args);
+    }
+  }
+});
+```
+
+## Example Output
+
+**Browser console:**
+```
+Hello from frontend
+```
+
+**Server terminal:**
+```
+[FRONTEND LOG] http://localhost:5173/app/dashboard @ 2024-01-11T10:30:00.000Z Hello from frontend
+```
+
+## API
+
+### Client
+
+#### `initConsolebridge(options?)`
+
+Initialize console bridge in browser.
+
+**Options:**
+- `endpoint?: string` - Backend endpoint (default: `/api/console-bridge`)
+- `batchSize?: number` - Logs per batch (default: 10)
+- `batchDelay?: number` - Batch delay in ms (default: 100)
+- `levels?: LogLevel[]` - Log levels to forward (default: all)
+- `captureNetwork?: boolean` - Forward fetch/XHR calls (default: true)
+- `captureErrors?: boolean` - Forward global errors/rejections (default: true)
+- `networkBodyLimit?: number` - Max body chars, 0 disables (default: 500)
+- `networkInclude?: (string | RegExp)[]` - Include-only URL patterns (default: [])
+- `networkIgnore?: (string | RegExp)[]` - Ignore URL patterns (default: [])
+
+#### `restoreConsole()`
+
+Restore original console methods.
+
+### Server
+
+#### `createConsoleBridgeEndpoint(options?)`
+
+Create SvelteKit RequestHandler for console bridge.
+
+**Options:**
+- `prefix?: string` - Log prefix (default: `[FRONTEND`)
+- `formatter?: (level, url, timestamp, args) => string` - Custom formatter
+- `onLog?: (level, url, timestamp, args) => void` - Custom log handler
+
+## Development
+
+```bash
+# Build
+pnpm build
+
+# Publish
+npm publish
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { initConsolebridge, restoreConsole, type ConsoleBridgeOptions } from './lib/client.js';
+export { createConsoleBridgeEndpoint, type ConsoleBridgeServerOptions } from './lib/server.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACN,iBAAiB,EACjB,cAAc,EACd,KAAK,oBAAoB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACN,2BAA2B,EAC3B,KAAK,0BAA0B,EAC/B,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+// Re-export everything for convenience
+export { initConsolebridge, restoreConsole } from './lib/client.js';
+export { createConsoleBridgeEndpoint } from './lib/server.js';

package/dist/lib/client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Client-side console bridge for SvelteKit
+ * Intercepts console methods and forwards logs to backend
+ */
+export interface ConsoleBridgeOptions {
+    endpoint?: string;
+    batchSize?: number;
+    batchDelay?: number;
+    levels?: LogLevel[];
+    captureNetwork?: boolean;
+    captureErrors?: boolean;
+    networkBodyLimit?: number;
+    networkIgnore?: (string | RegExp)[];
+    networkInclude?: (string | RegExp)[];
+}
+type LogLevel = 'log' | 'warn' | 'error' | 'info' | 'debug';
+/**
+ * Initialize console bridge
+ * Call this in your root +layout.svelte onMount()
+ */
+export declare function initConsolebridge(userOptions?: ConsoleBridgeOptions): void;
+/**
+ * Restore original console methods
+ */
+export declare function restoreConsole(): void;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/lib/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/lib/client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACpC,cAAc,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CACrC;AAED,KAAK,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;AAmW5D;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,GAAE,oBAAyB,QA4BvE;AAED;;GAEG;AACH,wBAAgB,cAAc,SAU7B"}

package/dist/lib/client.js

@@ -0,0 +1,364 @@
+/**
+ * Client-side console bridge for SvelteKit
+ * Intercepts console methods and forwards logs to backend
+ */
+import { browser, dev } from '$app/environment';
+const DEFAULT_OPTIONS = {
+    endpoint: '/api/console-bridge',
+    batchSize: 10,
+    batchDelay: 100,
+    levels: ['log', 'warn', 'error', 'info', 'debug'],
+    captureNetwork: true,
+    captureErrors: true,
+    networkBodyLimit: 500,
+    networkIgnore: [],
+    networkInclude: []
+};
+let isSending = false;
+let logQueue = [];
+let batchTimer = null;
+let options = null;
+let isInitialized = false;
+let networkPatched = false;
+let errorListenersAttached = false;
+let originalFetch = null;
+let originalXhrOpen = null;
+let originalXhrSend = null;
+let errorHandler = null;
+let rejectionHandler = null;
+const xhrMeta = new WeakMap();
+// Store original console methods
+const originalConsole = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+    info: console.info,
+    debug: console.debug
+};
+function resolveUrl(input) {
+    try {
+        return new URL(input, window.location.href).toString();
+    }
+    catch {
+        return input;
+    }
+}
+function matchesPattern(value, pattern) {
+    if (pattern instanceof RegExp)
+        return pattern.test(value);
+    return value.includes(pattern);
+}
+function isNetworkTracked(targetUrl) {
+    if (!options)
+        return false;
+    const resolved = resolveUrl(targetUrl);
+    if (resolved === resolveUrl(options.endpoint))
+        return false;
+    if (options.networkIgnore.some((pattern) => matchesPattern(resolved, pattern))) {
+        return false;
+    }
+    if (options.networkInclude.length > 0) {
+        return options.networkInclude.some((pattern) => matchesPattern(resolved, pattern));
+    }
+    return true;
+}
+function queueEntry(entry) {
+    if (!dev || !browser || !options)
+        return;
+    if (isSending)
+        return;
+    logQueue.push(entry);
+    scheduleBatch();
+}
+function sendBatch() {
+    if (!options || isSending || logQueue.length === 0)
+        return;
+    isSending = true;
+    const batch = logQueue.splice(0, options.batchSize);
+    const sender = originalFetch ?? fetch;
+    sender(options.endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(batch.length === 1 ? batch[0] : { batch })
+    })
+        .catch((err) => {
+        originalConsole.error('[Console Bridge] Failed to send logs:', err);
+    })
+        .finally(() => {
+        isSending = false;
+        if (logQueue.length > 0) {
+            scheduleBatch();
+        }
+    });
+}
+function scheduleBatch() {
+    if (!options || batchTimer)
+        return;
+    batchTimer = setTimeout(() => {
+        batchTimer = null;
+        sendBatch();
+    }, options.batchDelay);
+}
+function createInterceptor(level) {
+    return function (...args) {
+        originalConsole[level](...args);
+        if (dev && browser && options?.levels.includes(level)) {
+            const entry = {
+                kind: 'console',
+                level,
+                args,
+                timestamp: new Date().toISOString(),
+                url: window.location.href
+            };
+            // Capture stack trace for errors
+            if (level === 'error' && args[0] instanceof Error) {
+                const error = args[0];
+                if (error.stack) {
+                    // Truncate to prevent huge payloads
+                    entry.stack = error.stack.slice(0, 1000);
+                }
+            }
+            queueEntry(entry);
+        }
+    };
+}
+function getFetchDetails(args) {
+    const [input, init] = args;
+    if (input instanceof Request) {
+        return { method: input.method ?? 'GET', url: input.url };
+    }
+    const url = typeof input === 'string' || input instanceof URL ? input.toString() : String(input);
+    return { method: init?.method ?? 'GET', url };
+}
+async function readResponseBody(response) {
+    if (!options || options.networkBodyLimit <= 0)
+        return undefined;
+    try {
+        const clone = response.clone();
+        const text = await clone.text();
+        return text.slice(0, options.networkBodyLimit);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readXhrBody(xhr) {
+    if (!options || options.networkBodyLimit <= 0)
+        return undefined;
+    try {
+        if (xhr.responseType && xhr.responseType !== 'text')
+            return undefined;
+        const text = typeof xhr.responseText === 'string' ? xhr.responseText : '';
+        return text.slice(0, options.networkBodyLimit);
+    }
+    catch {
+        return undefined;
+    }
+}
+function patchFetch() {
+    if (!('fetch' in window))
+        return;
+    if (!originalFetch)
+        originalFetch = window.fetch.bind(window);
+    window.fetch = (async (...args) => {
+        const [input, init] = args;
+        const { method, url } = getFetchDetails(args);
+        const resolvedUrl = resolveUrl(url);
+        if (!isNetworkTracked(resolvedUrl)) {
+            return originalFetch.call(window, input, init);
+        }
+        const start = performance.now();
+        try {
+            const response = await originalFetch.call(window, input, init);
+            const duration = Math.round(performance.now() - start);
+            const responseBody = await readResponseBody(response);
+            queueEntry({
+                kind: 'network',
+                level: 'network',
+                args: [`${method} ${resolvedUrl}`, `status: ${response.status}`, `duration: ${duration}ms`],
+                timestamp: new Date().toISOString(),
+                url: resolvedUrl,
+                method,
+                status: response.status,
+                duration,
+                requestType: 'fetch',
+                pageUrl: window.location.href,
+                responseBody
+            });
+            return response;
+        }
+        catch (err) {
+            const duration = Math.round(performance.now() - start);
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error && err.stack ? err.stack.slice(0, 1000) : undefined;
+            queueEntry({
+                kind: 'network',
+                level: 'network',
+                args: [`${method} ${resolvedUrl}`, `error: ${message}`, `duration: ${duration}ms`],
+                timestamp: new Date().toISOString(),
+                url: resolvedUrl,
+                method,
+                status: 0,
+                duration,
+                requestType: 'fetch',
+                pageUrl: window.location.href,
+                stack
+            });
+            throw err;
+        }
+    });
+}
+function patchXhr() {
+    if (!('XMLHttpRequest' in window))
+        return;
+    if (!originalXhrOpen)
+        originalXhrOpen = XMLHttpRequest.prototype.open;
+    if (!originalXhrSend)
+        originalXhrSend = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.open = function (method, url, ...rest) {
+        xhrMeta.set(this, { method, url, start: 0 });
+        return originalXhrOpen.apply(this, [method, url, ...rest]);
+    };
+    XMLHttpRequest.prototype.send = function (...args) {
+        const meta = xhrMeta.get(this);
+        if (meta)
+            meta.start = performance.now();
+        const resolvedUrl = meta ? resolveUrl(meta.url) : '';
+        const onDone = async () => {
+            this.removeEventListener('loadend', onDone);
+            if (!meta || !resolvedUrl || !isNetworkTracked(resolvedUrl))
+                return;
+            const duration = Math.round(performance.now() - meta.start);
+            const status = this.status || 0;
+            const responseBody = await readXhrBody(this);
+            queueEntry({
+                kind: 'network',
+                level: 'network',
+                args: [`${meta.method} ${resolvedUrl}`, `status: ${status}`, `duration: ${duration}ms`],
+                timestamp: new Date().toISOString(),
+                url: resolvedUrl,
+                method: meta.method,
+                status,
+                duration,
+                requestType: 'xhr',
+                pageUrl: window.location.href,
+                responseBody
+            });
+        };
+        this.addEventListener('loadend', onDone);
+        const body = args[0];
+        return originalXhrSend.call(this, body);
+    };
+}
+function restoreNetwork() {
+    if (!networkPatched)
+        return;
+    if (originalFetch)
+        window.fetch = originalFetch;
+    if (originalXhrOpen)
+        XMLHttpRequest.prototype.open = originalXhrOpen;
+    if (originalXhrSend)
+        XMLHttpRequest.prototype.send = originalXhrSend;
+    networkPatched = false;
+}
+function patchNetwork() {
+    if (networkPatched)
+        return;
+    networkPatched = true;
+    patchFetch();
+    patchXhr();
+}
+function attachErrorListeners() {
+    if (errorListenersAttached)
+        return;
+    errorListenersAttached = true;
+    errorHandler = (event) => {
+        const stack = event.error?.stack ? event.error.stack.slice(0, 1000) : undefined;
+        queueEntry({
+            kind: 'error',
+            level: 'error',
+            args: [event.message],
+            timestamp: new Date().toISOString(),
+            url: event.filename ?? window.location.href,
+            stack,
+            pageUrl: window.location.href
+        });
+    };
+    rejectionHandler = (event) => {
+        const reason = event.reason;
+        const message = reason instanceof Error ? reason.message : String(reason);
+        const stack = reason instanceof Error && reason.stack ? reason.stack.slice(0, 1000) : undefined;
+        queueEntry({
+            kind: 'error',
+            level: 'error',
+            args: [message],
+            timestamp: new Date().toISOString(),
+            url: window.location.href,
+            stack,
+            pageUrl: window.location.href
+        });
+    };
+    window.addEventListener('error', errorHandler);
+    window.addEventListener('unhandledrejection', rejectionHandler);
+}
+function detachErrorListeners() {
+    if (!errorListenersAttached)
+        return;
+    errorListenersAttached = false;
+    if (errorHandler)
+        window.removeEventListener('error', errorHandler);
+    if (rejectionHandler)
+        window.removeEventListener('unhandledrejection', rejectionHandler);
+    errorHandler = null;
+    rejectionHandler = null;
+}
+/**
+ * Initialize console bridge
+ * Call this in your root +layout.svelte onMount()
+ */
+export function initConsolebridge(userOptions = {}) {
+    if (!browser || !dev)
+        return;
+    options = { ...DEFAULT_OPTIONS, ...userOptions };
+    // Intercept only specified levels
+    if (options.levels.includes('log'))
+        console.log = createInterceptor('log');
+    if (options.levels.includes('warn'))
+        console.warn = createInterceptor('warn');
+    if (options.levels.includes('error'))
+        console.error = createInterceptor('error');
+    if (options.levels.includes('info'))
+        console.info = createInterceptor('info');
+    if (options.levels.includes('debug'))
+        console.debug = createInterceptor('debug');
+    if (options.captureNetwork) {
+        patchNetwork();
+    }
+    else {
+        restoreNetwork();
+    }
+    if (options.captureErrors) {
+        attachErrorListeners();
+    }
+    else {
+        detachErrorListeners();
+    }
+    if (!isInitialized) {
+        isInitialized = true;
+        originalConsole.info(`[Console Bridge] Active - logs forwarded to ${options.endpoint}`);
+    }
+}
+/**
+ * Restore original console methods
+ */
+export function restoreConsole() {
+    console.log = originalConsole.log;
+    console.warn = originalConsole.warn;
+    console.error = originalConsole.error;
+    console.info = originalConsole.info;
+    console.debug = originalConsole.debug;
+    restoreNetwork();
+    detachErrorListeners();
+    options = null;
+    isInitialized = false;
+}

package/dist/lib/server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Server-side console bridge endpoint factory
+ */
+import type { RequestHandler } from '@sveltejs/kit';
+export interface ConsoleBridgeServerOptions {
+    prefix?: string;
+    formatter?: (level: string, url: string, timestamp: string, args: any[]) => string;
+    onLog?: (level: string, url: string, timestamp: string, args: any[]) => void;
+}
+/**
+ * Create a SvelteKit RequestHandler for console bridge endpoint
+ * Use in your +server.ts: export const POST = createConsoleBridgeEndpoint();
+ */
+export declare function createConsoleBridgeEndpoint(userOptions?: ConsoleBridgeServerOptions): RequestHandler;
+//# sourceMappingURL=server.d.ts.map

package/dist/lib/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/lib/server.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,MAAM,WAAW,0BAA0B;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC;IACnF,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CAC7E;AASD;;;GAGG;AACH,wBAAgB,2BAA2B,CAC1C,WAAW,GAAE,0BAA+B,GAC1C,cAAc,CAuDhB"}

package/dist/lib/server.js

@@ -0,0 +1,61 @@
+/**
+ * Server-side console bridge endpoint factory
+ */
+import { json, error } from '@sveltejs/kit';
+const DEFAULT_OPTIONS = {
+    prefix: '[FRONTEND',
+    formatter: (level, url, timestamp) => `[FRONTEND ${level.toUpperCase()}] ${url} @ ${timestamp}`,
+    onLog: () => { }
+};
+/**
+ * Create a SvelteKit RequestHandler for console bridge endpoint
+ * Use in your +server.ts: export const POST = createConsoleBridgeEndpoint();
+ */
+export function createConsoleBridgeEndpoint(userOptions = {}) {
+    const options = { ...DEFAULT_OPTIONS, ...userOptions };
+    return async ({ request }) => {
+        // Only allow in dev mode
+        if (import.meta.env.PROD) {
+            throw error(404);
+        }
+        try {
+            const body = await request.json();
+            // Handle both single log and batch
+            const logs = Array.isArray(body.batch) ? body.batch : [body];
+            for (const log of logs) {
+                const { level, args, timestamp, url, stack } = log;
+                // Custom formatter or default
+                const prefix = options.formatter(level, url, timestamp, args);
+                // Prepare args for logging (include stack if present)
+                const logArgs = stack ? [...args, `\nStack: ${stack}`] : args;
+                // Log to console
+                switch (level) {
+                    case 'error':
+                        console.error(prefix, ...logArgs);
+                        break;
+                    case 'warn':
+                        console.warn(prefix, ...logArgs);
+                        break;
+                    case 'info':
+                        console.info(prefix, ...logArgs);
+                        break;
+                    case 'debug':
+                        console.debug(prefix, ...logArgs);
+                        break;
+                    case 'network':
+                        console.info(prefix, ...logArgs);
+                        break;
+                    default:
+                        console.log(prefix, ...logArgs);
+                }
+                // Custom callback
+                options.onLog(level, url, timestamp, args);
+            }
+            return json({ success: true });
+        }
+        catch (err) {
+            console.error('[Console Bridge] Failed to process logs:', err);
+            return json({ success: false }, { status: 400 });
+        }
+    };
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "console-bridge-sveltekit",
+	"version": "1.0.0",
+	"description": "Forward frontend console logs to backend for easier debugging in SvelteKit",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./client": {
+			"types": "./dist/lib/client.d.ts",
+			"import": "./dist/lib/client.js"
+		},
+		"./server": {
+			"types": "./dist/lib/server.d.ts",
+			"import": "./dist/lib/server.js"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"build": "tsc",
+		"prepublishOnly": "pnpm build"
+	},
+	"keywords": [
+		"sveltekit",
+		"console",
+		"logging",
+		"debugging",
+		"development"
+	],
+	"author": "Chintan Thakkar",
+	"license": "MIT",
+	"peerDependencies": {
+		"@sveltejs/kit": "^2.0.0",
+		"svelte": "^5.0.0"
+	},
+	"devDependencies": {
+		"@sveltejs/kit": "^2.0.0",
+		"svelte": "^5.0.0",
+		"typescript": "^5.0.0"
+	}
+}