@graphorin/observability 0.5.0

package/dist/gen-ai/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/gen-ai/types.ts"],"sourcesContent":[],"mappings":";;;;AA2FA;AAqBA;;;;;AAamC,KA9GvB,WAAA,GA8GuB,WAAA,GAAA,QAAA,GAAA,QAAA,GAAA,SAAA,GAAA,QAAA,GAAA,YAAA,GAAA,oBAAA,GAAA,aAAA,GAAA,QAAA,GAAA,WAAA,GAAA,oBAAA,GAAA,6BAAA,GAAA,CAAA,MAAA,GAAA;EAavB,SAAA,aAAA,CAAA,EAAA,KAAuB;;;;;;;;KAtGvB,aAAA;;;;;;;KAcA,kBAAA;;;;;;KAkCA,gBAAA;;;;;;UAOK,YAAA;iBACA;;;uBAGM;;;;;;;;;;;;;;;;UAiBN,eAAA;oBACG;;;;;;2BAMO;uBACJ;;;;;sBAKD;;;;;;;;;;;;KAaV,uBAAA,UAAiC,aAAa"}

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import { CostBudgetExceededCallback, CostBudgets, CostRecordInput, CostScope, CostSnapshot, CostTrackerOptions } from "./cost/types.js";
+import { CostTracker, createCostTracker } from "./cost/cost-tracker.js";
+import { Case, Dataset, EvalCaseResult, EvalReport, RunEvalOptions, ScoreResult, Scorer } from "./eval/types.js";
+import { runEval } from "./eval/runner.js";
+import { SpanRecord, SpanRecordEvent, TraceExporter, VALIDATED_EXPORTER_BRAND } from "./exporters/types.js";
+import { ConsoleExporterOptions, createConsoleExporter } from "./exporters/console.js";
+import { JSONLExporterOptions, createJSONLExporter } from "./exporters/jsonl.js";
+import { OTLPHttpExporterOptions, createOTLPHttpExporter } from "./exporters/otlp-http.js";
+import { ALL_BUILT_IN_PATTERNS, BUILT_IN_PATTERNS, BuiltInPatternName, OPT_IN_PATTERNS, PatternCategory, RedactionPattern } from "./redaction/patterns.js";
+import { RedactionCounters, RedactionInput, RedactionOutput, RedactionValidator, RedactionValidatorInstance, RedactionValidatorOptions, RedactionViolation, RedactionViolationCallback } from "./redaction/types.js";
+import { WithValidationOptions, isValidatedExporter, tryGetValidatorCounters, withValidation } from "./exporters/with-validation.js";
+import { GenAIAttributes, GenAIMessage, GenAIMessageRole, GenAIOperationName, GenAISystem, GenAIToolType, SpanTypeToOperationName } from "./gen-ai/types.js";
+import { emitGenAIAttributes, emitGenAIMessageEvents } from "./gen-ai/emit.js";
+import { OPERATION_NAME_TABLE, operationNameFor } from "./gen-ai/operation-mapping.js";
+import { PROVIDER_CLASS_TO_GEN_AI_SYSTEM, _resetGenAISystemWarningsForTesting, deriveGenAISystem, setGenAISystemWarnSink } from "./gen-ai/system-derivation.js";
+import { LoggerFormat, LoggerOptions, createLogger, getCurrentSpanContext, withCurrentSpan } from "./logger/logger.js";
+import { OPEN_INFERENCE_EXCLUDED_TYPES, OPEN_INFERENCE_KIND_TABLE, OpenInferenceSpanKind, emitOpenInferenceKind, openInferenceKindFor } from "./openinference/index.js";
+import { DEFAULT_VALIDATION_CONFIG, ValidationConfig } from "./redaction/config.js";
+import { RedactionValidationError, UnvalidatedExporterError } from "./redaction/errors.js";
+import { BUILT_IN_IMPERATIVE_PATTERNS, IMPERATIVE_PREFILTER_SUBSTRINGS, ImperativePattern, ImperativePatternName, ScanResult, scanImperativePatterns, stripImperativePatterns } from "./redaction/imperative-patterns.js";
+import { compareSensitivityTiers, createRedactionValidator } from "./redaction/validator.js";
+import { DEFAULT_REPLAY_LOG_CONFIG, ReplayLogConfig } from "./replay/config.js";
+import { PruneTracesOptions, getTraceLog, pruneTraces } from "./replay/log.js";
+import { ReplayAuditBridge, ReplayAuditEvent, ReplayEvent, ReplayMode, ReplayOptions, ReplayRunInput } from "./replay/types.js";
+import { Replay, createReplay } from "./replay/replay.js";
+import { TelemetryStatus, announceTelemetryPosture, enableTelemetry, getTelemetryStatus } from "./telemetry/index.js";
+import { newSpanId, newTraceId } from "./tracer/ids.js";
+import { Sampler, SamplingDecisionMaker, SamplingOptions, SamplingRule, createSampler } from "./tracer/sampling.js";
+import { GraphorinSpan, SetAttributeOptions } from "./tracer/span.js";
+import { spanNameFor } from "./tracer/span-names.js";
+import { GraphorinTracer, TracerOptions, asGraphorinSpan, createTracer } from "./tracer/tracer.js";
+
+//#region src/index.d.ts
+/**
+ * @graphorin/observability — observability primitives for the
+ * Graphorin framework. Ships:
+ *
+ * - the typed `AISpan<T>` tracer over OpenTelemetry,
+ * - the **mandatory** `withValidation()` wrapper for every exporter,
+ * - the sensitivity-aware `RedactionValidator` with 14 built-in PII /
+ *   secret detection patterns,
+ * - OpenTelemetry GenAI semantic-conventions conformance helpers,
+ * - OpenInference span-kind emission,
+ * - the structured `Logger` with span correlation,
+ * - the append-only `JSONLExporter` for replay,
+ * - sanitized-by-default `Replay` primitives,
+ * - the hierarchical `CostTracker`,
+ * - and a minimal inline eval runner.
+ *
+ * The full documentation lives in the package `README.md`.
+ *
+ * @packageDocumentation
+ */
+/** Canonical version constant. Mirrors the `package.json` version. */
+declare const VERSION = "0.5.0";
+//#endregion
+export { ALL_BUILT_IN_PATTERNS, BUILT_IN_IMPERATIVE_PATTERNS, BUILT_IN_PATTERNS, BuiltInPatternName, Case, ConsoleExporterOptions, CostBudgetExceededCallback, CostBudgets, CostRecordInput, CostScope, CostSnapshot, CostTracker, CostTrackerOptions, DEFAULT_REPLAY_LOG_CONFIG, DEFAULT_VALIDATION_CONFIG, Dataset, EvalCaseResult, EvalReport, GenAIAttributes, GenAIMessage, GenAIMessageRole, GenAIOperationName, GenAISystem, GenAIToolType, GraphorinSpan, GraphorinTracer, IMPERATIVE_PREFILTER_SUBSTRINGS, ImperativePattern, ImperativePatternName, ScanResult as ImperativeScanResult, JSONLExporterOptions, LoggerFormat, LoggerOptions, OPEN_INFERENCE_EXCLUDED_TYPES, OPEN_INFERENCE_KIND_TABLE, OPERATION_NAME_TABLE, OPT_IN_PATTERNS, OTLPHttpExporterOptions, OpenInferenceSpanKind, PROVIDER_CLASS_TO_GEN_AI_SYSTEM, PatternCategory, PruneTracesOptions, RedactionCounters, RedactionInput, RedactionOutput, RedactionPattern, RedactionValidationError, RedactionValidator, RedactionValidatorInstance, RedactionValidatorOptions, RedactionViolation, RedactionViolationCallback, Replay, ReplayAuditBridge, ReplayAuditEvent, ReplayEvent, ReplayLogConfig, ReplayMode, ReplayOptions, ReplayRunInput, RunEvalOptions, Sampler, SamplingDecisionMaker, SamplingOptions, SamplingRule, ScoreResult, Scorer, SetAttributeOptions, SpanRecord, SpanRecordEvent, SpanTypeToOperationName, TelemetryStatus, TraceExporter, TracerOptions, UnvalidatedExporterError, VALIDATED_EXPORTER_BRAND, VERSION, ValidationConfig, WithValidationOptions, _resetGenAISystemWarningsForTesting, announceTelemetryPosture, asGraphorinSpan, compareSensitivityTiers, createConsoleExporter, createCostTracker, createJSONLExporter, createLogger, createOTLPHttpExporter, createRedactionValidator, createReplay, createSampler, createTracer, deriveGenAISystem, emitGenAIAttributes, emitGenAIMessageEvents, emitOpenInferenceKind, enableTelemetry, getCurrentSpanContext, getTelemetryStatus, getTraceLog, isValidatedExporter, newSpanId, newTraceId, openInferenceKindFor, operationNameFor, pruneTraces, runEval, scanImperativePatterns, setGenAISystemWarnSink, spanNameFor, stripImperativePatterns, tryGetValidatorCounters, withCurrentSpan, withValidation };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsBa,OAAA"}

