agent-first-data 0.12.2 → 0.13.0

package/README.md

@@ -1,578 +1,46 @@
-# agent-first-data
-
-**Agent-First Data (AFDATA)** — Suffix-driven output formatting and protocol templates for AI agents.
-
-The field name is the schema. Agents read `latency_ms` and know milliseconds, `api_key_secret` and know to redact, no external schema needed.
-
-## Installation
+# Agent-First Data for TypeScript
 
 ```bash
 npm install agent-first-data
 ```
 
-## Quick Example
-
-A backup tool invoked from the CLI — flags, env vars, and config all use the same suffixes:
-
-```bash
-API_KEY_SECRET=sk-1234 cloudback --timeout-s 30 --max-file-size-bytes 10737418240 /data/backup.tar.gz
-```
-
-For CLI diagnostics, enable log categories explicitly:
-
-```bash
---log startup,request,progress,retry,redirect
---verbose   # shorthand for all categories
-```
-
-Without these flags, startup diagnostics should stay off by default.
-
-The tool reads env vars, flags, and config — all with AFDATA suffixes — and can emit a startup diagnostic event:
-
 ```typescript
-import { buildJson, outputJson, outputYaml, outputPlain } from "agent-first-data";
+import { outputJson, outputPlain } from "agent-first-data";
 
-const startup = buildJson(
-  "log",
-  {
-    event: "startup",
-    config: { timeout_s: 30, max_file_size_bytes: 10737418240 },
-    args: { input_path: "/data/backup.tar.gz" },
-    env: { API_KEY_SECRET: process.env.API_KEY_SECRET ?? null },
+const value = {
+  code: "ok",
+  result: {
+    api_key_secret: "sk-123",
+    latency_ms: 1280,
+    db_url: "postgres://user:p@ss@db/app?token_secret=abc",
   },
-);
-```
-
-Three output formats, same data:
-
-```
-JSON:  {"code":"log","event":"startup","args":{"input_path":"/data/backup.tar.gz"},"config":{"max_file_size_bytes":10737418240,"timeout_s":30},"env":{"API_KEY_SECRET":"***"}}
-YAML:  code: "log"
-       event: "startup"
-       args:
-         input_path: "/data/backup.tar.gz"
-       config:
-         max_file_size: "10.0GB"
-         timeout: "30s"
-       env:
-         API_KEY: "***"
-Plain: args.input_path=/data/backup.tar.gz code=log event=startup config.max_file_size=10.0GB config.timeout=30s env.API_KEY=***
-```
-
-`--timeout-s` → `timeout_s` → `timeout: 30s`. `API_KEY_SECRET` → `API_KEY: "***"`. The suffix is the schema.
-
-## API Reference
-
-Public APIs are grouped by role: protocol builders, redaction helpers, output formatters, internal redaction tools, utility/CLI helpers, types, and AFDATA logging integration.
-
-### Protocol Builders (returns JsonValue)
-
-Build AFDATA protocol structures. Return JSON-serializable objects for transport payloads.
-
-```typescript
-type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
-
-// Success (result)
-buildJsonOk(result: JsonValue, trace?: JsonValue): JsonValue
-
-// Error (simple message, optional hint)
-buildJsonError(message: string, hint?: string, trace?: JsonValue): JsonValue
-
-// Generic (any code + fields)
-buildJson(code: string, fields: JsonValue, trace?: JsonValue): JsonValue
-```
-
-### Redaction Helpers (returns JsonValue)
-
-Use these before raw HTTP/MCP/SSE serializers that do not call `outputJson`.
-
-```typescript
-redactedValue(value: unknown): JsonValue
-redactedValueWith(value: unknown, redactionPolicy: RedactionPolicy): JsonValue
-redactedValueWithOptions(value: unknown, redactionOptions: RedactionOptions): JsonValue
-```
-
-`_url` fields are scrubbed in place during redaction (userinfo password, plus query parameters whose name follows the `_secret`/`secretNames` rule). For a URL inside a free-form string, redact it directly before interpolating:
-
-```typescript
-redactUrlSecrets(url: string): string
-redactUrlSecretsWithOptions(url: string, redactionOptions: RedactionOptions): string
-```
-
-**Use case:** structured protocol payloads (frameworks automatically serialize)
-
-**Example:**
-```typescript
-import { buildJsonOk, buildJsonError, buildJson } from "agent-first-data";
-
-// Startup
-const startup = buildJson(
-  "log",
-  {
-    event: "startup",
-    config: { api_key_secret: "sk-123", timeout_s: 30 },
-    args: { config_path: "config.yml" },
-    env: { RUST_LOG: "info" },
-  },
-);
-
-// Success (always include trace)
-const response = buildJsonOk(
-  { user_id: 123 },
-  { duration_ms: 150, source: "db" },
-);
-
-// Error
-const error = buildJsonError("user not found", undefined, { duration_ms: 5 });
-
-// Error with hint
-const errorHint = buildJsonError("wallet not found", "list wallets with: afpay wallet list", { duration_ms: 5 });
-
-// Specific error code
-const notFound = buildJson(
-  "not_found",
-  { resource: "user", id: 123 },
-  { duration_ms: 8 },
-);
-```
-
-### Output Formatters (returns string)
-
-Format values for CLI output and logs. `outputJson` uses full `_secret` redaction by default. `outputJsonWith` supports explicit scoped policies. Use `OutputOptions` to pass legacy secret names such as `api_key` or request schema-preserving YAML/plain rendering with `OutputStyle.Raw`.
-
-```typescript
-outputJson(value: JsonValue): string   // Single-line JSON, original keys, for programs/logs
-outputJsonWith(value: JsonValue, redactionPolicy: RedactionPolicy): string
-outputJsonWithOptions(value: JsonValue, outputOptions: OutputOptions): string
-outputYaml(value: JsonValue): string   // Multi-line YAML, keys stripped, values formatted
-outputYamlWithOptions(value: JsonValue, outputOptions: OutputOptions): string
-outputPlain(value: JsonValue): string  // Single-line logfmt, keys stripped, values formatted
-outputPlainWithOptions(value: JsonValue, outputOptions: OutputOptions): string
-```
-
-```typescript
-enum RedactionPolicy {
-  RedactionTraceOnly = "RedactionTraceOnly",
-  RedactionNone = "RedactionNone",
-  RedactionStrict = "RedactionStrict",
-}
-
-type RedactionOptions = {
-  policy?: RedactionPolicy;
-  secretNames?: readonly string[]; // legacy names like "api_key" or "authorization"
-}
-
-enum OutputStyle {
-  Readable = "Readable",
-  Raw = "Raw",
-}
-
-type OutputOptions = {
-  redaction?: RedactionOptions;
-  style?: OutputStyle;
-}
-```
-
-Secret names match exact field names at any nesting level; there is no trim, case folding, hyphen/underscore normalization, glob, regex, or substring matching. `OutputOptions` combines `RedactionOptions` with `OutputStyle.Readable` (default suffix stripping and value formatting) or `OutputStyle.Raw` (no suffix stripping or value formatting).
-
-**Example:**
-```typescript
-import { outputJson, outputYaml, outputPlain } from "agent-first-data";
-
-const data = {
-  user_id: 123,
-  api_key_secret: "sk-1234567890abcdef",
-  created_at_epoch_ms: 1738886400000,
-  file_size_bytes: 5242880,
 };
 
-// JSON (secrets redacted, original keys, raw values)
-console.log(outputJson(data));
-// {"api_key_secret":"***","created_at_epoch_ms":1738886400000,"file_size_bytes":5242880,"user_id":123}
-
-// YAML (keys stripped, values formatted, secrets redacted)
-console.log(outputYaml(data));
-// ---
-// api_key: "***"
-// created_at: "2025-02-07T00:00:00.000Z"
-// file_size: "5.0MB"
-// user_id: 123
-
-// Plain logfmt (keys stripped, values formatted, secrets redacted)
-console.log(outputPlain(data));
-// api_key=*** created_at=2025-02-07T00:00:00.000Z file_size=5.0MB user_id=123
+console.log(outputJson(value));
+console.log(outputPlain(value));
 ```
 
