autotel 3.5.0 → 3.7.0

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","names":[],"sources":["../src/validate.ts"],"mappings":";;;KAyCY,cAAA;AAAA,KACA,kBAAA;;UAGK,eAAA;EAYf;EAVA,IAAA;EAYA;EAVA,IAAA;EAWA;EATA,QAAA;AAAA;;UAIe,kBAAA;EAOc;EAL7B,IAAA;EACA,QAAA;EACA,IAAA,EAAM,cAAA;EACN,MAAA,EAAQ,eAAA;EACR,IAAA;EACA,QAAA,GAAW,kBAAA;AAAA;AAAA,KAaR,gBAAA,IAAoB,QAA4B,EAAlB,kBAAkB;;;AAcS;AAe9D;;;;AAAqE;AAqDrE;;;iBApEgB,oBAAA,CAAqB,OAAyB,EAAhB,gBAAgB;AAoES;AAmCvE;;;;AAnCuE,iBArDvD,wBAAA,CAAyB,QAA4B,EAAlB,kBAAkB;;;;;;;;iBAqDrD,sBAAA,CAAuB,KAAA,YAAiB,eAAe;AAAA,UAmCtD,sBAAA;EAMf;EAJA,QAAA;EAIgB;EAFhB,UAAA,GAAa,cAAA;EAGF;EADX,YAAA,IAAgB,MAAA,EAAQ,CAAA;EACxB,QAAA,GAAW,kBAAA;EAEC;EAAZ,QAAA,IAAY,MAAA,EAAQ,eAAA,IAAmB,IAAA,aAAiB,KAAA;AAAA;AAAA,KAG9C,eAAA;EACN,OAAA;EAAe,IAAA,EAAM,CAAA;AAAA;EACrB,OAAA;EAAgB,MAAA,EAAQ,eAAe;AAAA;AAAA,UAE5B,SAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA,EAAM,cAAA;EAJX;EAMJ,SAAA,CAAU,KAAA,YAAiB,eAAA,CAAgB,CAAA;EANf;;AAAe;AAE7C;EASE,KAAA,CAAM,KAAA,YAAiB,CAAA;AAAA;;;;;;;;;;;;;;;;;;;AAAC;AA2C1B;;iBAAgB,eAAA,cAA6B,UAAA,CAAW,CAAA,GACtD,IAAA,UACA,MAAA,EAAQ,CAAA,EACR,OAAA,GAAS,sBAAA,CAAuB,CAAA,IAC/B,SAAA,CAAU,CAAA"}

package/dist/validate.js