package/dist/index.js

@@ -0,0 +1,60 @@
+import { createCostTracker } from "./cost/cost-tracker.js";
+import "./cost/index.js";
+import { runEval } from "./eval/runner.js";
+import { createConsoleExporter } from "./exporters/console.js";
+import { createJSONLExporter } from "./exporters/jsonl.js";
+import { createOTLPHttpExporter } from "./exporters/otlp-http.js";
+import { VALIDATED_EXPORTER_BRAND } from "./exporters/types.js";
+import { RedactionValidationError, UnvalidatedExporterError } from "./redaction/errors.js";
+import { ALL_BUILT_IN_PATTERNS, BUILT_IN_PATTERNS, OPT_IN_PATTERNS } from "./redaction/patterns.js";
+import { compareSensitivityTiers, createRedactionValidator } from "./redaction/validator.js";
+import { isValidatedExporter, tryGetValidatorCounters, withValidation } from "./exporters/with-validation.js";
+import "./exporters/index.js";
+import { newSpanId, newTraceId } from "./tracer/ids.js";
+import { createSampler } from "./tracer/sampling.js";
+import { spanNameFor } from "./tracer/span-names.js";
+import { asGraphorinSpan, createTracer } from "./tracer/tracer.js";
+import { OPERATION_NAME_TABLE, operationNameFor } from "./gen-ai/operation-mapping.js";
+import { emitGenAIAttributes, emitGenAIMessageEvents } from "./gen-ai/emit.js";
+import { PROVIDER_CLASS_TO_GEN_AI_SYSTEM, _resetGenAISystemWarningsForTesting, deriveGenAISystem, setGenAISystemWarnSink } from "./gen-ai/system-derivation.js";
+import "./gen-ai/index.js";
+import { createLogger, getCurrentSpanContext, withCurrentSpan } from "./logger/logger.js";
+import "./logger/index.js";
+import { OPEN_INFERENCE_EXCLUDED_TYPES, OPEN_INFERENCE_KIND_TABLE, emitOpenInferenceKind, openInferenceKindFor } from "./openinference/index.js";
+import { DEFAULT_VALIDATION_CONFIG } from "./redaction/config.js";
+import { BUILT_IN_IMPERATIVE_PATTERNS, IMPERATIVE_PREFILTER_SUBSTRINGS, scanImperativePatterns, stripImperativePatterns } from "./redaction/imperative-patterns.js";
+import "./redaction/index.js";
+import { DEFAULT_REPLAY_LOG_CONFIG } from "./replay/config.js";
+import { getTraceLog, pruneTraces } from "./replay/log.js";
+import { createReplay } from "./replay/replay.js";
+import "./replay/index.js";
+import { announceTelemetryPosture, enableTelemetry, getTelemetryStatus } from "./telemetry/index.js";
+import "./tracer/index.js";
+
+//#region src/index.ts
+/**
+* @graphorin/observability — observability primitives for the
+* Graphorin framework. Ships:
+*
+* - the typed `AISpan<T>` tracer over OpenTelemetry,
+* - the **mandatory** `withValidation()` wrapper for every exporter,
+* - the sensitivity-aware `RedactionValidator` with 14 built-in PII /
+*   secret detection patterns,
+* - OpenTelemetry GenAI semantic-conventions conformance helpers,
+* - OpenInference span-kind emission,
+* - the structured `Logger` with span correlation,
+* - the append-only `JSONLExporter` for replay,
+* - sanitized-by-default `Replay` primitives,
+* - the hierarchical `CostTracker`,
+* - and a minimal inline eval runner.
+*
+* The full documentation lives in the package `README.md`.
+*
+* @packageDocumentation
+*/
+/** Canonical version constant. Mirrors the `package.json` version. */
+const VERSION = "0.5.0";
+
+//#endregion
+export { ALL_BUILT_IN_PATTERNS, BUILT_IN_IMPERATIVE_PATTERNS, BUILT_IN_PATTERNS, DEFAULT_REPLAY_LOG_CONFIG, DEFAULT_VALIDATION_CONFIG, IMPERATIVE_PREFILTER_SUBSTRINGS, OPEN_INFERENCE_EXCLUDED_TYPES, OPEN_INFERENCE_KIND_TABLE, OPERATION_NAME_TABLE, OPT_IN_PATTERNS, PROVIDER_CLASS_TO_GEN_AI_SYSTEM, RedactionValidationError, UnvalidatedExporterError, VALIDATED_EXPORTER_BRAND, VERSION, _resetGenAISystemWarningsForTesting, announceTelemetryPosture, asGraphorinSpan, compareSensitivityTiers, createConsoleExporter, createCostTracker, createJSONLExporter, createLogger, createOTLPHttpExporter, createRedactionValidator, createReplay, createSampler, createTracer, deriveGenAISystem, emitGenAIAttributes, emitGenAIMessageEvents, emitOpenInferenceKind, enableTelemetry, getCurrentSpanContext, getTelemetryStatus, getTraceLog, isValidatedExporter, newSpanId, newTraceId, openInferenceKindFor, operationNameFor, pruneTraces, runEval, scanImperativePatterns, setGenAISystemWarnSink, spanNameFor, stripImperativePatterns, tryGetValidatorCounters, withCurrentSpan, withValidation };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * @graphorin/observability — observability primitives for the\n * Graphorin framework. Ships:\n *\n * - the typed `AISpan<T>` tracer over OpenTelemetry,\n * - the **mandatory** `withValidation()` wrapper for every exporter,\n * - the sensitivity-aware `RedactionValidator` with 14 built-in PII /\n *   secret detection patterns,\n * - OpenTelemetry GenAI semantic-conventions conformance helpers,\n * - OpenInference span-kind emission,\n * - the structured `Logger` with span correlation,\n * - the append-only `JSONLExporter` for replay,\n * - sanitized-by-default `Replay` primitives,\n * - the hierarchical `CostTracker`,\n * - and a minimal inline eval runner.\n *\n * The full documentation lives in the package `README.md`.\n *\n * @packageDocumentation\n */\n\n/** Canonical version constant. Mirrors the `package.json` version. */\nexport const VERSION = '0.5.0';\n\nexport * from './cost/index.js';\nexport * from './eval/index.js';\nexport * from './exporters/index.js';\nexport * from './gen-ai/index.js';\nexport * from './logger/index.js';\nexport * from './openinference/index.js';\nexport * from './redaction/index.js';\nexport * from './replay/index.js';\nexport * from './telemetry/index.js';\nexport * from './tracer/index.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,UAAU"}