-### Internal Tools
+Useful names use TypeScript casing: `outputJson`, `outputYaml`, `outputPlain`, `outputJsonWithOptions`, `redactedValue`, `redactSecretsInPlace`, `redactUrlSecrets`, `parseSize`, `normalizeUtcOffset`, `cliParseOutput`, `cliOutput`, and `buildCliError`.
 
-```typescript
-internalRedactSecrets(value: JsonValue): void  // Manually redact secrets in-place
-internalRedactSecretsWithOptions(value: JsonValue, redactionOptions: RedactionOptions): void
-```
-
-Most users don't need this. Output functions automatically protect secrets.
-
-### Utility Functions
-
-```typescript
-parseSize(s: string): number | null  // Parse "10M" → bytes
-```
-
-Returns `null` for invalid, negative, overflow, or non-safe-integer values.
-
-**Example:**
-```typescript
-import { parseSize } from "agent-first-data";
-
-parseSize("10M");  // 10485760
-parseSize("1.5K"); // 1536
-parseSize("512");  // 512
-```
-
-### CLI Helpers (for tools built on AFDATA)
-
-Shared helpers that prevent flag-parsing drift between CLI tools. Use these instead of reimplementing `--output` and `--log` handling in each tool.
-
-Help scope and format are orthogonal: `--recursive` decides one-level vs
-recursive, `--output` decides plain/json/yaml/markdown. Human-facing CLIs use
-one-level `--help` (and scoped `sub --help`); agent/doc flows use
-`--help --recursive`, adding `--output json|yaml|markdown` for a recursive
-export. A bare `--recursive` without `--help` is ignored by the help layer.
-See `examples/agent_cli.ts` for that pattern.
+Logging is available through `initJson`, `initPlain`, `initYaml`, `span`, and `log`.
 
 ```typescript
-type OutputFormat = "json" | "yaml" | "plain"
+import { initJson } from "agent-first-data";
 
-cliParseOutput(s: string): OutputFormat             // Parse --output flag; throws on unknown
-cliParseLogFilters(entries: string[]): string[]     // Normalize --log: trim, lowercase, dedup, remove empty
-cliOutput(value: JsonValue, format: OutputFormat): string  // Dispatch to outputJson/Yaml/Plain
-cliOutputWithOptions(value: JsonValue, format: OutputFormat, outputOptions: OutputOptions): string
-buildCliError(message: string, hint?: string): JsonValue  // {code:"error", error_code:"invalid_request", hint?, retryable:false, trace:{duration_ms:0}}
+initJson({ secretNames: ["authorization"] });
 ```
 
