@vibesdotdev/logging 0.0.1

package/dist/docs/transports.docs.descriptor.js

@@ -0,0 +1,426 @@
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'logging.transports',
+    title: 'Logging Transports',
+    summary: 'Transport layers including console, file, and remote outputs',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: `---
+title: Logging Transports
+summary: Transport layers including console, file, and remote outputs
+tags: [logging, transports, console, file, remote, outputs]
+parent: logging
+order: 2
+surfaces: [cli, web, in-app]
+hardware: [consumer, cloud]
+---
+
+# Logging Transports
+
+Transports (called "sinks" and "outputs" in the logging system) determine where log entries are written. The \`logging/sink\` and \`logging/output\` runtime kinds provide multiple transport options.
+
+## Transport Types
+
+### Console Sink
+
+Writes to stdout/stderr:
+
+\`\`\`ts
+import { logger } from '@vibesdotdev/logging';
+
+logger.info('Console output');
+// [INFO] [app] Console output
+\`\`\`
+
+**Configuration:**
+- Default for CLI and browser
+- Uses pretty formatter by default
+- Color-coded output
+
+**Use cases:**
+- Development debugging
+- CLI applications
+- Browser console
+
+### File Output
+
+Writes to log files:
+
+\`\`\`ts
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+
+const runtime = getVibesRuntime();
+
+await runtime.registerPlugin(loggingPlugin({
+  outputs: [{
+    type: 'file',
+    path: './logs/app.log',
+    format: 'jsonl',
+    maxSize: '10MB',
+    maxFiles: 5
+  }]
+}));
+\`\`\`
+
+**Features:**
+- Automatic rotation
+- Compression of old files
+- Timestamp-based naming
+
+**Use cases:**
+- Production logging
+- Audit trails
+- Long-term storage
+
+### Memory Sink
+
+Buffers logs in memory:
+
+\`\`\`ts
+import { memorySinkPlugin } from '@vibesdotdev/logging';
+
+await runtime.registerPlugin(memorySinkPlugin({
+  maxSize: 1000,  // Keep last 1000 entries
+  flushOn: 'error'  // Auto-flush on error level
+}));
+\`\`\`
+
+**Use cases:**
+- Testing
+- Debug sessions
+- Temporary buffering
+
+### Buffer Sink
+
+Circular buffer with flush capability:
+
+\`\`\`ts
+import { bufferSinkPlugin } from '@vibesdotdev/logging';
+
+await runtime.registerPlugin(bufferSinkPlugin({
+  capacity: 500,
+  flushInterval: 60_000  // Flush every minute
+}));
+\`\`\`
+
+**Use cases:**
+- Batch processing
+- Network optimization
+- Error context capture
+
+### Remote Output
+
+Sends logs to remote service:
+
+\`\`\`ts
+import { remoteOutputPlugin } from '@vibesdotdev/logging';
+
+await runtime.registerPlugin(remoteOutputPlugin({
+  endpoint: 'https://logs.vibes.dev/ingest',
+  apiKey: process.env.LOGS_API_KEY,
+  batchSize: 100,
+  flushInterval: 5_000
+}));
+\`\`\`
+
+**Features:**
+- Batched delivery
+- Retry on failure
+- Compression
+
+**Use cases:**
+- Centralized logging
+- Log aggregation services
+- Multi-app correlation
+
+## Configuring Transports
+
+### Multiple Transports
+
+\`\`\`ts
+import { loggingPlugin } from '@vibesdotdev/logging';
+
+await runtime.registerPlugin(loggingPlugin({
+  sinks: ['console', 'memory'],
+  outputs: [{
+    type: 'file',
+    path: './logs/app.log'
+  }, {
+    type: 'remote',
+    endpoint: 'https://logs.vibes.dev/ingest'
+  }]
+}));
+\`\`\`
+
+**Log flow:**
+\`\`\`
+Logger → Console (immediate)
+       → Memory (buffer)
+       → File (batched)
+       → Remote (batched, compressed)
+\`\`\`
+
+### Transport Selection by Environment
+
+\`\`\`ts
+const loggingConfig = {
+  development: {
+    sinks: ['console'],
+    level: 'debug'
+  },
+  production: {
+    sinks: ['console', 'memory'],
+    outputs: [
+      { type: 'file', path: '/var/log/app.log' },
+      { type: 'remote', endpoint: 'https://logs.vibes.dev' }
+    ],
+    level: 'info'
+  }
+};
+
+const env = process.env.NODE_ENV || 'development';
+await runtime.registerPlugin(loggingPlugin(loggingConfig[env]));
+\`\`\`
+
+### Transport Selection by Hardware
+
+\`\`\`ts
+const loggingConfig = {
+  consumer: {
+    sinks: ['console'],
+    outputs: [{ type: 'file', path: '~/.logs/app.log' }]
+  },
+  cloud: {
+    sinks: ['stdout'],
+    outputs: [{ type: 'remote', endpoint: 'https://logs.vibes.dev' }]
+  }
+};
+
+const hardware = runtime.scope.hardware;
+await runtime.registerPlugin(loggingPlugin(loggingConfig[hardware]));
+\`\`\`
+
+## Formatter Integration
+
+Transports use formatters to format log entries:
+
+### Pretty Formatter (Console)
+
+\`\`\`ts
+[INFO] [app:server] Server started on port 3000
+\`\`\`
+
+**Features:**
+- Color-coded levels
+- Human-readable timestamps
+- Indented context objects
+
+### JSON Formatter
+
+\`\`\`json
+{"level":"info","namespace":"app:server","message":"Server started","port":3000,"timestamp":"2024-01-01T00:00:00.000Z"}
+\`\`\`
+
+**Features:**
+- Machine-parseable
+- Structured data
+- Log aggregation friendly
+
+### JSONL Formatter
+
+\`\`\`
+{"level":"info",...}
+{"level":"error",...}
+{"level":"warn",...}
+\`\`\`
+
+**Features:**
+- One JSON per line
+- Easy streaming
+- Efficient storage
+
+## Transport Configuration
+
+### Console Sink
+
+\`\`\`ts
+import { consoleSinkPlugin } from '@vibesdotdev/logging';
+
+await runtime.registerPlugin(consoleSinkPlugin({
+  stderrThreshold: 'warn',  // warn/error to stderr
+  colors: true,              // ANSI colors
+  timestamp: true            // Include timestamps
+}));
+\`\`\`
+
+### File Output
+
+\`\`\`ts
+import { fileOutputPlugin } from '@vibesdotdev/logging';
+
+await runtime.registerPlugin(fileOutputPlugin({
+  path: './logs/app.log',
+  format: 'jsonl',
+  rotation: {
+    strategy: 'size',
+    maxSize: '10MB',
+    maxFiles: 5,
+    compress: true
+  },
+  schedule: {
+    type: 'daily',
+    time: '00:00'  // Rotate at midnight
+  }
+}));
+\`\`\`
+
+### Remote Output
+
+\`\`\`ts
+import { remoteOutputPlugin } from '@vibesdotdev/logging';
+
+await runtime.registerPlugin(remoteOutputPlugin({
+  endpoint: 'https://logs.vibes.dev/ingest',
+  method: 'POST',
+  headers: {
+    'Authorization': \`Bearer \${process.env.LOGS_API_KEY}\`,
+    'Content-Type': 'application/json'
+  },
+  batch: {
+    maxSize: 100,
+    maxWait: 5_000
+  },
+  retry: {
+    maxAttempts: 3,
+    backoff: 'exponential',
+    initialDelay: 1_000
+  },
+  compression: 'gzip'
+}));
+\`\`\`
+
+## Transport Lifecycle
+
+### Initialization
+
+\`\`\`ts
+const transport = await runtime.query('logging/sink')
+  .filter(d => d.id === 'console')
+  .resolve();
+
+await transport.ensureReady();
+\`\`\`
+
+### Flushing
+
+\`\`\`ts
+// Flush buffered logs
+await transport.flush();
+
+// Or auto-flush on interval
+await runtime.registerPlugin(bufferSinkPlugin({
+  flushInterval: 60_000  // 1 minute
+}));
+\`\`\`
+
+### Cleanup
+
+\`\`\`ts
+// Close transport and release resources
+await transport.close();
+\`\`\`
+
+## Transport Resolution
+
+### Query by ID
+
+\`\`\`ts
+const consoleSink = await runtime.query('logging/sink')
+  .filter(d => d.id === 'console')
+  .resolve();
+\`\`\`
+
+### Query by Hardware
+
+\`\`\`ts
+const sink = await runtime.query('logging/sink')
+  .forHardware('consumer')
+  .resolve();
+\`\`\`
+
+### List All Transports
+
+\`\`\`ts
+const sinks = runtime.query('logging/sink').descriptors();
+const outputs = runtime.query('logging/output').descriptors();
+
+console.log('Available sinks:', sinks.map(s => s.id));
+console.log('Available outputs:', outputs.map(o => o.id));
+\`\`\`
+
+## Custom Transport
+
+\`\`\`ts
+import { createRuntimePlugin } from '@vibesdotdev/runtime';
+import type { SinkImplementation } from '@vibesdotdev/logging';
+
+class CustomSink implements SinkImplementation {
+  constructor(private config: CustomConfig) {}
+  
+  emit(entry: LogEntry): void {
+    // Custom transport logic
+    console.log('Custom:', entry);
+  }
+  
+  async flush(): Promise<void> {
+    // Flush buffered entries
+  }
+  
+  async close(): Promise<void> {
+    // Cleanup resources
+  }
+}
+
+const descriptor: SinkDescriptor = {
+  kind: 'logging/sink',
+  id: 'logging.sink.custom',
+  title: 'Custom Sink'
+};
+
+export const customSinkPlugin = createRuntimePlugin({
+  id: 'custom-sink',
+  kinds: [{
+    id: 'logging/sink',
+    descriptorSchema: SinkDescriptorSchema,
+    defaultImplementation: CustomSink
+  }],
+  descriptors: [descriptor]
+});
+\`\`\`
+
+## Transport Best Practices
+
+1. **Use appropriate transports** — Console for dev, file/remote for prod
+2. **Configure rotation** — Prevent disk exhaustion
+3. **Batch remote sends** — Reduce network overhead
+4. **Handle failures gracefully** — Don't crash on log failures
+5. **Sanitize sensitive data** — Remove PII before sending
+6. **Monitor transport health** — Alert on delivery failures
+
+:::card{title="See also"}
+- [\`logging.levels\`](logging.levels) — Log levels
+- [\`logging.structured\`](logging.structured) — Structured logging
+- [\`config.environment\`](config.environment) — Environment configuration
+:::
+`
+    },
+    parent: 'logging',
+    order: 2,
+    tags: ['logging', 'transports', 'console', 'file', 'remote', 'outputs'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=transports.docs.descriptor.js.map

package/dist/docs/transports.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transports.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/transports.docs.descriptor.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAwB;IACvC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,oBAAoB;IACxB,KAAK,EAAE,oBAAoB;IAC3B,OAAO,EAAE,8DAA8D;IACvE,IAAI,EAAE;QACL,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuZT;KACC;IACD,MAAM,EAAE,SAAS;IACjB,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC;IACvE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,IAAI;CACb,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/formatters/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Logging Formatters
+ *
+ * Descriptors and implementations are autoloaded by the runtime.
+ * No public types to export — formatter interfaces live in kinds/formatter.
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formatters/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/formatters/index.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Logging Formatters
+ *
+ * Descriptors and implementations are autoloaded by the runtime.
+ * No public types to export — formatter interfaces live in kinds/formatter.
+ */
+//# sourceMappingURL=index.js.map

package/dist/formatters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/formatters/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG"}

package/dist/formatters/json/json.formatters.descriptor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * JSON Formatter Descriptor
+ *
+ * Formats log entries as pretty-printed JSON.
+ */
+import type { FormatterDescriptor } from '../../schemas/formatter.ts';
+export declare const jsonFormatterDescriptor: FormatterDescriptor;
+export default jsonFormatterDescriptor;
+//# sourceMappingURL=json.formatters.descriptor.d.ts.map

package/dist/formatters/json/json.formatters.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.formatters.descriptor.d.ts","sourceRoot":"","sources":["../../../src/formatters/json/json.formatters.descriptor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,eAAO,MAAM,uBAAuB,EAAE,mBAcrC,CAAC;AAEF,eAAe,uBAAuB,CAAC"}

package/dist/formatters/json/json.formatters.descriptor.js

@@ -0,0 +1,22 @@
+/**
+ * JSON Formatter Descriptor
+ *
+ * Formats log entries as pretty-printed JSON.
+ */
+export const jsonFormatterDescriptor = {
+    kind: 'logging/formatter',
+    id: 'json',
+    name: 'JSON Formatter',
+    description: 'Formats log entries as indented JSON',
+    tags: ['readable', 'debug'],
+    format: 'json',
+    options: {
+        indent: 2,
+        includeTimestamp: true,
+        includeNamespace: true,
+        includeLevel: true,
+        colors: false
+    }
+};
+export default jsonFormatterDescriptor;
+//# sourceMappingURL=json.formatters.descriptor.js.map

package/dist/formatters/json/json.formatters.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.formatters.descriptor.js","sourceRoot":"","sources":["../../../src/formatters/json/json.formatters.descriptor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,CAAC,MAAM,uBAAuB,GAAwB;IAC3D,IAAI,EAAE,mBAAmB;IACzB,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,gBAAgB;IACtB,WAAW,EAAE,sCAAsC;IACnD,IAAI,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC3B,MAAM,EAAE,MAAM;IACd,OAAO,EAAE;QACR,MAAM,EAAE,CAAC;QACT,gBAAgB,EAAE,IAAI;QACtB,gBAAgB,EAAE,IAAI;QACtB,YAAY,EAAE,IAAI;QAClB,MAAM,EAAE,KAAK;KACb;CACD,CAAC;AAEF,eAAe,uBAAuB,CAAC"}

package/dist/formatters/json/json.impl.d.ts

@@ -0,0 +1,22 @@
+/**
+ * JSON Formatter Implementation
+ *
+ * Pretty-printed JSON with configurable indentation.
+ */
+import type { FormatterImplementation, FormatterContext } from '../../kinds/formatter.ts';
+import type { FormatterDescriptor } from '../../schemas/formatter.ts';
+import type { RuntimeLogEntry } from '../../schemas/entry.ts';
+/**
+ * JSON formatter - indented JSON for readability.
+ */
+export default class JsonFormatter implements FormatterImplementation {
+    readonly id: string;
+    readonly descriptor: FormatterDescriptor;
+    private readonly indent;
+    constructor(descriptor: FormatterDescriptor, _context: FormatterContext);
+    format(entry: RuntimeLogEntry): string;
+    parse(formatted: string): RuntimeLogEntry;
+    formatBatch(entries: RuntimeLogEntry[]): string;
+    parseBatch(formatted: string): RuntimeLogEntry[];
+}
+//# sourceMappingURL=json.impl.d.ts.map

package/dist/formatters/json/json.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.impl.d.ts","sourceRoot":"","sources":["../../../src/formatters/json/json.impl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC1F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,YAAW,uBAAuB;IACpE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,UAAU,EAAE,mBAAmB,EAAE,QAAQ,EAAE,gBAAgB;IAMvE,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM;IAItC,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe;IAIzC,WAAW,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM;IAI/C,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE;CAIhD"}

package/dist/formatters/json/json.impl.js

@@ -0,0 +1,32 @@
+/**
+ * JSON Formatter Implementation
+ *
+ * Pretty-printed JSON with configurable indentation.
+ */
+/**
+ * JSON formatter - indented JSON for readability.
+ */
+export default class JsonFormatter {
+    id;
+    descriptor;
+    indent;
+    constructor(descriptor, _context) {
+        this.id = descriptor.id;
+        this.descriptor = descriptor;
+        this.indent = descriptor.options?.indent ?? 2;
+    }
+    format(entry) {
+        return JSON.stringify(entry, null, this.indent);
+    }
+    parse(formatted) {
+        return JSON.parse(formatted);
+    }
+    formatBatch(entries) {
+        return JSON.stringify(entries, null, this.indent);
+    }
+    parseBatch(formatted) {
+        const parsed = JSON.parse(formatted);
+        return Array.isArray(parsed) ? parsed : [parsed];
+    }
+}
+//# sourceMappingURL=json.impl.js.map

package/dist/formatters/json/json.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.impl.js","sourceRoot":"","sources":["../../../src/formatters/json/json.impl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAa;IACxB,EAAE,CAAS;IACX,UAAU,CAAsB;IACxB,MAAM,CAAS;IAEhC,YAAY,UAA+B,EAAE,QAA0B;QACtE,IAAI,CAAC,EAAE,GAAG,UAAU,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,KAAsB;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IAED,KAAK,CAAC,SAAiB;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAoB,CAAC;IACjD,CAAC;IAED,WAAW,CAAC,OAA0B;QACrC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;IAED,UAAU,CAAC,SAAiB;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACrC,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC;CACD"}

package/dist/formatters/json5/json5.descriptor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * JSON5 Formatter Descriptor
+ *
+ * Formats log entries as JSON5 (human-readable JSON with comments).
+ */
+import type { FormatterDescriptor } from '../../schemas/formatter.ts';
+export declare const json5FormatterDescriptor: FormatterDescriptor;
+export default json5FormatterDescriptor;
+//# sourceMappingURL=json5.descriptor.d.ts.map

package/dist/formatters/json5/json5.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json5.descriptor.d.ts","sourceRoot":"","sources":["../../../src/formatters/json5/json5.descriptor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,eAAO,MAAM,wBAAwB,EAAE,mBActC,CAAC;AAEF,eAAe,wBAAwB,CAAC"}

package/dist/formatters/json5/json5.descriptor.js

@@ -0,0 +1,22 @@
+/**
+ * JSON5 Formatter Descriptor
+ *
+ * Formats log entries as JSON5 (human-readable JSON with comments).
+ */
+export const json5FormatterDescriptor = {
+    kind: 'logging/formatter',
+    id: 'json5',
+    name: 'JSON5 Formatter',
+    description: 'Formats log entries as JSON5 for human readability',
+    tags: ['readable', 'config'],
+    format: 'json5',
+    options: {
+        indent: 2,
+        includeTimestamp: true,
+        includeNamespace: true,
+        includeLevel: true,
+        colors: false
+    }
+};
+export default json5FormatterDescriptor;
+//# sourceMappingURL=json5.descriptor.js.map

package/dist/formatters/json5/json5.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json5.descriptor.js","sourceRoot":"","sources":["../../../src/formatters/json5/json5.descriptor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,CAAC,MAAM,wBAAwB,GAAwB;IAC5D,IAAI,EAAE,mBAAmB;IACzB,EAAE,EAAE,OAAO;IACX,IAAI,EAAE,iBAAiB;IACvB,WAAW,EAAE,oDAAoD;IACjE,IAAI,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;IAC5B,MAAM,EAAE,OAAO;IACf,OAAO,EAAE;QACR,MAAM,EAAE,CAAC;QACT,gBAAgB,EAAE,IAAI;QACtB,gBAAgB,EAAE,IAAI;QACtB,YAAY,EAAE,IAAI;QAClB,MAAM,EAAE,KAAK;KACb;CACD,CAAC;AAEF,eAAe,wBAAwB,CAAC"}

package/dist/formatters/json5/json5.impl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * JSON5 Formatter Implementation
+ *
+ * Uses JSON5 for human-readable output with comments support.
+ * Note: For serialization, we use standard JSON since JSON5 is a superset.
+ */
+import type { FormatterImplementation, FormatterContext } from '../../kinds/formatter.ts';
+import type { FormatterDescriptor } from '../../schemas/formatter.ts';
+import type { RuntimeLogEntry } from '../../schemas/entry.ts';
+/**
+ * JSON5 formatter - human-readable JSON.
+ */
+export default class Json5Formatter implements FormatterImplementation {
+    readonly id: string;
+    readonly descriptor: FormatterDescriptor;
+    private readonly indent;
+    constructor(descriptor: FormatterDescriptor, _context: FormatterContext);
+    format(entry: RuntimeLogEntry): string;
+    parse(formatted: string): RuntimeLogEntry;
+    formatBatch(entries: RuntimeLogEntry[]): string;
+    parseBatch(formatted: string): RuntimeLogEntry[];
+}
+//# sourceMappingURL=json5.impl.d.ts.map

package/dist/formatters/json5/json5.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json5.impl.d.ts","sourceRoot":"","sources":["../../../src/formatters/json5/json5.impl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC1F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,YAAW,uBAAuB;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,UAAU,EAAE,mBAAmB,EAAE,QAAQ,EAAE,gBAAgB;IAMvE,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM;IAItC,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe;IAIzC,WAAW,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM;IAI/C,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE;CAIhD"}

package/dist/formatters/json5/json5.impl.js

@@ -0,0 +1,34 @@
+/**
+ * JSON5 Formatter Implementation
+ *
+ * Uses JSON5 for human-readable output with comments support.
+ * Note: For serialization, we use standard JSON since JSON5 is a superset.
+ */
+import JSON5 from 'json5';
+/**
+ * JSON5 formatter - human-readable JSON.
+ */
+export default class Json5Formatter {
+    id;
+    descriptor;
+    indent;
+    constructor(descriptor, _context) {
+        this.id = descriptor.id;
+        this.descriptor = descriptor;
+        this.indent = descriptor.options?.indent ?? 2;
+    }
+    format(entry) {
+        return JSON5.stringify(entry, null, this.indent);
+    }
+    parse(formatted) {
+        return JSON5.parse(formatted);
+    }
+    formatBatch(entries) {
+        return JSON5.stringify(entries, null, this.indent);
+    }
+    parseBatch(formatted) {
+        const parsed = JSON5.parse(formatted);
+        return Array.isArray(parsed) ? parsed : [parsed];
+    }
+}
+//# sourceMappingURL=json5.impl.js.map

package/dist/formatters/json5/json5.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json5.impl.js","sourceRoot":"","sources":["../../../src/formatters/json5/json5.impl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;IACzB,EAAE,CAAS;IACX,UAAU,CAAsB;IACxB,MAAM,CAAS;IAEhC,YAAY,UAA+B,EAAE,QAA0B;QACtE,IAAI,CAAC,EAAE,GAAG,UAAU,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,KAAsB;QAC5B,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC;IAED,KAAK,CAAC,SAAiB;QACtB,OAAO,KAAK,CAAC,KAAK,CAAC,SAAS,CAAoB,CAAC;IAClD,CAAC;IAED,WAAW,CAAC,OAA0B;QACrC,OAAO,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACpD,CAAC;IAED,UAAU,CAAC,SAAiB;QAC3B,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACtC,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC;CACD"}

package/dist/formatters/jsonl/jsonl.descriptor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * JSONL Formatter Descriptor
+ *
+ * Formats log entries as newline-delimited JSON.
+ * Default formatter for file outputs.
+ */
+import type { FormatterDescriptor } from '../../schemas/formatter.ts';
+export declare const jsonlFormatterDescriptor: FormatterDescriptor;
+export default jsonlFormatterDescriptor;
+//# sourceMappingURL=jsonl.descriptor.d.ts.map

package/dist/formatters/jsonl/jsonl.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl.descriptor.d.ts","sourceRoot":"","sources":["../../../src/formatters/jsonl/jsonl.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,eAAO,MAAM,wBAAwB,EAAE,mBActC,CAAC;AAEF,eAAe,wBAAwB,CAAC"}