package/dist/logger/index.d.ts

@@ -0,0 +1,2 @@
+import { LoggerFormat, LoggerOptions, createLogger, getCurrentSpanContext, withCurrentSpan } from "./logger.js";
+export { type LoggerFormat, type LoggerOptions, createLogger, getCurrentSpanContext, withCurrentSpan };

package/dist/logger/index.js

@@ -0,0 +1,3 @@
+import { createLogger, getCurrentSpanContext, withCurrentSpan } from "./logger.js";
+
+export { createLogger, getCurrentSpanContext, withCurrentSpan };

package/dist/logger/logger.d.ts

@@ -0,0 +1,53 @@
+import { RedactionValidatorInstance } from "../redaction/types.js";
+import { AISpan, LogLevel, Logger, Sensitivity } from "@graphorin/core";
+
+//#region src/logger/logger.d.ts
+
+/**
+ * @stable
+ */
+type LoggerFormat = 'json' | 'pretty';
+/**
+ * Configuration shape for {@link createLogger}.
+ *
+ * @stable
+ */
+interface LoggerOptions {
+  readonly level?: LogLevel;
+  readonly format?: LoggerFormat;
+  /** Optional validator. Logger fields flow through `validate(...)`. */
+  readonly redaction?: RedactionValidatorInstance;
+  /** Default sensitivity tier for fields. Defaults to `'internal'`. */
+  readonly defaultTier?: Sensitivity;
+  /**
+   * Sink that receives the rendered line. Defaults to writing to the
+   * appropriate `console.*` method.
+   */
+  readonly sink?: (level: LogLevel, line: string) => void;
+}
+/**
+ * Run `fn` with the supplied span as the "current" log-correlation
+ * span. The logger picks up the trace + span ids automatically.
+ *
+ * @stable
+ */
+declare function withCurrentSpan<R>(span: AISpan | undefined, fn: () => R | Promise<R>): R | Promise<R>;
+/**
+ * Read the current span context (if any). Useful for callers that
+ * want to attach span metadata to bespoke records.
+ *
+ * @stable
+ */
+declare function getCurrentSpanContext(): {
+  readonly traceId: string;
+  readonly spanId: string;
+} | undefined;
+/**
+ * Build a {@link Logger} configured against the supplied options.
+ *
+ * @stable
+ */
+declare function createLogger(opts?: LoggerOptions): Logger;
+//#endregion
+export { LoggerFormat, LoggerOptions, createLogger, getCurrentSpanContext, withCurrentSpan };
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../../src/logger/logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAiEc,KAxCF,YAAA,GAwCE,MAAA,GAAA,QAAA;AAWd;AAWA;;;;UAvDiB,aAAA;mBACE;oBACC;;uBAEG;;yBAEE;;;;;0BAKC;;;;;;;;iBAmBV,yBACR,8BACI,IAAI,QAAQ,KACrB,IAAI,QAAQ;;;;;;;iBAWC,qBAAA,CAAA;;;;;;;;;iBAWA,YAAA,QAAmB,gBAAqB"}

package/dist/logger/logger.js