-**Canonical pattern** — parse all flags before doing work, emit JSONL errors to stdout:
-
-```typescript
-import {
-  type OutputFormat, cliParseOutput, cliParseLogFilters,
-  cliOutput, buildCliError, outputJson,
-} from "agent-first-data";
-
-let fmt: OutputFormat;
-try {
-  fmt = cliParseOutput(outputArg);
-} catch (e) {
-  console.log(outputJson(buildCliError((e as Error).message)));
-  process.exit(2);
-}
+## Behavior Notes
 
-const log = cliParseLogFilters(logArg ? logArg.split(",") : []);
-// ... do work ...
-console.log(cliOutput(result, fmt));
-```
-
-See `examples/agent_cli.ts` for the complete working example (`npx tsx --test examples/agent_cli.ts`).
-
-### Skill Admin (for spore CLIs that ship an Agent Skill)
-
-`runSkillAdmin` installs, uninstalls, and reports status of a spore's embedded `SKILL.md` across Codex, Claude Code, and opencode. Describe the skill once with a `SkillSpec`, then call it per action. It returns a typed `SkillReport` discriminated union (narrow on `code` to read fields, or serialize with `cliOutput`) or throws `SkillError`; it never writes to stdout/stderr. The generated `SKILL.md` is byte-identical to the Rust, Go, and Python ports.
-
-```typescript
-runSkillAdmin(spec: SkillSpec, action: SkillAction, options: SkillOptions): SkillReport
-
-const spec: SkillSpec = { name: "agent-first-widget", source: skillMarkdown, title: "Agent-First Widget", markerSlug: "afwidget" };
-const options: SkillOptions = { agent: "all", scope: "personal" };
-
-try {
-  const report = runSkillAdmin(spec, "install", options);
-  console.log(cliOutput(report as unknown as JsonValue, fmt));
-} catch (e) {
-  if (e instanceof SkillError) {
-    console.log(cliOutput(buildCliError(e.message, e.hint), fmt));
-    process.exit(1);
-  }
-  throw e;
-}
-```
-
-`status` reports `installed` / `valid` / `managed` / `current` per target; `current` is true only when the installed content matches the bundle, so re-running `install` refreshes a stale copy. See `examples/agent_cli.ts` for the `skill` subcommand wiring.
-
-## Usage Examples
-
-### Example 1: REST API
-
-```typescript
-import { buildJsonOk } from "agent-first-data";
-import express from "express";
-
-const app = express();
-
-app.get("/users/:id", (req, res) => {
-  const response = buildJsonOk(
-    { user_id: Number(req.params.id), name: "alice" },
-    { duration_ms: 150, source: "db" },
-  );
-  // API returns raw JSON — no output processing, no key stripping
-  res.json(response);
-});
-```
-
-### Example 2: CLI Tool (Complete Lifecycle)
-
-```typescript
-import { buildJsonOk, buildJson, outputYaml, outputPlain } from "agent-first-data";
-
-// 1. Startup
-const startup = buildJson(
-  "log",
-  {
-    event: "startup",
-    config: { api_key_secret: "sk-sensitive-key", timeout_s: 30 },
-    args: { input_path: "data.json" },
-    env: { RUST_LOG: "info" },
-  },
-);
-console.log(outputYaml(startup));
-// ---
-// code: "log"
-// event: "startup"
-// args:
-//   input_path: "data.json"
-// config:
-//   api_key: "***"
-//   timeout: "30s"
-// env:
-//   RUST_LOG: "info"
-
-// 2. Progress
-const progress = buildJson(
-  "progress",
-  { current: 3, total: 10, message: "processing" },
-  { duration_ms: 1500 },
-);
-console.log(outputPlain(progress));
-// code=progress current=3 message=processing total=10 trace.duration=1.5s
-
-// 3. Result
-const result = buildJsonOk(
-  {
-    records_processed: 10,
-    file_size_bytes: 5242880,
-    created_at_epoch_ms: 1738886400000,
-  },
-  { duration_ms: 3500, source: "file" },
-);
-console.log(outputYaml(result));
-// ---
-// code: "ok"
-// result:
-//   created_at: "2025-02-07T00:00:00.000Z"
-//   file_size: "5.0MB"
-//   records_processed: 10
-// trace:
-//   duration: "3.5s"
-//   source: "file"
-```
-
-### Example 3: JSONL Output
-
-```typescript
-import { buildJsonOk, outputJson } from "agent-first-data";
-
-const result = buildJsonOk(
-  { status: "success" },
-  { duration_ms: 250, api_key_secret: "sk-123" },
-);
-
-// Print JSONL to stdout (secrets redacted, one JSON object per line)
-// Channel policy: machine-readable protocol/log events must not use stderr.
-console.log(outputJson(result));
-// {"code":"ok","result":{"status":"success"},"trace":{"api_key_secret":"***","duration_ms":250}}
-```
-
-## Complete Suffix Example
-
-```typescript
-import { outputYaml, outputPlain } from "agent-first-data";
-
-const data = {
-  created_at_epoch_ms: 1738886400000,
-  request_timeout_ms: 5000,
-  cache_ttl_s: 3600,
-  file_size_bytes: 5242880,
-  payment_msats: 50000000,
-  price_usd_cents: 9999,
-  success_rate_percent: 95.5,
-  api_key_secret: "sk-1234567890abcdef",
-  user_name: "alice",
-  count: 42,
-};
-
-// YAML output (keys stripped, values formatted, secrets redacted)
-console.log(outputYaml(data));
-// ---
-// api_key: "***"
-// cache_ttl: "3600s"
-// count: 42
-// created_at: "2025-02-07T00:00:00.000Z"
-// file_size: "5.0MB"
-// payment: "50000000msats"
-// price: "$99.99"
-// request_timeout: "5.0s"
-// success_rate: "95.5%"
-// user_name: "alice"
-
-// Plain logfmt output (same transformations, single line)
-console.log(outputPlain(data));
-// api_key=*** cache_ttl=3600s count=42 created_at=2025-02-07T00:00:00.000Z file_size=5.0MB payment=50000000msats price=$99.99 request_timeout=5.0s success_rate=95.5% user_name=alice
-```
-
-## AFDATA Logging
-
-AFDATA-compliant structured logging. Every log line is formatted using the library's own `outputJson`/`outputPlain`/`outputYaml` functions. Span fields are carried via `AsyncLocalStorage` (async-safe), automatically flattened into each log line. Zero dependencies beyond Node.js built-ins.
-
-### API
-
-```typescript
-import { log, span, initJson, initPlain, initYaml } from "agent-first-data";
-
-// Format selectors — set the output format for all subsequent log calls
-initJson()    // Single-line JSONL (secrets redacted, original keys) — default
-initPlain()   // Single-line logfmt (keys stripped, values formatted)
-initYaml()    // Multi-line YAML (keys stripped, values formatted)
-
-// Logger — each method outputs a single log line to stdout
-log.trace(msg, fields?)
-log.debug(msg, fields?)
-log.info(msg, fields?)
-log.warn(msg, fields?)
-log.error(msg, fields?)
-
-// Span — run fn with additional fields on all log events
-span<T>(fields, fn: () => T): T  // works with sync and async functions
-```
-
-### Setup
-
-```typescript
-import { log, initJson, initPlain, initYaml } from "agent-first-data";
-
-// JSON output for production (one JSONL line per event, secrets redacted)
-initJson();  // default, can be omitted
-
-// Plain logfmt for development (keys stripped, values formatted)
-initPlain();
-
-// YAML for detailed inspection (multi-line, keys stripped, values formatted)
-initYaml();
-```
-
-### Log Output
-
-Output format depends on the init function used.
-
-```typescript
-log.info("Server started");
-// JSON:  {"timestamp_epoch_ms":1739000000000,"message":"Server started","code":"info"}
-// Plain: code=info message="Server started" timestamp_epoch_ms=1739000000000
-// YAML:  ---
-//        code: "info"
-//        message: "Server started"
-//        timestamp_epoch_ms: 1739000000000
-
-log.warn("DNS lookup failed", { error: "timeout", domain: "example.com" });
-// JSON:  {"timestamp_epoch_ms":...,"message":"DNS lookup failed","error":"timeout","domain":"example.com","code":"warn"}
-// Plain: code=warn domain=example.com error=timeout message="DNS lookup failed" ...
-```
-
-### Span Support
-
-Use `span()` to add fields to all log events within the callback. Spans nest and work with both sync and async functions.
-
-```typescript
-import { log, span } from "agent-first-data";
-
-await span({ request_id: "abc-123" }, async () => {
-  log.info("Processing");
-  // {"timestamp_epoch_ms":...,"message":"Processing","request_id":"abc-123","code":"info"}
-
-  await span({ step: "validate" }, async () => {
-    log.info("Validating input");
-    // {"timestamp_epoch_ms":...,"message":"Validating input","request_id":"abc-123","step":"validate","code":"info"}
-  });
-});
-```
-
-### Custom Code Override
-
-The `code` field defaults to the log level. Override with an explicit field:
-
-```typescript
-log.info("Server ready", { code: "log", event: "startup" });
-// {"timestamp_epoch_ms":...,"message":"Server ready","code":"log","event":"startup"}
-```
-
-### Output Fields
-
-Every log line contains:
-
-| Field | Type | Description |
-|:------|:-----|:------------|
-| `timestamp_epoch_ms` | number | Unix milliseconds |
-| `message` | string | Log message |
-| `code` | string | Level (trace/debug/info/warn/error) or explicit override |
-| *span fields* | any | From `span()` callback |
-| *event fields* | any | From fields argument |
-
-### Log Output Formats
-
-All three formats use the library's own output functions, so AFDATA suffix processing applies to log fields too:
-
-| Format | Function | Keys | Values | Use case |
-|:-------|:---------|:-----|:-------|:---------|
-| **JSON** | `initJson` | original (with suffix) | raw | production, log aggregation |
-| **Plain** | `initPlain` | stripped | formatted | development, compact scanning |
-| **YAML** | `initYaml` | stripped | formatted | debugging, detailed inspection |
-
-All formats automatically redact `_secret` fields in log output.
-
-## Output Formats
-
-Three output formats for different use cases:
-
-| Format | Structure | Keys | Values | Use case |
-|:-------|:----------|:-----|:-------|:---------|
-| **JSON** | single-line | original (with suffix) | raw | programs, logs |
-| **YAML** | multi-line | stripped | formatted | human inspection |
-| **Plain** | single-line logfmt | stripped | formatted | compact scanning |
-
-All formats automatically redact `_secret` fields.
-
-## Supported Suffixes
-
-- **Duration**: `_ms`, `_s`, `_ns`, `_us`, `_minutes`, `_hours`, `_days`
-- **Timestamps**: `_epoch_ms`, `_epoch_s`, `_epoch_ns`, `_rfc3339`
-- **Size**: `_bytes` (auto-scales to KB/MB/GB/TB), `_size` (config input, pass through)
-- **Currency**: `_msats`, `_sats`, `_btc`, `_usd_cents`, `_eur_cents`, `_jpy`, `_{code}_cents`
-- **Other**: `_percent`, `_secret` (auto-redacted in all formats)
-
-TypeScript uses JavaScript `number` for JSON values, so `_epoch_ns` values above `Number.MAX_SAFE_INTEGER` lose precision. Prefer `_epoch_ms` for JSON interchange, or convert nanosecond values before formatting.
-
-## Repository
-
-This package is part of the [agent-first-data](https://github.com/agentfirstkit/agent-first-data) repository, which also contains:
-
-- **`spec/`** — Full AFDATA specification with suffix definitions, protocol format rules, and cross-language test fixtures
-- **`skills/`** — AI coding agent skill for working with AFDATA conventions
-
-To run tests, clone the full repository (tests use shared cross-language fixtures from `spec/fixtures/`):
-
-```bash
-git clone https://github.com/agentfirstkit/agent-first-data
-cd agent-first-data/typescript
-npm test
-```
+- Default redaction replaces every `_secret` or configured secret-name subtree with `***`, including objects and arrays.
+- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed and internal whitespace redacts the whole field.
+- YAML/plain quote and escape keys as well as values, sort by UTF-16 code unit order, and render nested objects in arrays as canonical JSON.
+- Logging records use `code: "log"` plus a separate `level` field, so error-level logs are not terminal protocol errors.
+- `build_cli_error(message, hint?)` returns `{code:"error", error: message, hint?}` only.
 
-## License
+## Reference
 
-MIT
+- Full convention and API groups: [../docs/overview.md](../docs/overview.md)
+- Formal cross-language contract: [../spec/agent-first-data.md](../spec/agent-first-data.md)
+- Conformance fixtures: [../spec/fixtures](../spec/fixtures)
+- Agent skill: [../skills/agent-first-data.md](../skills/agent-first-data.md)

package/dist/afdata_logging.d.ts

@@ -16,12 +16,15 @@
  *     log.info("Processing", { domain: "example.com" });
  *   });
  */