@@ -0,0 +1,197 @@
+import { t as createStructuredError } from "./structured-error-9--cxBay.js";
+import { t as hashJson } from "./stable-hash-Cg5cT34Q.js";
+import { createCounter } from "./metric-helpers.js";
+import { VALIDATION_ATTR, VALIDATION_ISSUE_CAP, VALIDATION_METRICS } from "./validation-attributes.js";
+import { trace } from "@opentelemetry/api";
+
+//#region src/validate.ts
+/**
+* Validation telemetry — connect runtime input validation (Zod or any
+* `safeParse` schema) to your traces and metrics at the boundaries where bad
+* data actually enters: HTTP bodies, events, messages.
+*
+* Today a `safeParse` failure either throws (no span, no metric, no alert) or
+* is silently swallowed in a handler. `defineValidator` makes the mismatch
+* **observable** — a `validation.*` span attribute set and a counter
+* incremented — with a per-validator `observe` vs `reject` mode:
+*
+* - `reject` (default): record telemetry, then throw a structured 400-shaped
+*   error so the boundary can fail cleanly.
+* - `observe`: record telemetry, return the raw input so the handler continues
+*   — useful for measuring real-world drift before you enforce it.
+*
+* **Not a security feature by default.** A malformed body is usually a bug or
+* version skew, not an attack. Validation telemetry is first-class on its own
+* metric; escalation to the security path is a deliberate opt-in via
+* {@link onValidationMismatch} (e.g. wired by `autotel-audit`), never automatic.
+*
+* **PII-safe by construction.** Only field *paths*, issue *codes*, and the
+* declared *type* are ever recorded — never the offending value, and never a
+* validator's error `message` (which routinely embeds the received value).
+*/
+let mismatchCounter;
+function counter() {
+	if (!mismatchCounter) mismatchCounter = createCounter(VALIDATION_METRICS.mismatches, { description: "Input payloads that did not match their declared shape" });
+	return mismatchCounter;
+}
+const listeners = /* @__PURE__ */ new Set();
+/**
+* Register an explicit handler called on every recorded mismatch — the opt-in
+* seam for escalating to security events, a webhook, or a custom sink. There is
+* no automatic, package-presence-driven escalation: nothing fires here unless
+* you (or a package you wire up) register a handler.
+*
+* Multiple subscribers coexist: a package (e.g. `autotel-audit` bridging to
+* security events) and your own app code (a webhook, a logger) can both
+* register and all fire. Returns an unsubscribe fn that removes only this
+* handler; registering the same function twice is a no-op (Set semantics).
+*/
+function onValidationMismatch(handler) {
+	listeners.add(handler);
+	return () => {
+		listeners.delete(handler);
+	};
+}
+const truncate = (values) => values.slice(0, 20).join(",");
+/**
+* Record a validation mismatch as telemetry: `validation.*` attributes on the
+* active span (if any) and an increment on `autotel.validation.mismatches`.
+* Fail-open — never throws, so instrumentation can't break the boundary.
+*/
+function recordValidationMismatch(mismatch) {
+	try {
+		const paths = mismatch.issues.map((i) => i.path).filter(Boolean);
+		const codes = [...new Set(mismatch.issues.map((i) => i.code))];
+		const span = trace.getActiveSpan();
+		if (span) span.setAttributes({
+			[VALIDATION_ATTR.name]: mismatch.name,
+			[VALIDATION_ATTR.boundary]: mismatch.boundary,
+			[VALIDATION_ATTR.mode]: mismatch.mode,
+			[VALIDATION_ATTR.issueCount]: mismatch.issues.length,
+			[VALIDATION_ATTR.issuePaths]: truncate(paths),
+			[VALIDATION_ATTR.issueCodes]: truncate(codes),
+			...mismatch.hash ? { [VALIDATION_ATTR.hash]: mismatch.hash } : {},
+			...mismatch.severity ? { [VALIDATION_ATTR.severity]: mismatch.severity } : {}
+		});
+		try {
+			counter().add(1, {
+				boundary: mismatch.boundary,
+				validation: mismatch.name,
+				mode: mismatch.mode
+			});
+		} catch {}
+		for (const listener of listeners) try {
+			listener(mismatch);
+		} catch {}
+	} catch {}
+}
+/**
+* Normalise an arbitrary validation error into PII-safe issues. Reads only
+* `path`, `code`, and (when it is a declared type name) `expected` — and never
+* `message`, `received`, or any value-bearing field. Understands the Zod shape
+* (`error.issues`) and a generic `error.errors` fallback; returns `[]` for
+* anything unrecognised.
+*/
+function formatValidationIssues(error) {
+	return extractRawIssues(error).map((issue) => toSafeIssue(issue));
+}
+function extractRawIssues(error) {
+	if (error && typeof error === "object") {
+		const candidate = error.issues ?? error.errors;
+		if (Array.isArray(candidate)) return candidate.filter((i) => i !== null && typeof i === "object");
+	}
+	return [];
+}
+function toSafeIssue(issue) {
+	const rawPath = issue.path;
+	const path = Array.isArray(rawPath) ? rawPath.map(String).join(".") : typeof rawPath === "string" ? rawPath : "";
+	const code = typeof issue.code === "string" ? issue.code : "invalid";
+	const expected = typeof issue.expected === "string" ? issue.expected : void 0;
+	return expected ? {
+		path,
+		code,
+		expected
+	} : {
+		path,
+		code
+	};
+}
+function defaultRejectError(issues, name) {
+	return createStructuredError({
+		name: "ValidationError",
+		status: 400,
+		code: "validation_failed",
+		message: `Input for "${name}" did not match its declared shape.`,
+		why: `${issues.length} field(s) failed validation: ${issues.map((i) => i.path || "(root)").slice(0, 20).join(", ")}.`,
+		fix: "Send a payload that matches the schema, or switch this validator to observe mode while you investigate.",
+		details: {
+			validation: name,
+			issues
+		}
+	});
+}
+/**
+* Declare an expected input shape once and get a validator that records every
+* mismatch as telemetry.
+*
+* @example
+* ```ts
+* import { z } from 'zod';
+* import { defineValidator } from 'autotel/validate';
+*
+* const OrderBody = defineValidator('POST /orders', z.object({
+*   items: z.array(z.object({ sku: z.string(), qty: z.number().int() })),
+* }), { boundary: 'http', toJsonSchema: (s) => z.toJSONSchema(s) });
+*
+* // reject mode (default): records + throws a 400-shaped structured error
+* const order = OrderBody.parse(req.body);
+*
+* // observe mode: records, returns the result, never throws
+* const result = OrderBody.safeParse(req.body);
+* if (!result.success) metrics.onDrift(result.issues);
+* ```
+*/
+function defineValidator(name, schema, options = {}) {
+	const mode = options.onMismatch ?? "reject";
+	const boundary = options.boundary ?? "input";
+	const hash = options.toJsonSchema ? hashJson(options.toJsonSchema(schema)) : void 0;
+	const record = (issues) => {
+		recordValidationMismatch({
+			name,
+			boundary,
+			mode,
+			issues,
+			hash,
+			severity: options.severity
+		});
+	};
+	return {
+		name,
+		mode,
+		safeParse(input) {
+			const parsed = schema.safeParse(input);
+			if (parsed.success) return {
+				success: true,
+				data: parsed.data
+			};
+			const issues = formatValidationIssues(parsed.error);
+			record(issues);
+			return {
+				success: false,
+				issues
+			};
+		},
+		parse(input) {
+			const parsed = schema.safeParse(input);
+			if (parsed.success) return parsed.data;
+			const issues = formatValidationIssues(parsed.error);
+			record(issues);
+			if (mode === "reject") throw options.onReject?.(issues, name) ?? defaultRejectError(issues, name);
+			return input;
+		}
+	};
+}
+
+//#endregion
+export { defineValidator, formatValidationIssues, onValidationMismatch, recordValidationMismatch };
+//# sourceMappingURL=validate.js.map