@@ -0,0 +1,145 @@
+import { createAsyncContext } from "@graphorin/core";
+
+//#region src/logger/logger.ts
+const LEVELS = [
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error"
+];
+/**
+* @internal — context used to thread the current span id through nested
+* async calls. Exposed via {@link withCurrentSpan} below.
+*/
+const SPAN_CONTEXT = createAsyncContext("graphorin.observability.current-span");
+/**
+* Run `fn` with the supplied span as the "current" log-correlation
+* span. The logger picks up the trace + span ids automatically.
+*
+* @stable
+*/
+function withCurrentSpan(span, fn) {
+	if (span === void 0) return fn();
+	return SPAN_CONTEXT.runAsync({
+		traceId: span.traceId,
+		spanId: span.id
+	}, async () => fn());
+}
+/**
+* Read the current span context (if any). Useful for callers that
+* want to attach span metadata to bespoke records.
+*
+* @stable
+*/
+function getCurrentSpanContext() {
+	return SPAN_CONTEXT.get();
+}
+/**
+* Build a {@link Logger} configured against the supplied options.
+*
+* @stable
+*/
+function createLogger(opts = {}) {
+	const minLevel = LEVELS.indexOf(opts.level ?? "info");
+	const format = opts.format ?? "json";
+	const redaction = opts.redaction;
+	const defaultTier = opts.defaultTier ?? "internal";
+	const sink = opts.sink ?? defaultSink;
+	function emit(level, message, fields) {
+		if (LEVELS.indexOf(level) < minLevel) return;
+		const span = SPAN_CONTEXT.get();
+		const safeFields = sanitizeFields(fields, redaction, defaultTier);
+		const payload = {
+			level,
+			time: (/* @__PURE__ */ new Date()).toISOString(),
+			message,
+			...safeFields
+		};
+		if (span !== void 0) {
+			payload.traceId = span.traceId;
+			payload.spanId = span.spanId;
+		}
+		sink(level, format === "json" ? JSON.stringify(payload) : prettyRender(payload));
+	}
+	return {
+		trace: (message, fields) => emit("trace", message, fields),
+		debug: (message, fields) => emit("debug", message, fields),
+		info: (message, fields) => emit("info", message, fields),
+		warn: (message, fields) => emit("warn", message, fields),
+		error: (message, fields) => emit("error", message, fields),
+		child(_bindings) {
+			const inherited = sanitizeFields(_bindings, redaction, defaultTier);
+			const parent = createLogger(opts);
+			return {
+				trace: (m, f) => parent.trace(m, {
+					...inherited,
+					...f
+				}),
+				debug: (m, f) => parent.debug(m, {
+					...inherited,
+					...f
+				}),
+				info: (m, f) => parent.info(m, {
+					...inherited,
+					...f
+				}),
+				warn: (m, f) => parent.warn(m, {
+					...inherited,
+					...f
+				}),
+				error: (m, f) => parent.error(m, {
+					...inherited,
+					...f
+				}),
+				child(b) {
+					return parent.child({
+						...inherited,
+						...b
+					});
+				}
+			};
+		}
+	};
+}
+function sanitizeFields(fields, validator, tier) {
+	if (fields === void 0) return {};
+	if (validator === void 0) return { ...fields };
+	const out = {};
+	for (const [k, v] of Object.entries(fields)) {
+		const result = validator.validate({
+			value: v,
+			tier,
+			context: { attribute: k }
+		});
+		if (result === null) continue;
+		out[k] = result.value;
+	}
+	return out;
+}
+function defaultSink(level, line) {
+	switch (level) {
+		case "trace":
+		case "debug":
+			console.debug(line);
+			return;
+		case "info":
+			console.info(line);
+			return;
+		case "warn":
+			console.warn(line);
+			return;
+		case "error":
+			console.error(line);
+			return;
+	}
+}
+function prettyRender(payload) {
+	const { level, time, message, ...rest } = payload;
+	const fields = Object.keys(rest).length === 0 ? "" : ` ${JSON.stringify(rest)}`;
+	return `[${String(time)}] ${String(level).toUpperCase()} ${String(message)}${fields}`;
+}
+
+//#endregion
+export { createLogger, getCurrentSpanContext, withCurrentSpan };
+//# sourceMappingURL=logger.js.map

