@vibesdotdev/logging 0.0.2 → 1.0.0-rc.4

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

@@ -18,398 +18,183 @@ 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.
+In the logging module a "transport" is one of two runtime kinds:
 
-## Transport Types
+- **Sinks** (\`logging/sink\`) — fire-and-forget destinations for individual entries (console, stdout, in-memory buffers).
+- **Outputs** (\`logging/output\`) — durable, named streams with rotation, buffering, read/tail/stats (file or remote HTTP).
 
-### Console Sink
+The \`loggingPlugin\` registers a fixed set of built-in sinks and outputs. You do **not** pass transport config into the plugin and there is no per-transport plugin factory. Instead you select transports by **ID** on a \`LoggerDescriptor\` (its \`sinks\` and \`outputs\` arrays), and the runtime resolves the matching implementation for the active hardware scope.
 
-Writes to stdout/stderr:
+## Registering the plugin
 
-\`\`\`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
+\`loggingPlugin\` is the default export and takes no arguments — it registers the kinds, descriptors, and lazy implementation loaders.
 
 \`\`\`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)
-\`\`\`
+import { bootstrapVibesRuntime } from '@vibesdotdev/kernel';
+import loggingPlugin from '@vibesdotdev/logging/plugin';
+import loggingConsumerPlugin from '@vibesdotdev/logging/consumer/plugin';
 
-### 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
+// \`environment\` is your host's environment plugin.
+const runtime = await bootstrapVibesRuntime({
+  environment,
+  composition: { kind: 'literal', plugins: [async () => loggingPlugin, async () => loggingConsumerPlugin] }
+});
 \`\`\`
 
-**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"}
+Terminal hosts compose the consumer slice for colorized console and pretty formatting.
+Browser and cloud hosts keep the universal plugin; its buffer and stdout sinks
+use only memory and runtime ports. Browser console stays universal; the optional
+browser plugin adds persistence. Scope filtering does not isolate static bundles.
+
+## Built-in sinks
+
+| ID | Description | Formats |
+| --- | --- | --- |
+| \`console\` | Colorized output to stderr (browser variant uses \`console.*\`) | \`pretty\`, \`jsonl\`, \`raw\` |
+| \`stdout\` | Plain output to stderr, safe for MCP stdio mode | \`raw\` |
+| \`buffer\` | In-memory retention with optional capacity refusal | \`raw\` |
+| \`memory\` | Queryable in-memory buffer for tests and debugging | \`raw\` |
+
+The \`buffer\` sink retains entries in order without an implicit limit. Its
+registered \`SinkDescriptor.capacity\` optionally sets a positive integer bound
+(zero, fractions and non-finite values are invalid). At capacity, \`emit\`
+refuses before mutation with \`CapabilityError\` code \`UNAVAILABLE\`, reason
+\`buffer-capacity-exceeded\`, retryable, without entry contents. The logger
+falls back to its host console and reports the failure. \`drain()\` returns
+accepted entries in order and empties storage; \`clear()\` also restores capacity.
+\`flush()\` keeps entries. \`close()\` and runtime disposal clear instance memory;
+use a durable output when entries must survive disposal.
+
+The \`memory\` sink retains all entries by default until clear, close or runtime
+disposal. Its registered \`SinkDescriptor.maxEntries\` accepts a finite
+nonnegative integer: zero disables retention, positive bounds deliberately
+evict oldest entries and preserve newest entries in emission order.
+\`setMaxEntries(number)\` changes the bound and trims immediately; invalid
+limits refuse \`INVALID_INPUT memory-entry-limit-invalid\`. This explicit
+eviction differs from buffer capacity refusal. \`flush()\` keeps entries.
+Queries filter by level, namespace, message and date and return independent array
+snapshots. A limit selects newest matches in emission order; zero selects none.
+Invalid queries refuse \`INVALID_INPUT memory-query-invalid\`.
+\`MemorySinkQueryOptions\` remains available through \`./sinks\`; its owning
+schemas and inferred types export through \`./schemas/sink\` and \`./schemas\`.
+
+A sink implements the \`SinkImplementation\` interface — only \`emit\` is required.
+It writes through the runtime it was handed (the host's \`runtime/stdio\`), never
+the global \`console\`:
+
+\`\`\`ts
+import { getRuntimeStdio, type RuntimeRef } from '@vibesdotdev/kernel';
+import type { RuntimeLogEntry, SinkImplementation } from '@vibesdotdev/logging';
+
+function createStderrSink(runtime: RuntimeRef): SinkImplementation {
+  return {
+    async emit(entry: RuntimeLogEntry): Promise<void> {
+      const stdio = await getRuntimeStdio(runtime);
+      stdio.write('stderr', \`[\${entry.level}] [\${entry.namespace}] \${entry.message}\\n\`);
+    },
+    // Optional:
+    async flush() {},
+    async close() {}
+  };
+}
 \`\`\`
 
-**Features:**
-- Machine-parseable
-- Structured data
-- Log aggregation friendly
+## Built-in outputs
 
-### JSONL Formatter
+Logging's one portable output is \`remote\` — it ships logs to a remote HTTP endpoint. It declares no hardware scope, so it selects on consumer and cloud hosts alike. File outputs (\`storage: 'file'\`) are implemented by the host's runtime environment (for example \`@vibesdotdev/host-node\`). Outputs are described by an \`OutputDescriptor\` whose \`storage\` is either \`'file'\` or \`'remote'\`:
 
-\`\`\`
-{"level":"info",...}
-{"level":"error",...}
-{"level":"warn",...}
-\`\`\`
-
-**Features:**
-- One JSON per line
-- Easy streaming
-- Efficient storage
-
-## Transport Configuration
+:::descriptor{kind="logging/output"}
+The \`remote\` descriptor uses \`storage: 'remote'\`, \`format: 'jsonl'\`, and buffering (\`size\`, \`flushInterval\`, \`maxBufferEntries\`).
+:::
 
-### Console Sink
+An \`OutputImplementation\` is richer than a sink — it supports batched writes, rotation, and reads:
 
 \`\`\`ts
-import { consoleSinkPlugin } from '@vibesdotdev/logging';
+import type { OutputImplementation } from '@vibesdotdev/logging';
 
-await runtime.registerPlugin(consoleSinkPlugin({
-  stderrThreshold: 'warn',  // warn/error to stderr
-  colors: true,              // ANSI colors
-  timestamp: true            // Include timestamps
-}));
+// Interface shape (implemented by the runtime-loaded output):
+//   readonly id: string
+//   write(entry): Promise<void>
+//   writeBatch?(entries): Promise<void>
+//   writeLine?(line): Promise<void>
+//   flush(): Promise<void>
+//   close(): Promise<void>
+//   rotate?(): Promise<{ archived: string | null }>   // null: nothing to rotate
+//   read(options?): Promise<string[]>
+//   tail(callback, options?): TailHandle
+//   stats(): Promise<OutputStats>
 \`\`\`
 
-### File Output
+## Selecting transports per logger
 
-\`\`\`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
+Transport selection lives on the \`LoggerDescriptor\`. Reference sinks and outputs by their IDs:
 
 \`\`\`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'
-}));
-\`\`\`
+import type { LoggerDescriptor } from '@vibesdotdev/logging';
 
-## Transport Lifecycle
-
-### Initialization
-
-\`\`\`ts
-const transport = await runtime.query('logging/sink')
-  .filter(d => d.id === 'console')
-  .resolve();
+const descriptor: LoggerDescriptor = {
+  kind: 'logging/logger',
+  id: 'myapp',
+  namespace: 'myapp',
+  runtime: 'server',
+  level: 'info',
+  sinks: ['console'],     // default is ['console']
+  outputs: ['remote']     // optional, for durable streams
+};
 
-await transport.ensureReady();
+export default descriptor;
 \`\`\`
 
-### Flushing
+Then resolve the logger by ID at runtime:
 
 \`\`\`ts
-// Flush buffered logs
-await transport.flush();
+import { getLogger } from '@vibesdotdev/logging';
 
-// Or auto-flush on interval
-await runtime.registerPlugin(bufferSinkPlugin({
-  flushInterval: 60_000  // 1 minute
-}));
+// runtime is the runtime your host booted and handed to this code.
+const logger = getLogger('myapp', runtime);
+logger.info('Application started', { version: '1.0.0' });
 \`\`\`
 
-### Cleanup
+Derive a child for a sub-namespace instead of resolving another id:
 
 \`\`\`ts
-// Close transport and release resources
-await transport.close();
+const dbLogger = logger.child({ namespace: 'database' });
+dbLogger.debug('Connected');
 \`\`\`
 
-## Transport Resolution
+## Hardware-aware resolution
 
-### Query by ID
+Both the \`logging/sink\` and \`logging/output\` kinds resolve candidates against the active \`scope.hardware\`. Descriptors with no \`hardware\` field match everywhere; descriptors that declare \`hardware\` are preferred when the hardware matches (\`remote\` declares none, so it matches everywhere). You select transports the same way on every target — the runtime picks the right implementation for consumer vs. cloud.
 
-\`\`\`ts
-const consoleSink = await runtime.query('logging/sink')
-  .filter(d => d.id === 'console')
-  .resolve();
-\`\`\`
+## Formats
 
-### Query by Hardware
+Sinks and outputs both use the shared \`SinkFormat\` enum:
 
-\`\`\`ts
-const sink = await runtime.query('logging/sink')
-  .forHardware('consumer')
-  .resolve();
-\`\`\`
-
-### List All Transports
+| Format | Notes |
+| --- | --- |
+| \`pretty\` | Human-readable, color-coded (console default) |
+| \`jsonl\` | One JSON object per line (output/file default) |
+| \`json\` | JSON object per entry |
+| \`json5\` | JSON5 variant |
+| \`raw\` | Unformatted |
 
-\`\`\`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));
-\`\`\`
+## Programmatic logger options
 
-## Custom Transport
+\`RuntimeLoggerOptions\` lets code construct a logger without a descriptor. It accepts \`sinks\` (IDs to resolve) or \`sinkImpls\` (direct implementations that bypass runtime resolution):
 
 \`\`\`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
-  }
-}
+import type { RuntimeLoggerOptions } from '@vibesdotdev/logging';
 
-const descriptor: SinkDescriptor = {
-  kind: 'logging/sink',
-  id: 'logging.sink.custom',
-  title: 'Custom Sink'
+const opts: RuntimeLoggerOptions = {
+  namespace: 'jobs',
+  runtime: 'worker',
+  level: 'debug',
+  sinks: ['stdout']
 };
-
-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.levels\`](logging.levels) — Log levels and filtering
 - [\`logging.structured\`](logging.structured) — Structured logging
 - [\`config.environment\`](config.environment) — Environment configuration
 :::

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMT;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/json/json.impl.d.ts

@@ -5,7 +5,7 @@
  */
 import type { FormatterImplementation, FormatterContext } from '../../kinds/formatter.ts';
 import type { FormatterDescriptor } from '../../schemas/formatter.ts';
-import type { RuntimeLogEntry } from '../../schemas/entry.ts';
+import { type RuntimeLogEntry } from '../../schemas/entry.ts';
 /**
  * JSON formatter - indented JSON for readability.
  */

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

@@ -1 +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"}
+{"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,EAAyB,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAErF;;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

@@ -3,6 +3,7 @@
  *
  * Pretty-printed JSON with configurable indentation.
  */
+import { RuntimeLogEntrySchema } from "../../schemas/entry.js";
 /**
  * JSON formatter - indented JSON for readability.
  */
@@ -19,14 +20,14 @@ export default class JsonFormatter {
         return JSON.stringify(entry, null, this.indent);
     }
     parse(formatted) {
-        return JSON.parse(formatted);
+        return RuntimeLogEntrySchema.parse(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];
+        return RuntimeLogEntrySchema.array().parse(Array.isArray(parsed) ? parsed : [parsed]);
     }
 }
 //# sourceMappingURL=json.impl.js.map

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

@@ -1 +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"}
+{"version":3,"file":"json.impl.js","sourceRoot":"","sources":["../../../src/formatters/json/json.impl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,qBAAqB,EAAwB,MAAM,wBAAwB,CAAC;AAErF;;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,qBAAqB,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAC3D,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,GAAY,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAC9C,OAAO,qBAAqB,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACvF,CAAC;CACD"}

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

@@ -6,7 +6,7 @@
  */
 import type { FormatterImplementation, FormatterContext } from '../../kinds/formatter.ts';
 import type { FormatterDescriptor } from '../../schemas/formatter.ts';
-import type { RuntimeLogEntry } from '../../schemas/entry.ts';
+import { type RuntimeLogEntry } from '../../schemas/entry.ts';
 /**
  * JSON5 formatter - human-readable JSON.
  */

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

@@ -1 +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"}
+{"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,EAAyB,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGrF;;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

@@ -4,6 +4,7 @@
  * Uses JSON5 for human-readable output with comments support.
  * Note: For serialization, we use standard JSON since JSON5 is a superset.
  */
+import { RuntimeLogEntrySchema } from "../../schemas/entry.js";
 import JSON5 from 'json5';
 /**
  * JSON5 formatter - human-readable JSON.
@@ -21,14 +22,14 @@ export default class Json5Formatter {
         return JSON5.stringify(entry, null, this.indent);
     }
     parse(formatted) {
-        return JSON5.parse(formatted);
+        return RuntimeLogEntrySchema.parse(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];
+        return RuntimeLogEntrySchema.array().parse(Array.isArray(parsed) ? parsed : [parsed]);
     }
 }
 //# sourceMappingURL=json5.impl.js.map

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

@@ -1 +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"}
+{"version":3,"file":"json5.impl.js","sourceRoot":"","sources":["../../../src/formatters/json5/json5.impl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,qBAAqB,EAAwB,MAAM,wBAAwB,CAAC;AACrF,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,qBAAqB,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAC5D,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,GAAY,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAC/C,OAAO,qBAAqB,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACvF,CAAC;CACD"}

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

@@ -5,7 +5,7 @@
  */
 import type { FormatterImplementation, FormatterContext } from '../../kinds/formatter.ts';
 import type { FormatterDescriptor } from '../../schemas/formatter.ts';
-import type { RuntimeLogEntry } from '../../schemas/entry.ts';
+import { type RuntimeLogEntry } from '../../schemas/entry.ts';
 /**
  * JSONL formatter - one JSON object per line.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"jsonl.impl.d.ts","sourceRoot":"","sources":["../../../src/formatters/jsonl/jsonl.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,cAAe,YAAW,uBAAuB;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;gBAE7B,UAAU,EAAE,mBAAmB,EAAE,QAAQ,EAAE,gBAAgB;IAKvE,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"}
+{"version":3,"file":"jsonl.impl.d.ts","sourceRoot":"","sources":["../../../src/formatters/jsonl/jsonl.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,EAAyB,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAErF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,YAAW,uBAAuB;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;gBAE7B,UAAU,EAAE,mBAAmB,EAAE,QAAQ,EAAE,gBAAgB;IAKvE,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"}