+type LoggingRedactionOptions = {
+    secretNames?: readonly string[];
+};
 /** Set log output to single-line JSONL (secrets redacted, original keys). */
-export declare function initJson(): void;
+export declare function initJson(options?: LoggingRedactionOptions): void;
 /** Set log output to single-line logfmt (keys stripped, values formatted). */
-export declare function initPlain(): void;
+export declare function initPlain(options?: LoggingRedactionOptions): void;
 /** Set log output to multi-line YAML (keys stripped, values formatted). */
-export declare function initYaml(): void;
+export declare function initYaml(options?: LoggingRedactionOptions): void;
 /**
  * AFDATA logger. Each method outputs a single log line to stdout.
  * Format is controlled by initJson/initPlain/initYaml (default: JSON).
@@ -38,3 +41,4 @@ export declare const log: {
  * Spans nest: inner spans inherit and can override outer span fields.
  */
 export declare function span<T>(fields: Record<string, unknown>, fn: () => T): T;
+export {};

package/dist/afdata_logging.js

@@ -17,19 +17,26 @@
  *   });
  */
 import { AsyncLocalStorage } from "node:async_hooks";
-import { outputJson, outputYaml, outputPlain } from "./format.js";
+import { outputJsonWithOptions, outputYamlWithOptions, outputPlainWithOptions, } from "./format.js";
 const spanStore = new AsyncLocalStorage();
 let currentFormat = "json";