package/dist/logger/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","names":["LEVELS: ReadonlyArray<LogLevel>","defaultTier: Sensitivity","payload: Record<string, unknown>","out: Record<string, unknown>"],"sources":["../../src/logger/logger.ts"],"sourcesContent":["/**\n * `createLogger(...)` — structured logger with optional span correlation.\n *\n * The logger is a thin wrapper around `console.{log,info,warn,error}`\n * that adds:\n *\n * - structured fields,\n * - JSON or pretty rendering,\n * - automatic correlation with the current Graphorin span (the\n *   {@link CurrentSpanContext} helper carries the live trace + span ids),\n * - sensitivity-aware redaction via the supplied\n *   {@link RedactionValidatorInstance}.\n *\n * @packageDocumentation\n */\n\nimport type { AISpan, LogFields, Logger, LogLevel, Sensitivity } from '@graphorin/core';\n\nimport { createAsyncContext } from '@graphorin/core';\n\nimport type { RedactionValidatorInstance } from '../redaction/types.js';\n\n/**\n * @stable\n */\nexport type LoggerFormat = 'json' | 'pretty';\n\n/**\n * Configuration shape for {@link createLogger}.\n *\n * @stable\n */\nexport interface LoggerOptions {\n  readonly level?: LogLevel;\n  readonly format?: LoggerFormat;\n  /** Optional validator. Logger fields flow through `validate(...)`. */\n  readonly redaction?: RedactionValidatorInstance;\n  /** Default sensitivity tier for fields. Defaults to `'internal'`. */\n  readonly defaultTier?: Sensitivity;\n  /**\n   * Sink that receives the rendered line. Defaults to writing to the\n   * appropriate `console.*` method.\n   */\n  readonly sink?: (level: LogLevel, line: string) => void;\n}\n\nconst LEVELS: ReadonlyArray<LogLevel> = ['trace', 'debug', 'info', 'warn', 'error'] as const;\n\n/**\n * @internal — context used to thread the current span id through nested\n * async calls. Exposed via {@link withCurrentSpan} below.\n */\nconst SPAN_CONTEXT = createAsyncContext<{ traceId: string; spanId: string }>(\n  'graphorin.observability.current-span',\n);\n\n/**\n * Run `fn` with the supplied span as the \"current\" log-correlation\n * span. The logger picks up the trace + span ids automatically.\n *\n * @stable\n */\nexport function withCurrentSpan<R>(\n  span: AISpan | undefined,\n  fn: () => R | Promise<R>,\n): R | Promise<R> {\n  if (span === undefined) return fn();\n  return SPAN_CONTEXT.runAsync({ traceId: span.traceId, spanId: span.id }, async () => fn());\n}\n\n/**\n * Read the current span context (if any). Useful for callers that\n * want to attach span metadata to bespoke records.\n *\n * @stable\n */\nexport function getCurrentSpanContext():\n  | { readonly traceId: string; readonly spanId: string }\n  | undefined {\n  return SPAN_CONTEXT.get();\n}\n\n/**\n * Build a {@link Logger} configured against the supplied options.\n *\n * @stable\n */\nexport function createLogger(opts: LoggerOptions = {}): Logger {\n  const minLevel = LEVELS.indexOf(opts.level ?? 'info');\n  const format = opts.format ?? 'json';\n  const redaction = opts.redaction;\n  const defaultTier: Sensitivity = opts.defaultTier ?? 'internal';\n  const sink = opts.sink ?? defaultSink;\n\n  function emit(level: LogLevel, message: string, fields?: LogFields): void {\n    const idx = LEVELS.indexOf(level);\n    if (idx < minLevel) return;\n\n    const span = SPAN_CONTEXT.get();\n    const safeFields = sanitizeFields(fields, redaction, defaultTier);\n\n    const payload: Record<string, unknown> = {\n      level,\n      time: new Date().toISOString(),\n      message,\n      ...safeFields,\n    };\n    if (span !== undefined) {\n      payload.traceId = span.traceId;\n      payload.spanId = span.spanId;\n    }\n\n    const line = format === 'json' ? JSON.stringify(payload) : prettyRender(payload);\n    sink(level, line);\n  }\n\n  return {\n    trace: (message, fields) => emit('trace', message, fields),\n    debug: (message, fields) => emit('debug', message, fields),\n    info: (message, fields) => emit('info', message, fields),\n    warn: (message, fields) => emit('warn', message, fields),\n    error: (message, fields) => emit('error', message, fields),\n    child(_bindings: LogFields): Logger {\n      const inherited = sanitizeFields(_bindings, redaction, defaultTier);\n      const parent = createLogger(opts);\n      return {\n        trace: (m, f) => parent.trace(m, { ...inherited, ...f }),\n        debug: (m, f) => parent.debug(m, { ...inherited, ...f }),\n        info: (m, f) => parent.info(m, { ...inherited, ...f }),\n        warn: (m, f) => parent.warn(m, { ...inherited, ...f }),\n        error: (m, f) => parent.error(m, { ...inherited, ...f }),\n        child(b: LogFields): Logger {\n          return parent.child({ ...inherited, ...b });\n        },\n      };\n    },\n  };\n}\n\nfunction sanitizeFields(\n  fields: LogFields | undefined,\n  validator: RedactionValidatorInstance | undefined,\n  tier: Sensitivity,\n): LogFields {\n  if (fields === undefined) return {};\n  if (validator === undefined) return { ...fields };\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(fields)) {\n    const result = validator.validate({ value: v, tier, context: { attribute: k } });\n    if (result === null) continue;\n    out[k] = result.value;\n  }\n  return out;\n}\n\nfunction defaultSink(level: LogLevel, line: string): void {\n  switch (level) {\n    case 'trace':\n    case 'debug':\n      console.debug(line);\n      return;\n    case 'info':\n      console.info(line);\n      return;\n    case 'warn':\n      console.warn(line);\n      return;\n    case 'error':\n      console.error(line);\n      return;\n  }\n}\n\nfunction prettyRender(payload: Record<string, unknown>): string {\n  const { level, time, message, ...rest } = payload;\n  const fields = Object.keys(rest).length === 0 ? '' : ` ${JSON.stringify(rest)}`;\n  return `[${String(time)}] ${String(level).toUpperCase()} ${String(message)}${fields}`;\n}\n"],"mappings":"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"}

package/dist/openinference/index.d.ts

@@ -0,0 +1,45 @@
+import { AISpan, SpanType } from "@graphorin/core";
+
+//#region src/openinference/index.d.ts
+
+/**
+ * Canonical OpenInference span-kind enum.
+ *
+ * @stable
+ */
+type OpenInferenceSpanKind = 'AGENT' | 'EVALUATOR' | 'LLM' | 'TOOL' | 'RETRIEVER' | 'EMBEDDING' | 'CHAIN' | 'RERANKER';
+/**
+ * Span types intentionally excluded from OpenInference span-kind
+ * emission per the canonical table — `skill.*`, `mcp.connect`,
+ * `mcp.list-tools`, and `replay.*` markers do not have a clean
+ * OpenInference equivalent.
+ *
+ * @stable
+ */
+declare const OPEN_INFERENCE_EXCLUDED_TYPES: ReadonlyArray<SpanType>;
+/**
+ * Resolve the OpenInference span kind for a Graphorin span type.
+ * Returns `null` for types intentionally excluded from emission.
+ *
+ * @stable
+ */
+declare function openInferenceKindFor<T extends SpanType>(type: T): OpenInferenceSpanKind | null;
+/**
+ * Attach the `openinference.span.kind` attribute to a span. No-op for
+ * span types that lack a clean OpenInference equivalent. The attribute
+ * is tagged `'public'` because the enum value is bounded and contains
+ * no PII.
+ *
+ * @stable
+ */
+declare function emitOpenInferenceKind<T extends SpanType>(span: AISpan<T>): void;
+/**
+ * Full canonical span-to-kind table — exposed for tooling and tests
+ * that need to introspect the mapping.
+ *
+ * @stable
+ */
+declare const OPEN_INFERENCE_KIND_TABLE: readonly (readonly [SpanType, OpenInferenceSpanKind])[];
+//#endregion
+export { OPEN_INFERENCE_EXCLUDED_TYPES, OPEN_INFERENCE_KIND_TABLE, OpenInferenceSpanKind, emitOpenInferenceKind, openInferenceKindFor };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/openinference/index.ts"],"sourcesContent":[],"mappings":";;;;AAoIA;;;;;KA5GY,qBAAA;;;;;;;;;cAgEC,+BAA+B,cAAc;;;;;;;iBAe1C,+BAA+B,gBAAgB,IAAI;;;;;;;;;iBAYnD,gCAAgC,gBAAgB,OAAO;;;;;;;cAiB1D,+CAAyB,UAAA"}