package/dist/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","names":[],"sources":["../src/validate.ts"],"sourcesContent":["/**\n * Validation telemetry — connect runtime input validation (Zod or any\n * `safeParse` schema) to your traces and metrics at the boundaries where bad\n * data actually enters: HTTP bodies, events, messages.\n *\n * Today a `safeParse` failure either throws (no span, no metric, no alert) or\n * is silently swallowed in a handler. `defineValidator` makes the mismatch\n * **observable** — a `validation.*` span attribute set and a counter\n * incremented — with a per-validator `observe` vs `reject` mode:\n *\n * - `reject` (default): record telemetry, then throw a structured 400-shaped\n *   error so the boundary can fail cleanly.\n * - `observe`: record telemetry, return the raw input so the handler continues\n *   — useful for measuring real-world drift before you enforce it.\n *\n * **Not a security feature by default.** A malformed body is usually a bug or\n * version skew, not an attack. Validation telemetry is first-class on its own\n * metric; escalation to the security path is a deliberate opt-in via\n * {@link onValidationMismatch} (e.g. wired by `autotel-audit`), never automatic.\n *\n * **PII-safe by construction.** Only field *paths*, issue *codes*, and the\n * declared *type* are ever recorded — never the offending value, and never a\n * validator's error `message` (which routinely embeds the received value).\n */\n\nimport { trace } from '@opentelemetry/api';\nimport { createCounter } from './metric-helpers';\nimport {\n  createStructuredError,\n  type StructuredError,\n} from './structured-error';\nimport { hashJson } from './stable-hash';\nimport type { SchemaLike } from './define-event';\nimport {\n  VALIDATION_ATTR,\n  VALIDATION_ISSUE_CAP,\n  VALIDATION_METRICS,\n} from './validation-attributes';\n\nexport type { SchemaLike } from './define-event';\n\nexport type ValidationMode = 'observe' | 'reject';\nexport type ValidationSeverity = 'info' | 'warning' | 'error';\n\n/** A single failing field, stripped of any payload values. */\nexport interface ValidationIssue {\n  /** Dotted field path, e.g. `items.0.price`. Never a value. */\n  path: string;\n  /** Issue code (e.g. Zod's `invalid_type`, `too_small`). Never a value. */\n  code: string;\n  /** Declared type/constraint summary, e.g. `string`. Never a received value. */\n  expected?: string;\n}\n\n/** Everything the recorder needs — already PII-stripped by the caller. */\nexport interface ValidationMismatch {\n  /** Contract id, e.g. `POST /orders` or `order.placed`. */\n  name: string;\n  boundary: string;\n  mode: ValidationMode;\n  issues: ValidationIssue[];\n  hash?: string;\n  severity?: ValidationSeverity;\n}\n\nlet mismatchCounter: ReturnType<typeof createCounter> | undefined;\nfunction counter(): ReturnType<typeof createCounter> {\n  if (!mismatchCounter) {\n    mismatchCounter = createCounter(VALIDATION_METRICS.mismatches, {\n      description: 'Input payloads that did not match their declared shape',\n    });\n  }\n  return mismatchCounter;\n}\n\ntype MismatchListener = (mismatch: ValidationMismatch) => void;\nconst listeners = new Set<MismatchListener>();\n\n/**\n * Register an explicit handler called on every recorded mismatch — the opt-in\n * seam for escalating to security events, a webhook, or a custom sink. There is\n * no automatic, package-presence-driven escalation: nothing fires here unless\n * you (or a package you wire up) register a handler.\n *\n * Multiple subscribers coexist: a package (e.g. `autotel-audit` bridging to\n * security events) and your own app code (a webhook, a logger) can both\n * register and all fire. Returns an unsubscribe fn that removes only this\n * handler; registering the same function twice is a no-op (Set semantics).\n */\nexport function onValidationMismatch(handler: MismatchListener): () => void {\n  listeners.add(handler);\n  return () => {\n    listeners.delete(handler);\n  };\n}\n\nconst truncate = (values: string[]): string =>\n  values.slice(0, VALIDATION_ISSUE_CAP).join(',');\n\n/**\n * Record a validation mismatch as telemetry: `validation.*` attributes on the\n * active span (if any) and an increment on `autotel.validation.mismatches`.\n * Fail-open — never throws, so instrumentation can't break the boundary.\n */\nexport function recordValidationMismatch(mismatch: ValidationMismatch): void {\n  try {\n    const paths = mismatch.issues.map((i) => i.path).filter(Boolean);\n    const codes = [...new Set(mismatch.issues.map((i) => i.code))];\n\n    const span = trace.getActiveSpan();\n    if (span) {\n      span.setAttributes({\n        [VALIDATION_ATTR.name]: mismatch.name,\n        [VALIDATION_ATTR.boundary]: mismatch.boundary,\n        [VALIDATION_ATTR.mode]: mismatch.mode,\n        [VALIDATION_ATTR.issueCount]: mismatch.issues.length,\n        [VALIDATION_ATTR.issuePaths]: truncate(paths),\n        [VALIDATION_ATTR.issueCodes]: truncate(codes),\n        ...(mismatch.hash ? { [VALIDATION_ATTR.hash]: mismatch.hash } : {}),\n        ...(mismatch.severity\n          ? { [VALIDATION_ATTR.severity]: mismatch.severity }\n          : {}),\n      });\n    }\n\n    try {\n      counter().add(1, {\n        boundary: mismatch.boundary,\n        validation: mismatch.name,\n        mode: mismatch.mode,\n      });\n    } catch {\n      // meter not initialised yet — skip the count, keep the span attrs\n    }\n\n    // Dispatch to every subscriber with per-listener fault isolation: one\n    // throwing subscriber must not starve its peers or break the boundary.\n    // Set iteration tolerates concurrent (un)subscription safely.\n    for (const listener of listeners) {\n      try {\n        listener(mismatch);\n      } catch {\n        // a misbehaving subscriber must not break the boundary or its peers\n      }\n    }\n  } catch {\n    // fail-open: telemetry must never break the validated boundary\n  }\n}\n\n/**\n * Normalise an arbitrary validation error into PII-safe issues. Reads only\n * `path`, `code`, and (when it is a declared type name) `expected` — and never\n * `message`, `received`, or any value-bearing field. Understands the Zod shape\n * (`error.issues`) and a generic `error.errors` fallback; returns `[]` for\n * anything unrecognised.\n */\nexport function formatValidationIssues(error: unknown): ValidationIssue[] {\n  const raw = extractRawIssues(error);\n  return raw.map((issue) => toSafeIssue(issue));\n}\n\nfunction extractRawIssues(error: unknown): Array<Record<string, unknown>> {\n  if (error && typeof error === 'object') {\n    const candidate =\n      (error as { issues?: unknown }).issues ??\n      (error as { errors?: unknown }).errors;\n    if (Array.isArray(candidate)) {\n      return candidate.filter(\n        (i): i is Record<string, unknown> =>\n          i !== null && typeof i === 'object',\n      );\n    }\n  }\n  return [];\n}\n\nfunction toSafeIssue(issue: Record<string, unknown>): ValidationIssue {\n  const rawPath = issue.path;\n  const path = Array.isArray(rawPath)\n    ? rawPath.map(String).join('.')\n    : typeof rawPath === 'string'\n      ? rawPath\n      : '';\n  const code = typeof issue.code === 'string' ? issue.code : 'invalid';\n  // `expected` is a declared type name in Zod (e.g. 'string'); safe. We never\n  // read `received`/`message`/`value`, which can carry the offending payload.\n  const expected =\n    typeof issue.expected === 'string' ? issue.expected : undefined;\n  return expected ? { path, code, expected } : { path, code };\n}\n\nexport interface DefineValidatorOptions<S> {\n  /** Where validation runs. Defaults to `input`. */\n  boundary?: string;\n  /** `reject` (default): record then throw. `observe`: record then continue. */\n  onMismatch?: ValidationMode;\n  /** Project the schema to JSON Schema for a stable `validation.hash`. */\n  toJsonSchema?: (schema: S) => unknown;\n  severity?: ValidationSeverity;\n  /** Build the error thrown in `reject` mode (defaults to a 400 structured error). */\n  onReject?: (issues: ValidationIssue[], name: string) => Error;\n}\n\nexport type ValidatorResult<T> =\n  | { success: true; data: T }\n  | { success: false; issues: ValidationIssue[] };\n\nexport interface Validator<T> {\n  readonly name: string;\n  readonly mode: ValidationMode;\n  /** Validate and record on failure; never throws. */\n  safeParse(input: unknown): ValidatorResult<T>;\n  /**\n   * Validate, record on failure, then apply the mode: `reject` throws,\n   * `observe` returns the raw input so the handler can continue.\n   */\n  parse(input: unknown): T;\n}\n\nfunction defaultRejectError(\n  issues: ValidationIssue[],\n  name: string,\n): StructuredError {\n  return createStructuredError({\n    name: 'ValidationError',\n    status: 400,\n    code: 'validation_failed',\n    message: `Input for \"${name}\" did not match its declared shape.`,\n    why: `${issues.length} field(s) failed validation: ${issues\n      .map((i) => i.path || '(root)')\n      .slice(0, VALIDATION_ISSUE_CAP)\n      .join(', ')}.`,\n    fix: 'Send a payload that matches the schema, or switch this validator to observe mode while you investigate.',\n    // PII-safe: paths + codes only, no received values.\n    details: { validation: name, issues },\n  });\n}\n\n/**\n * Declare an expected input shape once and get a validator that records every\n * mismatch as telemetry.\n *\n * @example\n * ```ts\n * import { z } from 'zod';\n * import { defineValidator } from 'autotel/validate';\n *\n * const OrderBody = defineValidator('POST /orders', z.object({\n *   items: z.array(z.object({ sku: z.string(), qty: z.number().int() })),\n * }), { boundary: 'http', toJsonSchema: (s) => z.toJSONSchema(s) });\n *\n * // reject mode (default): records + throws a 400-shaped structured error\n * const order = OrderBody.parse(req.body);\n *\n * // observe mode: records, returns the result, never throws\n * const result = OrderBody.safeParse(req.body);\n * if (!result.success) metrics.onDrift(result.issues);\n * ```\n */\nexport function defineValidator<T, S extends SchemaLike<T>>(\n  name: string,\n  schema: S,\n  options: DefineValidatorOptions<S> = {},\n): Validator<T> {\n  const mode = options.onMismatch ?? 'reject';\n  const boundary = options.boundary ?? 'input';\n  const hash = options.toJsonSchema\n    ? hashJson(options.toJsonSchema(schema))\n    : undefined;\n\n  const record = (issues: ValidationIssue[]): void => {\n    recordValidationMismatch({\n      name,\n      boundary,\n      mode,\n      issues,\n      hash,\n      severity: options.severity,\n    });\n  };\n\n  return {\n    name,\n    mode,\n    safeParse(input: unknown): ValidatorResult<T> {\n      const parsed = schema.safeParse(input);\n      if (parsed.success) return { success: true, data: parsed.data };\n      const issues = formatValidationIssues(parsed.error);\n      record(issues);\n      return { success: false, issues };\n    },\n    parse(input: unknown): T {\n      const parsed = schema.safeParse(input);\n      if (parsed.success) return parsed.data;\n      const issues = formatValidationIssues(parsed.error);\n      record(issues);\n      if (mode === 'reject') {\n        throw (\n          options.onReject?.(issues, name) ?? defaultRejectError(issues, name)\n        );\n      }\n      // observe: continue with the raw input (documented type caveat)\n      return input as T;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/validation-attributes.cjs

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/validation-attributes.ts
+/**
+* Validation telemetry wire constants — the single source of truth for the
+* `validation.*` span attributes and the `autotel.validation.mismatches` metric
+* emitted when an input payload (HTTP body, event, message) fails to match its
+* declared shape.
+*
+* Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):
+* safe to import from anything that only needs the constant strings — a
+* dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.
+*
+* These keys are a public API for the agents that query your telemetry. Treat a
+* rename here the way you'd treat a breaking change to any other contract.
+*/
+const VALIDATION_ATTR = {
+	/** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */
+	name: "validation.name",
+	/** Where validation ran: `http` | `event` | `message` | a custom label. */
+	boundary: "validation.boundary",
+	/** `observe` (recorded, request continues) or `reject` (recorded, then failed). */
+	mode: "validation.mode",
+	/** Stable hash of the declared shape, when a JSON-schema projection is given. */
+	hash: "validation.hash",
+	/** `info` | `warning` | `error`. */
+	severity: "validation.severity",
+	/** Number of failing fields. */
+	issueCount: "validation.issue.count",
+	/** Comma-separated failing field paths (capped). Never contains values. */
+	issuePaths: "validation.issue.paths",
+	/** Comma-separated distinct issue codes (capped). Never contains values. */
+	issueCodes: "validation.issue.codes"
+};
+const VALIDATION_METRICS = { 
+/** Counter, labelled `{ boundary, validation, mode }`. */
+mismatches: "autotel.validation.mismatches" };
+/** Max field paths / codes stamped onto a span, to bound attribute size. */
+const VALIDATION_ISSUE_CAP = 20;
+
+//#endregion
+exports.VALIDATION_ATTR = VALIDATION_ATTR;
+exports.VALIDATION_ISSUE_CAP = VALIDATION_ISSUE_CAP;
+exports.VALIDATION_METRICS = VALIDATION_METRICS;
+//# sourceMappingURL=validation-attributes.cjs.map

package/dist/validation-attributes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-attributes.cjs","names":[],"sources":["../src/validation-attributes.ts"],"sourcesContent":["/**\n * Validation telemetry wire constants — the single source of truth for the\n * `validation.*` span attributes and the `autotel.validation.mismatches` metric\n * emitted when an input payload (HTTP body, event, message) fails to match its\n * declared shape.\n *\n * Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):\n * safe to import from anything that only needs the constant strings — a\n * dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.\n *\n * These keys are a public API for the agents that query your telemetry. Treat a\n * rename here the way you'd treat a breaking change to any other contract.\n */\n\nexport const VALIDATION_ATTR = {\n  /** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */\n  name: 'validation.name',\n  /** Where validation ran: `http` | `event` | `message` | a custom label. */\n  boundary: 'validation.boundary',\n  /** `observe` (recorded, request continues) or `reject` (recorded, then failed). */\n  mode: 'validation.mode',\n  /** Stable hash of the declared shape, when a JSON-schema projection is given. */\n  hash: 'validation.hash',\n  /** `info` | `warning` | `error`. */\n  severity: 'validation.severity',\n  /** Number of failing fields. */\n  issueCount: 'validation.issue.count',\n  /** Comma-separated failing field paths (capped). Never contains values. */\n  issuePaths: 'validation.issue.paths',\n  /** Comma-separated distinct issue codes (capped). Never contains values. */\n  issueCodes: 'validation.issue.codes',\n} as const;\n\nexport type ValidationAttributeKey =\n  (typeof VALIDATION_ATTR)[keyof typeof VALIDATION_ATTR];\n\nexport const VALIDATION_METRICS = {\n  /** Counter, labelled `{ boundary, validation, mode }`. */\n  mismatches: 'autotel.validation.mismatches',\n} as const;\n\n/** Max field paths / codes stamped onto a span, to bound attribute size. */\nexport const VALIDATION_ISSUE_CAP = 20;\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,MAAa,kBAAkB;;CAE7B,MAAM;;CAEN,UAAU;;CAEV,MAAM;;CAEN,MAAM;;CAEN,UAAU;;CAEV,YAAY;;CAEZ,YAAY;;CAEZ,YAAY;AACd;AAKA,MAAa,qBAAqB;;AAEhC,YAAY,gCACd;;AAGA,MAAa,uBAAuB"}

package/dist/validation-attributes.d.cts

@@ -0,0 +1,33 @@
+//#region src/validation-attributes.d.ts
+/**
+ * Validation telemetry wire constants — the single source of truth for the
+ * `validation.*` span attributes and the `autotel.validation.mismatches` metric
+ * emitted when an input payload (HTTP body, event, message) fails to match its
+ * declared shape.
+ *
+ * Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):
+ * safe to import from anything that only needs the constant strings — a
+ * dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.
+ *
+ * These keys are a public API for the agents that query your telemetry. Treat a
+ * rename here the way you'd treat a breaking change to any other contract.
+ */
+declare const VALIDATION_ATTR: {
+  /** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */readonly name: "validation.name"; /** Where validation ran: `http` | `event` | `message` | a custom label. */
+  readonly boundary: "validation.boundary"; /** `observe` (recorded, request continues) or `reject` (recorded, then failed). */
+  readonly mode: "validation.mode"; /** Stable hash of the declared shape, when a JSON-schema projection is given. */
+  readonly hash: "validation.hash"; /** `info` | `warning` | `error`. */
+  readonly severity: "validation.severity"; /** Number of failing fields. */
+  readonly issueCount: "validation.issue.count"; /** Comma-separated failing field paths (capped). Never contains values. */
+  readonly issuePaths: "validation.issue.paths"; /** Comma-separated distinct issue codes (capped). Never contains values. */
+  readonly issueCodes: "validation.issue.codes";
+};
+type ValidationAttributeKey = (typeof VALIDATION_ATTR)[keyof typeof VALIDATION_ATTR];
+declare const VALIDATION_METRICS: {
+  /** Counter, labelled `{ boundary, validation, mode }`. */readonly mismatches: "autotel.validation.mismatches";
+};
+/** Max field paths / codes stamped onto a span, to bound attribute size. */
+declare const VALIDATION_ISSUE_CAP = 20;
+//#endregion
+export { VALIDATION_ATTR, VALIDATION_ISSUE_CAP, VALIDATION_METRICS, ValidationAttributeKey };
+//# sourceMappingURL=validation-attributes.d.cts.map

package/dist/validation-attributes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-attributes.d.cts","names":[],"sources":["../src/validation-attributes.ts"],"mappings":";;AAcA;;;;;;;;;;;;cAAa,eAAA;sHAmBqB;EAAA,0CACxB;EAAA,kCAEG;EAAA;;iDAMoB;EAAA,+CAAA;EAAA;;KATrB,sBAAA,WACF,eAAA,eAA8B,eAAe;AAAA,cAE1C,kBAAA;qEAGH,UAAA;AAAA;;cAGG,oBAAA"}

package/dist/validation-attributes.d.ts

@@ -0,0 +1,33 @@
+//#region src/validation-attributes.d.ts
+/**
+ * Validation telemetry wire constants — the single source of truth for the
+ * `validation.*` span attributes and the `autotel.validation.mismatches` metric
+ * emitted when an input payload (HTTP body, event, message) fails to match its
+ * declared shape.
+ *
+ * Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):
+ * safe to import from anything that only needs the constant strings — a
+ * dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.
+ *
+ * These keys are a public API for the agents that query your telemetry. Treat a
+ * rename here the way you'd treat a breaking change to any other contract.
+ */
+declare const VALIDATION_ATTR: {
+  /** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */readonly name: "validation.name"; /** Where validation ran: `http` | `event` | `message` | a custom label. */
+  readonly boundary: "validation.boundary"; /** `observe` (recorded, request continues) or `reject` (recorded, then failed). */
+  readonly mode: "validation.mode"; /** Stable hash of the declared shape, when a JSON-schema projection is given. */
+  readonly hash: "validation.hash"; /** `info` | `warning` | `error`. */
+  readonly severity: "validation.severity"; /** Number of failing fields. */
+  readonly issueCount: "validation.issue.count"; /** Comma-separated failing field paths (capped). Never contains values. */
+  readonly issuePaths: "validation.issue.paths"; /** Comma-separated distinct issue codes (capped). Never contains values. */
+  readonly issueCodes: "validation.issue.codes";
+};
+type ValidationAttributeKey = (typeof VALIDATION_ATTR)[keyof typeof VALIDATION_ATTR];
+declare const VALIDATION_METRICS: {
+  /** Counter, labelled `{ boundary, validation, mode }`. */readonly mismatches: "autotel.validation.mismatches";
+};
+/** Max field paths / codes stamped onto a span, to bound attribute size. */
+declare const VALIDATION_ISSUE_CAP = 20;
+//#endregion
+export { VALIDATION_ATTR, VALIDATION_ISSUE_CAP, VALIDATION_METRICS, ValidationAttributeKey };
+//# sourceMappingURL=validation-attributes.d.ts.map

package/dist/validation-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-attributes.d.ts","names":[],"sources":["../src/validation-attributes.ts"],"mappings":";;AAcA;;;;;;;;;;;;cAAa,eAAA;sHAmBqB;EAAA,0CACxB;EAAA,kCAEG;EAAA;;iDAMoB;EAAA,+CAAA;EAAA;;KATrB,sBAAA,WACF,eAAA,eAA8B,eAAe;AAAA,cAE1C,kBAAA;qEAGH,UAAA;AAAA;;cAGG,oBAAA"}

package/dist/validation-attributes.js

@@ -0,0 +1,41 @@
+//#region src/validation-attributes.ts
+/**
+* Validation telemetry wire constants — the single source of truth for the
+* `validation.*` span attributes and the `autotel.validation.mismatches` metric
+* emitted when an input payload (HTTP body, event, message) fails to match its
+* declared shape.
+*
+* Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):
+* safe to import from anything that only needs the constant strings — a
+* dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.
+*
+* These keys are a public API for the agents that query your telemetry. Treat a
+* rename here the way you'd treat a breaking change to any other contract.
+*/
+const VALIDATION_ATTR = {
+	/** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */
+	name: "validation.name",
+	/** Where validation ran: `http` | `event` | `message` | a custom label. */
+	boundary: "validation.boundary",
+	/** `observe` (recorded, request continues) or `reject` (recorded, then failed). */
+	mode: "validation.mode",
+	/** Stable hash of the declared shape, when a JSON-schema projection is given. */
+	hash: "validation.hash",
+	/** `info` | `warning` | `error`. */
+	severity: "validation.severity",
+	/** Number of failing fields. */
+	issueCount: "validation.issue.count",
+	/** Comma-separated failing field paths (capped). Never contains values. */
+	issuePaths: "validation.issue.paths",
+	/** Comma-separated distinct issue codes (capped). Never contains values. */
+	issueCodes: "validation.issue.codes"
+};
+const VALIDATION_METRICS = { 
+/** Counter, labelled `{ boundary, validation, mode }`. */
+mismatches: "autotel.validation.mismatches" };
+/** Max field paths / codes stamped onto a span, to bound attribute size. */
+const VALIDATION_ISSUE_CAP = 20;
+
+//#endregion
+export { VALIDATION_ATTR, VALIDATION_ISSUE_CAP, VALIDATION_METRICS };
+//# sourceMappingURL=validation-attributes.js.map

package/dist/validation-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-attributes.js","names":[],"sources":["../src/validation-attributes.ts"],"sourcesContent":["/**\n * Validation telemetry wire constants — the single source of truth for the\n * `validation.*` span attributes and the `autotel.validation.mismatches` metric\n * emitted when an input payload (HTTP body, event, message) fails to match its\n * declared shape.\n *\n * Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):\n * safe to import from anything that only needs the constant strings — a\n * dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.\n *\n * These keys are a public API for the agents that query your telemetry. Treat a\n * rename here the way you'd treat a breaking change to any other contract.\n */\n\nexport const VALIDATION_ATTR = {\n  /** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */\n  name: 'validation.name',\n  /** Where validation ran: `http` | `event` | `message` | a custom label. */\n  boundary: 'validation.boundary',\n  /** `observe` (recorded, request continues) or `reject` (recorded, then failed). */\n  mode: 'validation.mode',\n  /** Stable hash of the declared shape, when a JSON-schema projection is given. */\n  hash: 'validation.hash',\n  /** `info` | `warning` | `error`. */\n  severity: 'validation.severity',\n  /** Number of failing fields. */\n  issueCount: 'validation.issue.count',\n  /** Comma-separated failing field paths (capped). Never contains values. */\n  issuePaths: 'validation.issue.paths',\n  /** Comma-separated distinct issue codes (capped). Never contains values. */\n  issueCodes: 'validation.issue.codes',\n} as const;\n\nexport type ValidationAttributeKey =\n  (typeof VALIDATION_ATTR)[keyof typeof VALIDATION_ATTR];\n\nexport const VALIDATION_METRICS = {\n  /** Counter, labelled `{ boundary, validation, mode }`. */\n  mismatches: 'autotel.validation.mismatches',\n} as const;\n\n/** Max field paths / codes stamped onto a span, to bound attribute size. */\nexport const VALIDATION_ISSUE_CAP = 20;\n"],"mappings":";;;;;;;;;;;;;;AAcA,MAAa,kBAAkB;;CAE7B,MAAM;;CAEN,UAAU;;CAEV,MAAM;;CAEN,MAAM;;CAEN,UAAU;;CAEV,YAAY;;CAEZ,YAAY;;CAEZ,YAAY;AACd;AAKA,MAAa,qBAAqB;;AAEhC,YAAY,gCACd;;AAGA,MAAa,uBAAuB"}