+let currentRedaction = {};
+function setFormat(format, options) {
+    currentFormat = format;
+    currentRedaction = options?.secretNames ? { secretNames: options.secretNames } : {};
+}
 /** Set log output to single-line JSONL (secrets redacted, original keys). */
-export function initJson() { currentFormat = "json"; }
+export function initJson(options) { setFormat("json", options); }
 /** Set log output to single-line logfmt (keys stripped, values formatted). */
-export function initPlain() { currentFormat = "plain"; }
+export function initPlain(options) { setFormat("plain", options); }
 /** Set log output to multi-line YAML (keys stripped, values formatted). */
-export function initYaml() { currentFormat = "yaml"; }
+export function initYaml(options) { setFormat("yaml", options); }
 function emit(level, message, fields) {
     const entry = {
         timestamp_epoch_ms: Date.now(),
         message,
+        code: "log",
+        level,
     };
     // Span fields (from AsyncLocalStorage)
     const spanFields = spanStore.getStore();
@@ -38,31 +45,26 @@ function emit(level, message, fields) {
             entry[k] = v;
         }
     }
-    // Event fields (override span fields on collision)
-    let hasCode = false;
+    // Event fields override span fields, except protocol code is always "log".
     if (fields) {
         for (const [k, v] of Object.entries(fields)) {
             if (k === "code")
-                hasCode = true;
+                continue;
             entry[k] = v;
         }
     }
-    // Default code from level
-    if (!hasCode) {
-        entry["code"] = level;
-    }
     // Format using the library's own output functions
     const value = entry;
     let line;
     switch (currentFormat) {
         case "plain":
-            line = outputPlain(value);
+            line = outputPlainWithOptions(value, { redaction: currentRedaction });
             break;
         case "yaml":
-            line = outputYaml(value);
+            line = outputYamlWithOptions(value, { redaction: currentRedaction });
             break;
         default:
-            line = outputJson(value);
+            line = outputJsonWithOptions(value, { redaction: currentRedaction });
             break;
     }
     process.stdout.write(line + "\n");