package/dist/openinference/index.js

@@ -0,0 +1,92 @@
+import { asGraphorinSpan } from "../tracer/tracer.js";
+
+//#region src/openinference/index.ts
+const KIND_TABLE = Object.freeze([
+	["agent.run", "AGENT"],
+	["agent.step", "AGENT"],
+	["agent.handoff", "AGENT"],
+	["agent.suspend", "AGENT"],
+	["agent.resume", "AGENT"],
+	["provider.generate", "LLM"],
+	["provider.stream", "LLM"],
+	["tool.execute", "TOOL"],
+	["tool.approval", "TOOL"],
+	["memory.read.working", "RETRIEVER"],
+	["memory.read.session", "RETRIEVER"],
+	["memory.read.episodic", "RETRIEVER"],
+	["memory.read.semantic", "RETRIEVER"],
+	["memory.read.procedural", "RETRIEVER"],
+	["memory.read.shared", "RETRIEVER"],
+	["memory.write.working", "RETRIEVER"],
+	["memory.write.session", "RETRIEVER"],
+	["memory.write.episodic", "RETRIEVER"],
+	["memory.write.semantic", "RETRIEVER"],
+	["memory.write.procedural", "RETRIEVER"],
+	["memory.write.shared", "RETRIEVER"],
+	["memory.search.working", "RETRIEVER"],
+	["memory.search.session", "RETRIEVER"],
+	["memory.search.episodic", "RETRIEVER"],
+	["memory.search.semantic", "RETRIEVER"],
+	["memory.search.procedural", "RETRIEVER"],
+	["memory.search.shared", "RETRIEVER"],
+	["memory.embed", "EMBEDDING"],
+	["memory.consolidate.light", "CHAIN"],
+	["memory.consolidate.standard", "CHAIN"],
+	["memory.consolidate.deep", "CHAIN"],
+	["memory.conflict", "CHAIN"],
+	["workflow.run", "CHAIN"],
+	["workflow.step", "CHAIN"],
+	["workflow.task", "CHAIN"],
+	["workflow.checkpoint", "CHAIN"],
+	["mcp.call", "TOOL"]
+]);
+/**
+* Span types intentionally excluded from OpenInference span-kind
+* emission per the canonical table — `skill.*`, `mcp.connect`,
+* `mcp.list-tools`, and `replay.*` markers do not have a clean
+* OpenInference equivalent.
+*
+* @stable
+*/
+const OPEN_INFERENCE_EXCLUDED_TYPES = Object.freeze([
+	"skill.activate",
+	"skill.load",
+	"mcp.connect",
+	"mcp.list-tools"
+]);
+const KIND_LOOKUP = new Map(KIND_TABLE);
+/**
+* Resolve the OpenInference span kind for a Graphorin span type.
+* Returns `null` for types intentionally excluded from emission.
+*
+* @stable
+*/
+function openInferenceKindFor(type) {
+	return KIND_LOOKUP.get(type) ?? null;
+}
+/**
+* Attach the `openinference.span.kind` attribute to a span. No-op for
+* span types that lack a clean OpenInference equivalent. The attribute
+* is tagged `'public'` because the enum value is bounded and contains
+* no PII.
+*
+* @stable
+*/
+function emitOpenInferenceKind(span) {
+	const kind = KIND_LOOKUP.get(span.type);
+	if (kind === void 0) return;
+	const gs = asGraphorinSpan(span);
+	if (gs !== null) gs.setAttribute("openinference.span.kind", kind, { sensitivity: "public" });
+	else span.setAttributes({ "openinference.span.kind": kind });
+}
+/**
+* Full canonical span-to-kind table — exposed for tooling and tests
+* that need to introspect the mapping.
+*
+* @stable
+*/
+const OPEN_INFERENCE_KIND_TABLE = KIND_TABLE;
+
+//#endregion
+export { OPEN_INFERENCE_EXCLUDED_TYPES, OPEN_INFERENCE_KIND_TABLE, emitOpenInferenceKind, openInferenceKindFor };
+//# sourceMappingURL=index.js.map

package/dist/openinference/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["KIND_TABLE: ReadonlyArray<readonly [SpanType, OpenInferenceSpanKind]>","OPEN_INFERENCE_EXCLUDED_TYPES: ReadonlyArray<SpanType>"],"sources":["../../src/openinference/index.ts"],"sourcesContent":["/**\n * OpenInference span-kind emission. Adds the\n * `openinference.span.kind` attribute (one of `AGENT`, `EVALUATOR`,\n * `LLM`, `TOOL`, `RETRIEVER`, `EMBEDDING`, `CHAIN`) to applicable\n * Graphorin spans.\n *\n * The mapping is the canonical table published in the architecture\n * documentation. Span types without a clean OpenInference equivalent\n * (`skill.*`, `mcp.connect`, `mcp.list-tools`, `replay.*`) are NOT\n * emitted — the caller can introspect via {@link openInferenceKindFor}\n * and decide whether to log a fallback attribute.\n *\n * @packageDocumentation\n */\n\nimport type { AISpan, SpanType } from '@graphorin/core';\n\nimport { asGraphorinSpan } from '../tracer/tracer.js';\n\n/**\n * Canonical OpenInference span-kind enum.\n *\n * @stable\n */\nexport type OpenInferenceSpanKind =\n  | 'AGENT'\n  | 'EVALUATOR'\n  | 'LLM'\n  | 'TOOL'\n  | 'RETRIEVER'\n  | 'EMBEDDING'\n  | 'CHAIN'\n  | 'RERANKER';\n\nconst KIND_TABLE: ReadonlyArray<readonly [SpanType, OpenInferenceSpanKind]> = Object.freeze([\n  ['agent.run', 'AGENT'],\n  ['agent.step', 'AGENT'],\n  ['agent.handoff', 'AGENT'],\n  ['agent.suspend', 'AGENT'],\n  ['agent.resume', 'AGENT'],\n\n  ['provider.generate', 'LLM'],\n  ['provider.stream', 'LLM'],\n\n  ['tool.execute', 'TOOL'],\n  ['tool.approval', 'TOOL'],\n\n  ['memory.read.working', 'RETRIEVER'],\n  ['memory.read.session', 'RETRIEVER'],\n  ['memory.read.episodic', 'RETRIEVER'],\n  ['memory.read.semantic', 'RETRIEVER'],\n  ['memory.read.procedural', 'RETRIEVER'],\n  ['memory.read.shared', 'RETRIEVER'],\n  ['memory.write.working', 'RETRIEVER'],\n  ['memory.write.session', 'RETRIEVER'],\n  ['memory.write.episodic', 'RETRIEVER'],\n  ['memory.write.semantic', 'RETRIEVER'],\n  ['memory.write.procedural', 'RETRIEVER'],\n  ['memory.write.shared', 'RETRIEVER'],\n  ['memory.search.working', 'RETRIEVER'],\n  ['memory.search.session', 'RETRIEVER'],\n  ['memory.search.episodic', 'RETRIEVER'],\n  ['memory.search.semantic', 'RETRIEVER'],\n  ['memory.search.procedural', 'RETRIEVER'],\n  ['memory.search.shared', 'RETRIEVER'],\n\n  ['memory.embed', 'EMBEDDING'],\n\n  ['memory.consolidate.light', 'CHAIN'],\n  ['memory.consolidate.standard', 'CHAIN'],\n  ['memory.consolidate.deep', 'CHAIN'],\n  ['memory.conflict', 'CHAIN'],\n  ['workflow.run', 'CHAIN'],\n  ['workflow.step', 'CHAIN'],\n  ['workflow.task', 'CHAIN'],\n  ['workflow.checkpoint', 'CHAIN'],\n\n  ['mcp.call', 'TOOL'],\n] as const);\n\n/**\n * Span types intentionally excluded from OpenInference span-kind\n * emission per the canonical table — `skill.*`, `mcp.connect`,\n * `mcp.list-tools`, and `replay.*` markers do not have a clean\n * OpenInference equivalent.\n *\n * @stable\n */\nexport const OPEN_INFERENCE_EXCLUDED_TYPES: ReadonlyArray<SpanType> = Object.freeze([\n  'skill.activate',\n  'skill.load',\n  'mcp.connect',\n  'mcp.list-tools',\n] as const);\n\nconst KIND_LOOKUP = new Map<SpanType, OpenInferenceSpanKind>(KIND_TABLE);\n\n/**\n * Resolve the OpenInference span kind for a Graphorin span type.\n * Returns `null` for types intentionally excluded from emission.\n *\n * @stable\n */\nexport function openInferenceKindFor<T extends SpanType>(type: T): OpenInferenceSpanKind | null {\n  return KIND_LOOKUP.get(type) ?? null;\n}\n\n/**\n * Attach the `openinference.span.kind` attribute to a span. No-op for\n * span types that lack a clean OpenInference equivalent. The attribute\n * is tagged `'public'` because the enum value is bounded and contains\n * no PII.\n *\n * @stable\n */\nexport function emitOpenInferenceKind<T extends SpanType>(span: AISpan<T>): void {\n  const kind = KIND_LOOKUP.get(span.type);\n  if (kind === undefined) return;\n  const gs = asGraphorinSpan(span);\n  if (gs !== null) {\n    gs.setAttribute('openinference.span.kind', kind, { sensitivity: 'public' });\n  } else {\n    span.setAttributes({ 'openinference.span.kind': kind });\n  }\n}\n\n/**\n * Full canonical span-to-kind table — exposed for tooling and tests\n * that need to introspect the mapping.\n *\n * @stable\n */\nexport const OPEN_INFERENCE_KIND_TABLE = KIND_TABLE;\n"],"mappings":";;;AAkCA,MAAMA,aAAwE,OAAO,OAAO;CAC1F,CAAC,aAAa,QAAQ;CACtB,CAAC,cAAc,QAAQ;CACvB,CAAC,iBAAiB,QAAQ;CAC1B,CAAC,iBAAiB,QAAQ;CAC1B,CAAC,gBAAgB,QAAQ;CAEzB,CAAC,qBAAqB,MAAM;CAC5B,CAAC,mBAAmB,MAAM;CAE1B,CAAC,gBAAgB,OAAO;CACxB,CAAC,iBAAiB,OAAO;CAEzB,CAAC,uBAAuB,YAAY;CACpC,CAAC,uBAAuB,YAAY;CACpC,CAAC,wBAAwB,YAAY;CACrC,CAAC,wBAAwB,YAAY;CACrC,CAAC,0BAA0B,YAAY;CACvC,CAAC,sBAAsB,YAAY;CACnC,CAAC,wBAAwB,YAAY;CACrC,CAAC,wBAAwB,YAAY;CACrC,CAAC,yBAAyB,YAAY;CACtC,CAAC,yBAAyB,YAAY;CACtC,CAAC,2BAA2B,YAAY;CACxC,CAAC,uBAAuB,YAAY;CACpC,CAAC,yBAAyB,YAAY;CACtC,CAAC,yBAAyB,YAAY;CACtC,CAAC,0BAA0B,YAAY;CACvC,CAAC,0BAA0B,YAAY;CACvC,CAAC,4BAA4B,YAAY;CACzC,CAAC,wBAAwB,YAAY;CAErC,CAAC,gBAAgB,YAAY;CAE7B,CAAC,4BAA4B,QAAQ;CACrC,CAAC,+BAA+B,QAAQ;CACxC,CAAC,2BAA2B,QAAQ;CACpC,CAAC,mBAAmB,QAAQ;CAC5B,CAAC,gBAAgB,QAAQ;CACzB,CAAC,iBAAiB,QAAQ;CAC1B,CAAC,iBAAiB,QAAQ;CAC1B,CAAC,uBAAuB,QAAQ;CAEhC,CAAC,YAAY,OAAO;CACrB,CAAU;;;;;;;;;AAUX,MAAaC,gCAAyD,OAAO,OAAO;CAClF;CACA;CACA;CACA;CACD,CAAU;AAEX,MAAM,cAAc,IAAI,IAAqC,WAAW;;;;;;;AAQxE,SAAgB,qBAAyC,MAAuC;AAC9F,QAAO,YAAY,IAAI,KAAK,IAAI;;;;;;;;;;AAWlC,SAAgB,sBAA0C,MAAuB;CAC/E,MAAM,OAAO,YAAY,IAAI,KAAK,KAAK;AACvC,KAAI,SAAS,OAAW;CACxB,MAAM,KAAK,gBAAgB,KAAK;AAChC,KAAI,OAAO,KACT,IAAG,aAAa,2BAA2B,MAAM,EAAE,aAAa,UAAU,CAAC;KAE3E,MAAK,cAAc,EAAE,2BAA2B,MAAM,CAAC;;;;;;;;AAU3D,MAAa,4BAA4B"}

package/dist/redaction/config.d.ts

@@ -0,0 +1,39 @@
+import { RedactionPattern } from "./patterns.js";
+import { Sensitivity } from "@graphorin/core";
+
+//#region src/redaction/config.d.ts
+
+/**
+ * @stable
+ */
+interface ValidationConfig {
+  /** Lowest tier that may pass through the validator. */
+  readonly minTier?: Sensitivity;
+  /**
+   * When `true`, the validator throws on dropped values instead of
+   * silently dropping + counting. Use in tests; production should
+   * keep the default.
+   *
+   * @default false
+   */
+  readonly failOnUnredactedSensitive?: boolean;
+  /**
+   * Custom pattern catalogue. Defaults to the 14 default-on built-in
+   * patterns.
+   */
+  readonly patterns?: ReadonlyArray<RedactionPattern>;
+  /** Per-name allow-list. */
+  readonly enabledPatterns?: ReadonlyArray<string>;
+  /** Per-name deny-list. */
+  readonly disabledPatterns?: ReadonlyArray<string>;
+}
+/**
+ * Default validation configuration. Mirrors the runtime defaults used
+ * by `createTracer({ ... })` when `validation` is omitted.
+ *
+ * @stable
+ */
+declare const DEFAULT_VALIDATION_CONFIG: Required<Pick<ValidationConfig, 'minTier' | 'failOnUnredactedSensitive'>>;
+//#endregion
+export { DEFAULT_VALIDATION_CONFIG, ValidationConfig };
+//# sourceMappingURL=config.d.ts.map

package/dist/redaction/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/redaction/config.ts"],"sourcesContent":[],"mappings":";;;;;;AA4CA;;AACE,UA7Be,gBAAA,CA6Bf;EADsC;EAAQ,SAAA,OAAA,CAAA,EA1B3B,WA0B2B;;;;;;;;;;;;;sBAb1B,cAAc;;6BAEP;;8BAEC;;;;;;;;cASjB,2BAA2B,SACtC,KAAK"}

package/dist/redaction/config.js

@@ -0,0 +1,15 @@
+//#region src/redaction/config.ts
+/**
+* Default validation configuration. Mirrors the runtime defaults used
+* by `createTracer({ ... })` when `validation` is omitted.
+*
+* @stable
+*/
+const DEFAULT_VALIDATION_CONFIG = Object.freeze({
+	minTier: "public",
+	failOnUnredactedSensitive: false
+});
+
+//#endregion
+export { DEFAULT_VALIDATION_CONFIG };
+//# sourceMappingURL=config.js.map

package/dist/redaction/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":["DEFAULT_VALIDATION_CONFIG: Required<\n  Pick<ValidationConfig, 'minTier' | 'failOnUnredactedSensitive'>\n>"],"sources":["../../src/redaction/config.ts"],"sourcesContent":["/**\n * Configuration shape consumed by `observability.validation.*`.\n *\n * The shape mirrors the canonical settings so consumer configuration\n * files can use a single typed structure.\n *\n * @packageDocumentation\n */\n\nimport type { Sensitivity } from '@graphorin/core';\n\nimport type { RedactionPattern } from './patterns.js';\n\n/**\n * @stable\n */\nexport interface ValidationConfig {\n  /** Lowest tier that may pass through the validator. */\n  readonly minTier?: Sensitivity;\n  /**\n   * When `true`, the validator throws on dropped values instead of\n   * silently dropping + counting. Use in tests; production should\n   * keep the default.\n   *\n   * @default false\n   */\n  readonly failOnUnredactedSensitive?: boolean;\n  /**\n   * Custom pattern catalogue. Defaults to the 14 default-on built-in\n   * patterns.\n   */\n  readonly patterns?: ReadonlyArray<RedactionPattern>;\n  /** Per-name allow-list. */\n  readonly enabledPatterns?: ReadonlyArray<string>;\n  /** Per-name deny-list. */\n  readonly disabledPatterns?: ReadonlyArray<string>;\n}\n\n/**\n * Default validation configuration. Mirrors the runtime defaults used\n * by `createTracer({ ... })` when `validation` is omitted.\n *\n * @stable\n */\nexport const DEFAULT_VALIDATION_CONFIG: Required<\n  Pick<ValidationConfig, 'minTier' | 'failOnUnredactedSensitive'>\n> = Object.freeze({\n  minTier: 'public' as const,\n  failOnUnredactedSensitive: false,\n});\n"],"mappings":";;;;;;;AA4CA,MAAaA,4BAET,OAAO,OAAO;CAChB,SAAS;CACT,2BAA2B;CAC5B,CAAC"}

package/dist/redaction/errors.d.ts

@@ -0,0 +1,36 @@
+import { RedactionViolation } from "./types.js";
+
+//#region src/redaction/errors.d.ts
+
+/**
+ * Thrown by the validator when `failOnUnredactedSensitive: true` and
+ * a value would otherwise be dropped or masked. The error never
+ * carries the secret value itself; only the sanitized
+ * {@link RedactionViolation} metadata.
+ *
+ * @stable
+ */
+declare class RedactionValidationError extends Error {
+  /** @stable */
+  readonly kind: "redaction-validation-failed";
+  /** @stable */
+  readonly violation: RedactionViolation;
+  constructor(message: string, violation: RedactionViolation);
+}
+/**
+ * Thrown at startup when an exporter is registered without going
+ * through `withValidation(...)`. Enforces ADR-035: every exporter
+ * must validate before forwarding.
+ *
+ * @stable
+ */
+declare class UnvalidatedExporterError extends Error {
+  /** @stable */
+  readonly kind: "unvalidated-exporter";
+  /** Exporter identifier (typically `exporter.constructor.name`). */
+  readonly exporterId: string;
+  constructor(exporterId: string);
+}
+//#endregion
+export { RedactionValidationError, UnvalidatedExporterError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/redaction/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/redaction/errors.ts"],"sourcesContent":[],"mappings":";;;;;;AAoCA;;;;;;cApBa,wBAAA,SAAiC,KAAA;;;;sBAIxB;0CAEoB;;;;;;;;;cAc7B,wBAAA,SAAiC,KAAA"}