ag-ui-validate 0.1.0

package/dist/cli.js

@@ -0,0 +1,2783 @@
+#!/usr/bin/env node
+import { createReadStream, readFileSync, writeFileSync } from "node:fs";
+import process from "node:process";
+//#region src/cli-args.ts
+const USAGE = `ag-ui-validate — conformance validator for the AG-UI protocol
+
+Usage:
+  ag-ui-validate <url>            connect to a live endpoint and validate the stream
+  ag-ui-validate <file>           validate a recorded stream (SSE capture or NDJSON/JSONL)
+  ag-ui-validate -                read a recorded stream from stdin
+
+Output (default: human-readable):
+  --json                          machine-readable report on stdout
+  --sarif                         SARIF 2.1.0 log on stdout (code scanning)
+  --junit                         JUnit XML on stdout (CI test reports)
+  --json-file <path>              additionally write the JSON report to a file
+  --sarif-file <path>             additionally write a SARIF log to a file
+  --junit-file <path>             additionally write JUnit XML to a file
+  --no-color                      disable ANSI colors
+
+Rules:
+  --rule AGUI###=<severity>       override a rule's severity (error|warning|info|off)
+  --off AGUI###                   shorthand for --rule AGUI###=off
+  --features <a,b,...>            declare exercised features (enables e.g. AGUI305)
+  --max-warnings <n>              exit 1 when warnings exceed n
+
+Endpoint options:
+  --header "Name: value"          extra request header (repeatable)
+  --timeout <seconds>             abort the request after this long
+
+Exit codes: 0 clean, 1 findings at error level (or warnings over --max-warnings), 2 tool failure.
+`;
+const SEVERITIES$1 = /* @__PURE__ */ new Set([
+	"error",
+	"warning",
+	"info",
+	"off"
+]);
+const RULE_ID = /^AGUI\d{3}$/;
+const FLAGS = {
+	"--help": {
+		takesValue: false,
+		apply: (c) => (c.help = true, null)
+	},
+	"--version": {
+		takesValue: false,
+		apply: (c) => (c.version = true, null)
+	},
+	"--no-color": {
+		takesValue: false,
+		apply: (c) => (c.color = false, null)
+	},
+	"--json": {
+		takesValue: false,
+		apply: (c) => setFormat(c, "json")
+	},
+	"--sarif": {
+		takesValue: false,
+		apply: (c) => setFormat(c, "sarif")
+	},
+	"--junit": {
+		takesValue: false,
+		apply: (c) => setFormat(c, "junit")
+	},
+	"--off": {
+		takesValue: true,
+		apply: (c, v) => {
+			if (!RULE_ID.test(v)) return `--off expects a rule ID like AGUI203, got '${v}'`;
+			c.severityOverrides[v] = "off";
+			return null;
+		}
+	},
+	"--rule": {
+		takesValue: true,
+		apply: (c, v) => {
+			const eq = v.indexOf("=");
+			if (eq === -1) return `--rule expects ID=severity (e.g. AGUI105=warning), got '${v}'`;
+			const id = v.slice(0, eq);
+			const severity = v.slice(eq + 1);
+			if (!RULE_ID.test(id)) return `--rule expects a rule ID like AGUI105, got '${id}'`;
+			if (!SEVERITIES$1.has(severity)) return `'${severity}' is not a severity; use error, warning, info, or off`;
+			c.severityOverrides[id] = severity;
+			return null;
+		}
+	},
+	"--max-warnings": {
+		takesValue: true,
+		apply: (c, v) => {
+			const n = Number(v);
+			if (!Number.isInteger(n) || n < 0) return `--max-warnings expects a non-negative integer, got '${v}'`;
+			c.maxWarnings = n;
+			return null;
+		}
+	},
+	"--timeout": {
+		takesValue: true,
+		apply: (c, v) => {
+			const n = Number(v);
+			if (!Number.isFinite(n) || n <= 0) return `--timeout expects a positive number of seconds, got '${v}'`;
+			c.timeoutMs = Math.round(n * 1e3);
+			return null;
+		}
+	},
+	"--header": {
+		takesValue: true,
+		apply: (c, v) => {
+			const colon = v.indexOf(":");
+			if (colon <= 0) return `--header expects "Name: value", got '${v}'`;
+			c.headers[v.slice(0, colon).trim().toLowerCase()] = v.slice(colon + 1).trim();
+			return null;
+		}
+	},
+	"--sarif-file": {
+		takesValue: true,
+		apply: (c, v) => (c.sarifFile = v, null)
+	},
+	"--junit-file": {
+		takesValue: true,
+		apply: (c, v) => (c.junitFile = v, null)
+	},
+	"--json-file": {
+		takesValue: true,
+		apply: (c, v) => (c.jsonFile = v, null)
+	},
+	"--features": {
+		takesValue: true,
+		apply: (c, v) => {
+			c.features = v.split(",").map((f) => f.trim()).filter((f) => f !== "");
+			return null;
+		}
+	}
+};
+function setFormat(c, format) {
+	if (c.format !== "pretty" && c.format !== format) return `pick at most one of --json, --sarif, --junit`;
+	c.format = format;
+	return null;
+}
+function parseCliArgs(argv) {
+	const config = {
+		target: "",
+		format: "pretty",
+		color: null,
+		headers: {},
+		severityOverrides: {},
+		help: false,
+		version: false
+	};
+	const targets = [];
+	for (let i = 0; i < argv.length; i += 1) {
+		const arg = argv[i];
+		if (arg === "-" || !arg.startsWith("-")) {
+			targets.push(arg);
+			continue;
+		}
+		let name = arg;
+		let inlineValue = null;
+		const eq = arg.indexOf("=");
+		if (eq !== -1) {
+			name = arg.slice(0, eq);
+			inlineValue = arg.slice(eq + 1);
+		}
+		const flag = FLAGS[name];
+		if (flag === void 0) return {
+			ok: false,
+			error: `unknown flag '${name}'`
+		};
+		let value = "";
+		if (flag.takesValue) {
+			if (inlineValue !== null) value = inlineValue;
+			else if (i + 1 < argv.length) value = argv[i += 1];
+			else return {
+				ok: false,
+				error: `${name} requires a value`
+			};
+		} else if (inlineValue !== null) return {
+			ok: false,
+			error: `${name} does not take a value`
+		};
+		const error = flag.apply(config, value);
+		if (error !== null) return {
+			ok: false,
+			error
+		};
+	}
+	if (targets.length > 1) return {
+		ok: false,
+		error: `expected exactly one target, got ${targets.length}`
+	};
+	if (targets.length === 1) config.target = targets[0];
+	else if (!config.help && !config.version) return {
+		ok: false,
+		error: "missing target: a URL, a file path, or - for stdin"
+	};
+	return {
+		ok: true,
+		config
+	};
+}
+function decideExitCode(summary, maxWarnings) {
+	if (summary.errors > 0) return 1;
+	if (maxWarnings !== void 0 && summary.warnings > maxWarnings) return 1;
+	return 0;
+}
+//#endregion
+//#region src/report/pretty.ts
+const SYMBOL = {
+	error: "✖",
+	warning: "⚠",
+	info: "ℹ"
+};
+const SGR = {
+	error: "31",
+	warning: "33",
+	info: "36"
+};
+function paint(code, s, on) {
+	return on ? `\x1b[${code}m${s}\x1b[0m` : s;
+}
+function formatDiagnosticLine(d, opts) {
+	const where = d.eventIndex >= 0 ? `event ${d.eventIndex}` : "—";
+	const head = paint(SGR[d.severity], `${SYMBOL[d.severity]} ${d.rule}`, opts.color);
+	const meta = paint("2", `${d.severity.padEnd(7)} ${where.padEnd(10)}`, opts.color);
+	const cite = paint("2", `  ↳ ${d.specUrl}`, opts.color);
+	return `${head}  ${meta} ${d.message}\n${cite}`;
+}
+function count(n, noun) {
+	return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+function formatReportSummary(report, opts) {
+	const { errors, warnings, info } = report.summary;
+	const lines = [];
+	if (errors + warnings + info === 0) lines.push(paint("32", `✔ no conformance violations across ${count(report.eventCount, "event")}`, opts.color));
+	else lines.push(`${count(errors, "error")}, ${count(warnings, "warning")}, ${info} info across ${count(report.eventCount, "event")}`);
+	const features = Object.entries(report.features);
+	const exercised = features.filter(([, s]) => s === "exercised").map(([f]) => f);
+	const suffix = exercised.length > 0 ? `: ${exercised.join(", ")}` : "";
+	lines.push(`${exercised.length} of ${features.length} AG-UI features exercised${suffix}`);
+	if (report.skipped.length > 0) {
+		lines.push(`${count(report.skipped.length, "rule")} not evaluated:`);
+		for (const s of report.skipped) lines.push(paint("2", `  – ${s.rule}: ${s.reason}`, opts.color));
+	}
+	for (const e of report.internalErrors) lines.push(paint("31", `! internal validator error: ${e}`, opts.color));
+	return lines.join("\n");
+}
+//#endregion
+//#region src/report/json.ts
+function toJsonReport(report, opts) {
+	const doc = {
+		tool: opts.tool,
+		...report
+	};
+	if (opts.target !== void 0) doc.target = opts.target;
+	return doc;
+}
+//#endregion
+//#region src/rules/catalog.json
+var catalog_default = {
+	$comment: "AG-UI conformance rule catalog. Data, not code: a Python/Go implementation shares these rules. Severities follow the working agreement that behaviour the spec does not clearly govern is at most 'info' — entries with 'specQuestion' were downgraded accordingly; see docs/spec-questions.md.",
+	catalogVersion: "0.1.0",
+	spec: "0.x",
+	rules: [
+		{
+			"id": "AGUI001",
+			"severity": "error",
+			"title": "Run does not start with RUN_STARTED",
+			"messageTemplate": "First event of the run is {type}; expected RUN_STARTED",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runstarted",
+			"specQuote": "The RunStarted event is the first event emitted when an agent begins processing a request.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI002",
+			"severity": "error",
+			"title": "Multiple RUN_STARTED in one run",
+			"messageTemplate": "Duplicate RUN_STARTED (runId '{runId}') before the active run terminated",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#lifecycle-events",
+			"specQuote": "The RunStarted and either RunFinished or RunError events are mandatory, forming the boundaries of an agent run.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI003",
+			"severity": "error",
+			"title": "Run not terminated",
+			"messageTemplate": "Run '{runId}' ended without RUN_FINISHED or RUN_ERROR",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runfinished",
+			"specQuote": "Every run terminates with either RunFinished or RunError.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI004",
+			"severity": "error",
+			"title": "Event after terminal event",
+			"messageTemplate": "{type} follows the run's terminal {terminalType}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#lifecycle-events",
+			"specQuote": "The RunStarted and either RunFinished or RunError events are mandatory, forming the boundaries of an agent run.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI005",
+			"severity": "error",
+			"title": "RUN_FINISHED and RUN_ERROR are mutually exclusive",
+			"messageTemplate": "{type} emitted after the run already terminated with {terminalType}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runfinished",
+			"specQuote": "Every run terminates with either RunFinished or RunError.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI006",
+			"severity": "error",
+			"title": "STEP_FINISHED without matching STEP_STARTED",
+			"messageTemplate": "STEP_FINISHED '{stepName}' has no open STEP_STARTED",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#stepfinished",
+			"specQuote": "The stepName must match the corresponding StepStarted event.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI007",
+			"severity": "error",
+			"title": "Step unterminated at run end",
+			"messageTemplate": "STEP_STARTED '{stepName}' never finished",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#stepstarted",
+			"specQuote": "The stepName must match the corresponding StepStarted event.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI008",
+			"severity": "warning",
+			"title": "Unstable threadId/runId across the run",
+			"messageTemplate": "RUN_FINISHED {field} '{actual}' does not match RUN_STARTED {field} '{expected}'",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runstarted",
+			"specQuote": "It also provides crucial identifiers that can be used to associate subsequent events with this specific run.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI101",
+			"severity": "error",
+			"title": "TEXT_MESSAGE_CONTENT without start",
+			"messageTemplate": "TEXT_MESSAGE_CONTENT for messageId '{messageId}' with no open TEXT_MESSAGE_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#text-message-events",
+			"specQuote": "A message begins with a TextMessageStart event, followed by one or more TextMessageContent events that deliver chunks of text as they become available, and concludes with a TextMessageEnd event.",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI102",
+			"severity": "error",
+			"title": "TEXT_MESSAGE_END without start",
+			"messageTemplate": "TEXT_MESSAGE_END for messageId '{messageId}' with no open TEXT_MESSAGE_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#textmessageend",
+			"specQuote": "messageId: Matches the ID from TextMessageStart",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI103",
+			"severity": "error",
+			"title": "Text message unterminated at run end",
+			"messageTemplate": "TEXT_MESSAGE_START messageId '{messageId}' never ended",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#text-message-events",
+			"specQuote": "A message begins with a TextMessageStart event, followed by one or more TextMessageContent events that deliver chunks of text as they become available, and concludes with a TextMessageEnd event.",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI104",
+			"severity": "error",
+			"title": "Duplicate messageId within a run",
+			"messageTemplate": "messageId '{messageId}' was already used by a completed message",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#textmessagestart",
+			"specQuote": "It establishes a unique messageId that will be referenced by subsequent content chunks and the end event.",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI105",
+			"severity": "warning",
+			"title": "Empty content delta",
+			"messageTemplate": "TEXT_MESSAGE_CONTENT for messageId '{messageId}' has an empty delta",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#textmessagecontent",
+			"specQuote": "delta: Text content chunk (non-empty)",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"specQuestion": "SQ-2",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI106",
+			"severity": "error",
+			"title": "Interleaved message streams sharing a messageId",
+			"messageTemplate": "TEXT_MESSAGE_START for messageId '{messageId}', which is already open",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#implementation-considerations",
+			"specQuote": "Events with the same ID (e.g., messageId, toolCallId) belong to the same logical stream",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI201",
+			"severity": "error",
+			"title": "TOOL_CALL_ARGS without start",
+			"messageTemplate": "TOOL_CALL_ARGS for toolCallId '{toolCallId}' with no open TOOL_CALL_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#tool-call-events",
+			"specQuote": "When an agent needs to use a tool, it emits a ToolCallStart event, followed by one or more ToolCallArgs events that stream the arguments being passed to the tool, and concludes with a ToolCallEnd event.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI202",
+			"severity": "error",
+			"title": "TOOL_CALL_END without start",
+			"messageTemplate": "TOOL_CALL_END for toolCallId '{toolCallId}' with no open TOOL_CALL_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallend",
+			"specQuote": "toolCallId: Matches the ID from ToolCallStart",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI203",
+			"severity": "error",
+			"title": "Unterminated tool call",
+			"messageTemplate": "TOOL_CALL_START id '{toolCallId}' never terminated",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#tool-call-events",
+			"specQuote": "When an agent needs to use a tool, it emits a ToolCallStart event, followed by one or more ToolCallArgs events that stream the arguments being passed to the tool, and concludes with a ToolCallEnd event.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI204",
+			"severity": "error",
+			"title": "Tool call arguments are not valid JSON",
+			"messageTemplate": "Concatenated TOOL_CALL_ARGS for toolCallId '{toolCallId}' do not parse as JSON: {error}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallargs",
+			"specQuote": "Frontends should concatenate these deltas in the order received to construct the complete arguments object.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI205",
+			"severity": "error",
+			"title": "Duplicate toolCallId within a run",
+			"messageTemplate": "toolCallId '{toolCallId}' was already used by a completed tool call",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallstart",
+			"specQuote": "toolCallId: Unique identifier for the tool call",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI206",
+			"severity": "warning",
+			"title": "TOOL_CALL_RESULT before TOOL_CALL_END",
+			"messageTemplate": "TOOL_CALL_RESULT for toolCallId '{toolCallId}' arrived while the call is still open",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallresult",
+			"specQuote": "This event is sent after the tool has been executed by the system and contains the actual output generated by the tool.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI207",
+			"severity": "error",
+			"title": "TOOL_CALL_RESULT references unknown toolCallId",
+			"messageTemplate": "TOOL_CALL_RESULT references toolCallId '{toolCallId}', which was never started",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallresult",
+			"specQuote": "toolCallId: Matches the ID from the corresponding ToolCallStart event",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI208",
+			"severity": "info",
+			"title": "parentMessageId references unknown message",
+			"messageTemplate": "TOOL_CALL_START parentMessageId '{parentMessageId}' matches no message observed in this stream",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallstart",
+			"specQuote": "The optional parentMessageId allows linking the tool call to a specific message in the conversation, providing context for why the tool is being used.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"specQuestion": "SQ-11",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI301",
+			"severity": "info",
+			"title": "STATE_DELTA before any STATE_SNAPSHOT",
+			"messageTemplate": "STATE_DELTA precedes any STATE_SNAPSHOT; the base it applies to is not observable on this stream",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#statesnapshot",
+			"specQuote": "This event is typically sent at the beginning of an interaction or when synchronization is needed.",
+			"since": "0.x",
+			"feature": "shared-state",
+			"specQuestion": "SQ-1",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI302",
+			"severity": "error",
+			"title": "STATE_DELTA failed to apply",
+			"messageTemplate": "STATE_DELTA failed to apply: {error}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#statedelta",
+			"specQuote": "Each delta represents specific changes to apply to the current state model.",
+			"since": "0.x",
+			"feature": "shared-state",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI303",
+			"severity": "error",
+			"title": "STATE_DELTA is not a valid RFC 6902 patch document",
+			"messageTemplate": "STATE_DELTA is not a valid RFC 6902 patch document: {error}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#statedelta",
+			"specQuote": "The StateDelta event contains incremental updates to the agent's state in the form of JSON Patch operations (as defined in RFC 6902).",
+			"since": "0.x",
+			"feature": "shared-state",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI304",
+			"severity": "info",
+			"title": "Mid-run STATE_SNAPSHOT discards accumulated deltas",
+			"messageTemplate": "STATE_SNAPSHOT replaces state previously built from {deltaCount} delta(s)",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#statesnapshot",
+			"specQuote": "This event is typically sent at the beginning of an interaction or when synchronization is needed.",
+			"since": "0.x",
+			"feature": "shared-state",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI305",
+			"severity": "warning",
+			"title": "Shared state declared but never established",
+			"messageTemplate": "features include 'shared-state' but no STATE_SNAPSHOT was emitted",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#state-management-events",
+			"specQuote": "These events are used to manage and synchronize the agent's state with the frontend.",
+			"since": "0.x",
+			"feature": "shared-state",
+			"requiresFeature": true,
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI401",
+			"severity": "error",
+			"title": "REASONING_MESSAGE_CONTENT without start",
+			"messageTemplate": "REASONING_MESSAGE_CONTENT for messageId '{messageId}' with no open REASONING_MESSAGE_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#reasoningmessagecontent",
+			"specQuote": "Multiple content events with the same messageId should be concatenated to form the complete visible reasoning.",
+			"since": "0.x",
+			"specQuestion": "SQ-4",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI402",
+			"severity": "warning",
+			"title": "Reasoning unterminated at run end",
+			"messageTemplate": "{startType} messageId '{messageId}' never ended",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#reasoning-events",
+			"specQuote": "Reasoning events support LLM reasoning visibility and continuity, enabling chain-of-thought reasoning while maintaining privacy.",
+			"since": "0.x",
+			"specQuestion": "SQ-4",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI501",
+			"severity": "error",
+			"title": "Malformed SSE framing",
+			"messageTemplate": "Malformed SSE framing: {detail}",
+			"specUrl": "https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation",
+			"since": "0.x",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI502",
+			"severity": "error",
+			"title": "Event payload is not valid JSON",
+			"messageTemplate": "Event payload is not valid JSON: {error}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#base-event-properties",
+			"specQuote": "All events share a common set of base properties.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI503",
+			"severity": "error",
+			"title": "Unknown event type",
+			"messageTemplate": "Unknown event type '{type}' (not in @ag-ui/core v{sdkVersion}, and not RAW or CUSTOM)",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#event-types-overview",
+			"specQuote": "Events in the protocol are categorized by their purpose.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI504",
+			"severity": "error",
+			"title": "Event fails schema validation for its declared type",
+			"messageTemplate": "{type}: {detail}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#base-event-properties",
+			"specQuote": "All events share a common set of base properties.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI505",
+			"severity": "warning",
+			"title": "Unexpected Content-Type",
+			"messageTemplate": "Content-Type '{contentType}' is neither text/event-stream nor application/x-ndjson",
+			"specUrl": "https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model",
+			"since": "0.x",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI506",
+			"severity": "info",
+			"title": "No keepalive frame within the configured window",
+			"messageTemplate": "No event or keepalive frame for {seconds}s",
+			"specUrl": "https://docs.ag-ui.com/concepts/architecture#standard-http-client",
+			"since": "0.x",
+			"specQuestion": "SQ-5",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI507",
+			"severity": "info",
+			"title": "Response appears buffered rather than incrementally flushed",
+			"messageTemplate": "Response appears buffered: {detail}",
+			"specUrl": "https://docs.ag-ui.com/concepts/architecture#standard-http-client",
+			"since": "0.x",
+			"specQuestion": "SQ-5",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI508",
+			"severity": "error",
+			"title": "Stream ended without a terminal event",
+			"messageTemplate": "Connection ended mid-run '{runId}' without RUN_FINISHED or RUN_ERROR",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runfinished",
+			"specQuote": "Every run terminates with either RunFinished or RunError.",
+			"since": "0.x",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI901",
+			"severity": "info",
+			"title": "RAW event wraps a typed AG-UI event",
+			"messageTemplate": "RAW event wraps an event of type '{wrappedType}', which has a typed AG-UI equivalent",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#raw",
+			"specQuote": "The Raw event acts as a container for events originating from external systems or sources that don't natively follow the Agent UI Protocol.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI902",
+			"severity": "info",
+			"title": "Events carry no timestamps",
+			"messageTemplate": "None of the {eventCount} events carry the optional timestamp property",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#base-event-properties",
+			"specQuote": "timestamp: Optional timestamp indicating when the event was created",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI903",
+			"severity": "info",
+			"title": "CUSTOM event name is not namespaced",
+			"messageTemplate": "CUSTOM event name '{name}' has no namespace prefix (e.g. 'vendor.event')",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#custom",
+			"specQuote": "Teams should document their custom events to ensure consistent implementation across frontends and agents.",
+			"since": "0.x",
+			"specQuestion": "SQ-14",
+			"checkedIn": "core"
+		}
+	]
+};
+//#endregion
+//#region src/rules/catalog.ts
+const SEVERITIES = [
+	"error",
+	"warning",
+	"info"
+];
+const LAYERS = ["core", "transport"];
+/** Validates catalog data and returns it typed. Throws on structural problems. */
+function validateCatalog(data) {
+	const problems = [];
+	const cat = data;
+	if (typeof cat !== "object" || cat === null || !Array.isArray(cat.rules)) throw new Error("rule catalog: expected an object with a rules array");
+	const seen = /* @__PURE__ */ new Set();
+	for (const rule of cat.rules) {
+		const where = rule?.id ?? "<missing id>";
+		if (!/^AGUI\d{3}$/.test(rule.id ?? "")) problems.push(`${where}: id must match AGUI###`);
+		if (seen.has(rule.id)) problems.push(`${where}: duplicate id`);
+		seen.add(rule.id);
+		if (!SEVERITIES.includes(rule.severity)) problems.push(`${where}: bad severity '${rule.severity}'`);
+		if (!rule.title) problems.push(`${where}: missing title`);
+		if (!rule.messageTemplate) problems.push(`${where}: missing messageTemplate`);
+		if (!rule.specUrl?.startsWith("https://")) problems.push(`${where}: specUrl must be an https URL`);
+		if (!rule.since) problems.push(`${where}: missing since`);
+		if (!LAYERS.includes(rule.checkedIn)) problems.push(`${where}: bad checkedIn '${rule.checkedIn}'`);
+		if (rule.requiresFeature && !rule.feature) problems.push(`${where}: requiresFeature without feature`);
+	}
+	if (problems.length > 0) throw new Error(`rule catalog is invalid:\n  ${problems.join("\n  ")}`);
+	return cat;
+}
+const CATALOG = validateCatalog(catalog_default);
+const RULES = new Map(CATALOG.rules.map((r) => [r.id, r]));
+/** Fills a rule's messageTemplate. Unknown placeholders are left intact. */
+function formatMessage(rule, params) {
+	return rule.messageTemplate.replace(/\{(\w+)\}/g, (whole, key) => key in params ? String(params[key]) : whole);
+}
+//#endregion
+//#region src/report/sarif.ts
+const LEVEL = {
+	error: "error",
+	warning: "warning",
+	info: "note"
+};
+function toSarif(report, opts) {
+	const rules = /* @__PURE__ */ new Map();
+	for (const d of report.diagnostics) {
+		if (rules.has(d.rule)) continue;
+		const entry = {
+			id: d.rule,
+			helpUri: d.specUrl
+		};
+		const catalog = RULES.get(d.rule);
+		if (catalog !== void 0) {
+			entry.shortDescription = { text: catalog.title };
+			entry.defaultConfiguration = { level: LEVEL[catalog.severity] };
+		}
+		rules.set(d.rule, entry);
+	}
+	const results = report.diagnostics.map((d) => ({
+		ruleId: d.rule,
+		level: LEVEL[d.severity],
+		message: { text: d.message },
+		locations: opts.artifactUri !== void 0 && d.eventIndex >= 0 ? [{ physicalLocation: {
+			artifactLocation: { uri: opts.artifactUri },
+			region: { startLine: d.eventIndex + 1 }
+		} }] : []
+	}));
+	return {
+		$schema: "https://docs.oasis-open.org/sarif/sarif/v2.1.0/os/schemas/sarif-schema-2.1.0.json",
+		version: "2.1.0",
+		runs: [{
+			tool: { driver: {
+				name: "ag-ui-validate",
+				version: opts.toolVersion,
+				informationUri: "https://github.com/langport-dev/ag-ui-validate",
+				rules: [...rules.values()]
+			} },
+			results
+		}]
+	};
+}
+//#endregion
+//#region src/report/junit.ts
+function esc(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function toJUnit(report, opts) {
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>"];
+	const suite = esc(opts.name);
+	if (report.diagnostics.length === 0) {
+		lines.push("<testsuites name=\"ag-ui-validate\" tests=\"1\" failures=\"0\" errors=\"0\" skipped=\"0\">");
+		lines.push(`  <testsuite name="${suite}" tests="1" failures="0" errors="0" skipped="0">`);
+		lines.push(`    <testcase name="AG-UI conformance: no violations across ${report.eventCount} events" classname="${suite}"/>`);
+		lines.push("  </testsuite>");
+		lines.push("</testsuites>");
+		return `${lines.join("\n")}\n`;
+	}
+	const failures = report.diagnostics.filter((d) => d.severity === "error").length;
+	const skipped = report.diagnostics.length - failures;
+	const counts = `tests="${report.diagnostics.length}" failures="${failures}" errors="0" skipped="${skipped}"`;
+	lines.push(`<testsuites name="ag-ui-validate" ${counts}>`);
+	lines.push(`  <testsuite name="${suite}" ${counts}>`);
+	for (const d of report.diagnostics) {
+		const where = d.eventIndex >= 0 ? `event ${d.eventIndex}` : "stream";
+		const name = esc(`${d.rule} (${where})`);
+		lines.push(`    <testcase name="${name}" classname="${suite}">`);
+		const body = `${esc(d.message)}\n${esc(d.specUrl)}`;
+		if (d.severity === "error") lines.push(`      <failure message="${esc(d.message)}">${body}</failure>`);
+		else lines.push(`      <skipped message="${esc(`${d.severity}: ${d.message}`)}">${body}</skipped>`);
+		lines.push("    </testcase>");
+	}
+	lines.push("  </testsuite>");
+	lines.push("</testsuites>");
+	return `${lines.join("\n")}\n`;
+}
+//#endregion
+//#region src/protocol/event-table.ts
+/** Version of @ag-ui/core this table was derived from. */
+const SDK_VERSION = "0.0.58";
+/** Canonical wire event types and their schemas, derived from @ag-ui/core. */
+const EVENT_TABLE = {
+	"TEXT_MESSAGE_START": {
+		category: "text",
+		specUrl: "https://docs.ag-ui.com/concepts/events#textmessagestart",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"role": {
+				kind: "string",
+				required: false,
+				enum: [
+					"developer",
+					"system",
+					"assistant",
+					"user"
+				]
+			},
+			"name": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"TEXT_MESSAGE_CONTENT": {
+		category: "text",
+		specUrl: "https://docs.ag-ui.com/concepts/events#textmessagecontent",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"delta": {
+				kind: "string",
+				required: true
+			}
+		}
+	},
+	"TEXT_MESSAGE_END": {
+		category: "text",
+		specUrl: "https://docs.ag-ui.com/concepts/events#textmessageend",
+		fields: { "messageId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"TEXT_MESSAGE_CHUNK": {
+		category: "text",
+		specUrl: "https://docs.ag-ui.com/concepts/events#textmessagechunk",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: false
+			},
+			"role": {
+				kind: "string",
+				required: false,
+				enum: [
+					"developer",
+					"system",
+					"assistant",
+					"user"
+				]
+			},
+			"delta": {
+				kind: "string",
+				required: false
+			},
+			"name": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"TOOL_CALL_START": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallstart",
+		fields: {
+			"toolCallId": {
+				kind: "string",
+				required: true
+			},
+			"toolCallName": {
+				kind: "string",
+				required: true
+			},
+			"parentMessageId": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"TOOL_CALL_ARGS": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallargs",
+		fields: {
+			"toolCallId": {
+				kind: "string",
+				required: true
+			},
+			"delta": {
+				kind: "string",
+				required: true
+			}
+		}
+	},
+	"TOOL_CALL_END": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallend",
+		fields: { "toolCallId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"TOOL_CALL_CHUNK": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallchunk",
+		fields: {
+			"toolCallId": {
+				kind: "string",
+				required: false
+			},
+			"toolCallName": {
+				kind: "string",
+				required: false
+			},
+			"parentMessageId": {
+				kind: "string",
+				required: false
+			},
+			"delta": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"TOOL_CALL_RESULT": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallresult",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"toolCallId": {
+				kind: "string",
+				required: true
+			},
+			"content": {
+				kind: "string",
+				required: true
+			},
+			"role": {
+				kind: "string",
+				required: false,
+				enum: ["tool"]
+			}
+		}
+	},
+	"THINKING_START": {
+		category: "thinking",
+		deprecated: "REASONING_START",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: { "title": {
+			kind: "string",
+			required: false
+		} }
+	},
+	"THINKING_END": {
+		category: "thinking",
+		deprecated: "REASONING_END",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: {}
+	},
+	"THINKING_TEXT_MESSAGE_START": {
+		category: "thinking",
+		deprecated: "REASONING_MESSAGE_START",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: {}
+	},
+	"THINKING_TEXT_MESSAGE_CONTENT": {
+		category: "thinking",
+		deprecated: "REASONING_MESSAGE_CONTENT",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: { "delta": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"THINKING_TEXT_MESSAGE_END": {
+		category: "thinking",
+		deprecated: "REASONING_MESSAGE_END",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: {}
+	},
+	"STATE_SNAPSHOT": {
+		category: "state",
+		specUrl: "https://docs.ag-ui.com/concepts/events#statesnapshot",
+		fields: { "snapshot": {
+			kind: "any",
+			required: true
+		} }
+	},
+	"STATE_DELTA": {
+		category: "state",
+		specUrl: "https://docs.ag-ui.com/concepts/events#statedelta",
+		fields: { "delta": {
+			kind: "array",
+			required: true
+		} }
+	},
+	"MESSAGES_SNAPSHOT": {
+		category: "state",
+		specUrl: "https://docs.ag-ui.com/concepts/events#messagessnapshot",
+		fields: { "messages": {
+			kind: "array",
+			required: true
+		} }
+	},
+	"ACTIVITY_SNAPSHOT": {
+		category: "activity",
+		specUrl: "https://docs.ag-ui.com/concepts/events#activitysnapshot",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"activityType": {
+				kind: "string",
+				required: true
+			},
+			"content": {
+				kind: "object",
+				required: true
+			},
+			"replace": {
+				kind: "boolean",
+				required: false
+			}
+		}
+	},
+	"ACTIVITY_DELTA": {
+		category: "activity",
+		specUrl: "https://docs.ag-ui.com/concepts/events#activitydelta",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"activityType": {
+				kind: "string",
+				required: true
+			},
+			"patch": {
+				kind: "array",
+				required: true
+			}
+		}
+	},
+	"RAW": {
+		category: "special",
+		specUrl: "https://docs.ag-ui.com/concepts/events#raw",
+		fields: {
+			"event": {
+				kind: "any",
+				required: true
+			},
+			"source": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"CUSTOM": {
+		category: "special",
+		specUrl: "https://docs.ag-ui.com/concepts/events#custom",
+		fields: {
+			"name": {
+				kind: "string",
+				required: true
+			},
+			"value": {
+				kind: "any",
+				required: true
+			}
+		}
+	},
+	"RUN_STARTED": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#runstarted",
+		fields: {
+			"threadId": {
+				kind: "string",
+				required: true
+			},
+			"runId": {
+				kind: "string",
+				required: true
+			},
+			"parentRunId": {
+				kind: "string",
+				required: false
+			},
+			"input": {
+				kind: "object",
+				required: false
+			}
+		}
+	},
+	"RUN_FINISHED": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#runfinished",
+		fields: {
+			"threadId": {
+				kind: "string",
+				required: true
+			},
+			"runId": {
+				kind: "string",
+				required: true
+			},
+			"result": {
+				kind: "any",
+				required: false
+			},
+			"outcome": {
+				kind: "object",
+				required: false
+			},
+			"usage": {
+				kind: "array",
+				required: false
+			}
+		}
+	},
+	"RUN_ERROR": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#runerror",
+		fields: {
+			"message": {
+				kind: "string",
+				required: true
+			},
+			"code": {
+				kind: "string",
+				required: false
+			},
+			"usage": {
+				kind: "array",
+				required: false
+			}
+		}
+	},
+	"STEP_STARTED": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#stepstarted",
+		fields: { "stepName": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"STEP_FINISHED": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#stepfinished",
+		fields: { "stepName": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"REASONING_START": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningstart",
+		fields: { "messageId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"REASONING_MESSAGE_START": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningmessagestart",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"role": {
+				kind: "string",
+				required: true,
+				enum: ["reasoning"]
+			}
+		}
+	},
+	"REASONING_MESSAGE_CONTENT": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningmessagecontent",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"delta": {
+				kind: "string",
+				required: true
+			}
+		}
+	},
+	"REASONING_MESSAGE_END": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningmessageend",
+		fields: { "messageId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"REASONING_MESSAGE_CHUNK": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningmessagechunk",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: false
+			},
+			"delta": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"REASONING_END": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningend",
+		fields: { "messageId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"REASONING_ENCRYPTED_VALUE": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningencryptedvalue",
+		fields: {
+			"subtype": {
+				kind: "string",
+				required: true,
+				enum: ["tool-call", "message"]
+			},
+			"entityId": {
+				kind: "string",
+				required: true
+			},
+			"encryptedValue": {
+				kind: "string",
+				required: true
+			}
+		}
+	}
+};
+/** All canonical wire `type` values, in @ag-ui/core enum order. */
+const EVENT_TYPES = Object.keys(EVENT_TABLE);
+/**
+* Wire types documented as drafts (https://docs.ag-ui.com/drafts/overview) but
+* not yet in @ag-ui/core. Not errors: reported at info severity.
+*/
+const DRAFT_EVENT_TYPES = ["META"];
+//#endregion
+//#region src/rules/checks/context.ts
+function newRunState(init) {
+	return {
+		...init,
+		terminal: null,
+		openMessages: /* @__PURE__ */ new Map(),
+		closedMessages: /* @__PURE__ */ new Map(),
+		knownMessageIds: /* @__PURE__ */ new Set(),
+		openToolCalls: /* @__PURE__ */ new Map(),
+		closedToolCalls: /* @__PURE__ */ new Map(),
+		knownToolCallIds: /* @__PURE__ */ new Set(),
+		openSteps: /* @__PURE__ */ new Map(),
+		openReasoningBlocks: /* @__PURE__ */ new Map(),
+		openReasoningMessages: /* @__PURE__ */ new Map(),
+		state: {
+			known: false,
+			value: void 0,
+			deltasSinceSnapshot: 0,
+			snapshotSeen: false,
+			agui301Fired: false
+		},
+		textChunk: null,
+		toolChunk: null,
+		reasoningChunk: null
+	};
+}
+/** Reads a field only if it is a string (schema problems already reported). */
+function str(event, field) {
+	const v = event[field];
+	return typeof v === "string" ? v : void 0;
+}
+//#endregion
+//#region src/rules/checks/lifecycle.ts
+function handleStepEvent(api) {
+	const { type, event, run, emit, index } = api;
+	const stepName = str(event, "stepName");
+	if (stepName === void 0) return;
+	if (type === "STEP_STARTED") {
+		const open = run.openSteps.get(stepName);
+		if (open !== void 0) open.count += 1;
+		else run.openSteps.set(stepName, {
+			count: 1,
+			firstIndex: index
+		});
+		return;
+	}
+	if (type === "STEP_FINISHED") {
+		const open = run.openSteps.get(stepName);
+		if (open === void 0) {
+			emit("AGUI006", { stepName }, { pointer: "/stepName" });
+			return;
+		}
+		open.count -= 1;
+		if (open.count === 0) run.openSteps.delete(stepName);
+	}
+}
+/** AGUI008 — RUN_FINISHED must carry the ids RUN_STARTED established. */
+function checkRunIdStability(api) {
+	const { event, run, emit } = api;
+	if (run.implicit) return;
+	for (const field of ["threadId", "runId"]) {
+		const actual = str(api.event, field);
+		const expected = field === "threadId" ? run.threadId : run.runId;
+		if (actual !== void 0 && expected !== null && actual !== expected) emit("AGUI008", {
+			field,
+			actual,
+			expected
+		}, {
+			pointer: `/${field}`,
+			relatedEventIndex: run.startIndex
+		});
+	}
+}
+/** AGUI007 — open steps when the run reaches a clean end. */
+function endOfRunSteps(run, emit, atIndex) {
+	for (const [stepName, open] of run.openSteps) emit("AGUI007", { stepName }, {
+		eventIndex: atIndex,
+		relatedEventIndex: open.firstIndex
+	});
+}
+//#endregion
+//#region src/rules/checks/reasoning.ts
+function handleReasoningEvent(api) {
+	const { type, event, run, emit, index } = api;
+	switch (type) {
+		case "REASONING_START": {
+			const id = str(event, "messageId");
+			if (id !== void 0) run.openReasoningBlocks.set(id, index);
+			return;
+		}
+		case "REASONING_END": {
+			const id = str(event, "messageId");
+			if (id !== void 0) run.openReasoningBlocks.delete(id);
+			return;
+		}
+		case "REASONING_MESSAGE_START": {
+			const id = str(event, "messageId");
+			if (id !== void 0) run.openReasoningMessages.set(id, index);
+			return;
+		}
+		case "REASONING_MESSAGE_CONTENT": {
+			const id = str(event, "messageId");
+			if (id === void 0) return;
+			const openChunk = run.reasoningChunk !== null && run.reasoningChunk.messageId === id;
+			if (!run.openReasoningMessages.has(id) && !openChunk) emit("AGUI401", { messageId: id }, { pointer: "/messageId" });
+			return;
+		}
+		case "REASONING_MESSAGE_END": {
+			const id = str(event, "messageId");
+			if (id !== void 0) run.openReasoningMessages.delete(id);
+			return;
+		}
+		case "REASONING_MESSAGE_CHUNK": {
+			const id = str(event, "messageId");
+			if (id === void 0) {
+				if (run.reasoningChunk === null) {
+					emit("AGUI504", {
+						type,
+						detail: "first REASONING_MESSAGE_CHUNK must include messageId"
+					}, { pointer: "/messageId" });
+					return;
+				}
+				if (event.delta === "") run.reasoningChunk = null;
+				return;
+			}
+			if (run.reasoningChunk !== null && run.reasoningChunk.messageId !== id) run.reasoningChunk = null;
+			if (event.delta === "") {
+				run.reasoningChunk = null;
+				return;
+			}
+			if (run.reasoningChunk === null) run.reasoningChunk = {
+				messageId: id,
+				startIndex: index
+			};
+			return;
+		}
+	}
+}
+/** Chunked reasoning also closes on any non-reasoning event (documented). */
+function closeReasoningChunk(run) {
+	run.reasoningChunk = null;
+}
+/** AGUI402 — unterminated reasoning at a clean run end. */
+function endOfRunReasoning(run, emit, atIndex) {
+	for (const [id, startIndex] of run.openReasoningBlocks) emit("AGUI402", {
+		startType: "REASONING_START",
+		messageId: id
+	}, {
+		eventIndex: atIndex,
+		relatedEventIndex: startIndex
+	});
+	for (const [id, startIndex] of run.openReasoningMessages) emit("AGUI402", {
+		startType: "REASONING_MESSAGE_START",
+		messageId: id
+	}, {
+		eventIndex: atIndex,
+		relatedEventIndex: startIndex
+	});
+}
+//#endregion
+//#region src/protocol/jsonpatch.ts
+const OPS = [
+	"add",
+	"remove",
+	"replace",
+	"move",
+	"copy",
+	"test"
+];
+/** RFC 6901: "" → whole document; "/a/b" → ["a", "b"]. Returns null when invalid. */
+function parsePointer(pointer) {
+	if (typeof pointer !== "string") return null;
+	if (pointer === "") return [];
+	if (!pointer.startsWith("/")) return null;
+	return pointer.slice(1).split("/").map((t) => t.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+/** Structural validation of a patch document, without applying it. */
+function validatePatchShape(patch) {
+	if (!Array.isArray(patch)) return {
+		error: "patch document must be an array of operations",
+		opIndex: -1,
+		pointer: ""
+	};
+	for (let i = 0; i < patch.length; i++) {
+		const op = patch[i];
+		if (typeof op !== "object" || op === null || Array.isArray(op)) return {
+			error: `operation ${i} is not an object`,
+			opIndex: i,
+			pointer: `/${i}`
+		};
+		const o = op;
+		if (!OPS.includes(o.op)) return {
+			error: `operation ${i} has invalid op '${String(o.op)}'`,
+			opIndex: i,
+			pointer: `/${i}/op`
+		};
+		if (parsePointer(o.path) === null) return {
+			error: `operation ${i} (${String(o.op)}) has invalid path`,
+			opIndex: i,
+			pointer: `/${i}/path`
+		};
+		if ((o.op === "add" || o.op === "replace" || o.op === "test") && !("value" in o)) return {
+			error: `operation ${i} (${String(o.op)}) is missing value`,
+			opIndex: i,
+			pointer: `/${i}`
+		};
+		if ((o.op === "move" || o.op === "copy") && parsePointer(o.from) === null) return {
+			error: `operation ${i} (${String(o.op)}) is missing or has invalid from`,
+			opIndex: i,
+			pointer: `/${i}`
+		};
+	}
+	return null;
+}
+function clone(value) {
+	if (Array.isArray(value)) return value.map(clone);
+	if (typeof value === "object" && value !== null) {
+		const out = {};
+		for (const [k, v] of Object.entries(value)) out[k] = clone(v);
+		return out;
+	}
+	return value;
+}
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+	if (typeof a === "object" && a !== null && typeof b === "object" && b !== null && !Array.isArray(a) && !Array.isArray(b)) {
+		const ka = Object.keys(a);
+		const kb = Object.keys(b);
+		return ka.length === kb.length && ka.every((k) => deepEqual(a[k], b[k]));
+	}
+	return false;
+}
+function arrayIndex(token, length, allowAppend) {
+	if (allowAppend && token === "-") return length;
+	if (!/^(0|[1-9]\d*)$/.test(token)) return null;
+	const i = Number(token);
+	return i > length ? null : i;
+}
+function locate(doc, tokens, forAdd) {
+	if (tokens.length === 0) return {
+		parent: null,
+		key: "",
+		exists: true,
+		value: doc
+	};
+	let current = doc;
+	for (let i = 0; i < tokens.length - 1; i++) {
+		const token = tokens[i];
+		if (Array.isArray(current)) {
+			const idx = arrayIndex(token, current.length, false);
+			if (idx === null || idx >= current.length) return `path segment '/${token}' does not exist`;
+			current = current[idx];
+		} else if (typeof current === "object" && current !== null) {
+			const obj = current;
+			if (!(token in obj)) return `path segment '/${token}' does not exist`;
+			current = obj[token];
+		} else return `path segment '/${token}' is not an object or array`;
+	}
+	const last = tokens[tokens.length - 1];
+	if (Array.isArray(current)) {
+		const idx = arrayIndex(last, current.length, forAdd);
+		if (idx === null) return `'${last}' is not a valid index for an array of length ${current.length}`;
+		return {
+			parent: current,
+			key: idx,
+			exists: idx < current.length,
+			value: current[idx]
+		};
+	}
+	if (typeof current === "object" && current !== null) {
+		const obj = current;
+		return {
+			parent: obj,
+			key: last,
+			exists: last in obj,
+			value: obj[last]
+		};
+	}
+	return `target of '/${last}' is not an object or array`;
+}
+/** Applies an RFC 6902 patch. Validates shape first; never throws. */
+function applyPatch(doc, patch) {
+	const shape = validatePatchShape(patch);
+	if (shape !== null) return {
+		ok: false,
+		error: shape.error,
+		opIndex: shape.opIndex
+	};
+	let result = clone(doc);
+	const ops = patch;
+	const getAt = (pointer) => {
+		const loc = locate(result, parsePointer(pointer), false);
+		if (typeof loc === "string") return {
+			ok: false,
+			error: `${pointer}: ${loc}`
+		};
+		if (!loc.exists) return {
+			ok: false,
+			error: `${pointer} does not exist`
+		};
+		return {
+			ok: true,
+			value: loc.value
+		};
+	};
+	const setAt = (pointer, value, mustExist) => {
+		const tokens = parsePointer(pointer);
+		if (tokens.length === 0) {
+			result = value;
+			return null;
+		}
+		const loc = locate(result, tokens, !mustExist);
+		if (typeof loc === "string") return `${pointer}: ${loc}`;
+		if (mustExist && !loc.exists) return `${pointer} does not exist`;
+		if (Array.isArray(loc.parent)) {
+			if (mustExist) loc.parent[loc.key] = value;
+			else loc.parent.splice(loc.key, 0, value);
+		} else loc.parent[loc.key] = value;
+		return null;
+	};
+	const removeAt = (pointer) => {
+		const tokens = parsePointer(pointer);
+		if (tokens.length === 0) return {
+			ok: false,
+			error: "cannot remove the whole document"
+		};
+		const loc = locate(result, tokens, false);
+		if (typeof loc === "string") return {
+			ok: false,
+			error: `${pointer}: ${loc}`
+		};
+		if (!loc.exists) return {
+			ok: false,
+			error: `${pointer} does not exist`
+		};
+		if (Array.isArray(loc.parent)) loc.parent.splice(loc.key, 1);
+		else delete loc.parent[loc.key];
+		return {
+			ok: true,
+			removed: loc.value
+		};
+	};
+	for (let i = 0; i < ops.length; i++) {
+		const op = ops[i];
+		const path = op.path;
+		let error = null;
+		switch (op.op) {
+			case "add":
+				error = setAt(path, clone(op.value), false);
+				break;
+			case "replace":
+				error = setAt(path, clone(op.value), true);
+				break;
+			case "remove": {
+				const r = removeAt(path);
+				if (!r.ok) error = r.error;
+				break;
+			}
+			case "move": {
+				const from = op.from;
+				if (path.startsWith(`${from}/`)) {
+					error = `cannot move ${from} into its own child ${path}`;
+					break;
+				}
+				const r = removeAt(from);
+				if (!r.ok) {
+					error = r.error;
+					break;
+				}
+				error = setAt(path, r.removed, false);
+				break;
+			}
+			case "copy": {
+				const r = getAt(op.from);
+				if (!r.ok) {
+					error = r.error;
+					break;
+				}
+				error = setAt(path, clone(r.value), false);
+				break;
+			}
+			case "test": {
+				const r = getAt(path);
+				if (!r.ok) error = r.error;
+				else if (!deepEqual(r.value, op.value)) error = `test failed at ${path}`;
+				break;
+			}
+		}
+		if (error !== null) return {
+			ok: false,
+			error,
+			opIndex: i
+		};
+	}
+	return {
+		ok: true,
+		result
+	};
+}
+//#endregion
+//#region src/rules/checks/state.ts
+function handleStateEvent(api) {
+	const { type, event, run, stream, emit } = api;
+	switch (type) {
+		case "STATE_SNAPSHOT":
+			api.feature("shared-state");
+			if (run.state.deltasSinceSnapshot > 0) emit("AGUI304", { deltaCount: run.state.deltasSinceSnapshot }, {});
+			run.state.known = true;
+			run.state.value = event.snapshot;
+			run.state.snapshotSeen = true;
+			run.state.deltasSinceSnapshot = 0;
+			stream.anySnapshot = true;
+			return;
+		case "STATE_DELTA": {
+			api.feature("shared-state");
+			const delta = event.delta;
+			if (!Array.isArray(delta)) return;
+			const shape = validatePatchShape(delta);
+			if (shape !== null) {
+				emit("AGUI303", { error: shape.error }, { pointer: `/delta${shape.pointer}` });
+				return;
+			}
+			if (!run.state.snapshotSeen && !run.state.agui301Fired) {
+				emit("AGUI301", {}, {});
+				run.state.agui301Fired = true;
+			}
+			if (run.state.known) {
+				const applied = applyPatch(run.state.value, delta);
+				if (applied.ok) run.state.value = applied.result;
+				else emit("AGUI302", { error: applied.error }, { pointer: `/delta/${applied.opIndex}` });
+			}
+			run.state.deltasSinceSnapshot += 1;
+			return;
+		}
+		case "MESSAGES_SNAPSHOT": {
+			const messages = event.messages;
+			if (!Array.isArray(messages)) return;
+			for (const message of messages) {
+				if (typeof message !== "object" || message === null) continue;
+				const m = message;
+				if (typeof m.id === "string") run.knownMessageIds.add(m.id);
+				if (Array.isArray(m.toolCalls)) {
+					for (const call of m.toolCalls) if (typeof call === "object" && call !== null) {
+						const id = call.id;
+						if (typeof id === "string") run.knownToolCallIds.add(id);
+					}
+				}
+			}
+			return;
+		}
+	}
+}
+//#endregion
+//#region src/rules/checks/text.ts
+function handleTextEvent(api) {
+	const { type, event, run, emit, index } = api;
+	api.feature("agentic-chat");
+	switch (type) {
+		case "TEXT_MESSAGE_START": {
+			const id = str(event, "messageId");
+			if (id === void 0) return;
+			if (run.openMessages.has(id)) {
+				emit("AGUI106", { messageId: id }, {
+					pointer: "/messageId",
+					relatedEventIndex: run.openMessages.get(id).startIndex
+				});
+				return;
+			}
+			if (run.closedMessages.has(id)) {
+				emit("AGUI104", { messageId: id }, {
+					pointer: "/messageId",
+					relatedEventIndex: run.closedMessages.get(id)
+				});
+				return;
+			}
+			run.openMessages.set(id, { startIndex: index });
+			run.knownMessageIds.add(id);
+			return;
+		}
+		case "TEXT_MESSAGE_CONTENT": {
+			const id = str(event, "messageId");
+			if (id === void 0) return;
+			const open = run.openMessages.get(id);
+			if (open === void 0) {
+				const closedAt = run.closedMessages.get(id);
+				emit("AGUI101", { messageId: id }, {
+					pointer: "/messageId",
+					...closedAt !== void 0 ? { relatedEventIndex: closedAt } : {}
+				});
+				return;
+			}
+			if (event.delta === "") emit("AGUI105", { messageId: id }, {
+				pointer: "/delta",
+				relatedEventIndex: open.startIndex
+			});
+			return;
+		}
+		case "TEXT_MESSAGE_END": {
+			const id = str(event, "messageId");
+			if (id === void 0) return;
+			if (!run.openMessages.has(id)) {
+				emit("AGUI102", { messageId: id }, { pointer: "/messageId" });
+				return;
+			}
+			run.openMessages.delete(id);
+			run.closedMessages.set(id, index);
+			return;
+		}
+		case "TEXT_MESSAGE_CHUNK": {
+			const id = str(event, "messageId");
+			if (id === void 0) {
+				if (run.textChunk === null) emit("AGUI504", {
+					type,
+					detail: "first TEXT_MESSAGE_CHUNK for a message must include messageId"
+				}, { pointer: "/messageId" });
+				return;
+			}
+			if (run.openMessages.has(id)) return;
+			if (run.textChunk !== null && run.textChunk.messageId === id) return;
+			closeTextChunk(run, index);
+			if (run.closedMessages.has(id)) {
+				emit("AGUI104", { messageId: id }, {
+					pointer: "/messageId",
+					relatedEventIndex: run.closedMessages.get(id)
+				});
+				return;
+			}
+			run.textChunk = {
+				messageId: id,
+				startIndex: index
+			};
+			run.knownMessageIds.add(id);
+			return;
+		}
+	}
+}
+/** Chunk streams close implicitly on the next non-chunk event. */
+function closeTextChunk(run, atIndex) {
+	if (run.textChunk === null) return;
+	run.closedMessages.set(run.textChunk.messageId, atIndex);
+	run.textChunk = null;
+}
+/** AGUI103 — open messages when the run reaches a clean end. */
+function endOfRunText(run, emit, atIndex) {
+	for (const [id, open] of run.openMessages) emit("AGUI103", { messageId: id }, {
+		eventIndex: atIndex,
+		relatedEventIndex: open.startIndex
+	});
+}
+//#endregion
+//#region src/rules/checks/toolcalls.ts
+function handleToolCallEvent(api) {
+	const { type, event, run, emit, index } = api;
+	api.feature("backend-tool-rendering");
+	switch (type) {
+		case "TOOL_CALL_START": {
+			const id = str(event, "toolCallId");
+			if (id === void 0) return;
+			if (run.openToolCalls.has(id) || run.closedToolCalls.has(id)) {
+				const related = run.openToolCalls.get(id)?.startIndex ?? run.closedToolCalls.get(id);
+				emit("AGUI205", { toolCallId: id }, {
+					pointer: "/toolCallId",
+					relatedEventIndex: related
+				});
+				return;
+			}
+			run.openToolCalls.set(id, {
+				startIndex: index,
+				args: "",
+				sawArgs: false
+			});
+			const parent = str(event, "parentMessageId");
+			if (parent !== void 0 && !run.knownMessageIds.has(parent)) emit("AGUI208", { parentMessageId: parent }, { pointer: "/parentMessageId" });
+			return;
+		}
+		case "TOOL_CALL_ARGS": {
+			const id = str(event, "toolCallId");
+			if (id === void 0) return;
+			const open = run.openToolCalls.get(id);
+			if (open === void 0) {
+				emit("AGUI201", { toolCallId: id }, { pointer: "/toolCallId" });
+				return;
+			}
+			const delta = str(event, "delta");
+			if (delta !== void 0) {
+				open.args += delta;
+				open.sawArgs = true;
+			}
+			return;
+		}
+		case "TOOL_CALL_END": {
+			const id = str(event, "toolCallId");
+			if (id === void 0) return;
+			const open = run.openToolCalls.get(id);
+			if (open === void 0) {
+				emit("AGUI202", { toolCallId: id }, { pointer: "/toolCallId" });
+				return;
+			}
+			run.openToolCalls.delete(id);
+			run.closedToolCalls.set(id, index);
+			checkArgsJson(id, open, emit, index);
+			return;
+		}
+		case "TOOL_CALL_RESULT": {
+			const id = str(event, "toolCallId");
+			if (id !== void 0) {
+				const open = run.openToolCalls.get(id);
+				if (open !== void 0) emit("AGUI206", { toolCallId: id }, {
+					pointer: "/toolCallId",
+					relatedEventIndex: open.startIndex
+				});
+				else if (!run.closedToolCalls.has(id) && !run.knownToolCallIds.has(id)) emit("AGUI207", { toolCallId: id }, { pointer: "/toolCallId" });
+			}
+			const messageId = str(event, "messageId");
+			if (messageId !== void 0) run.knownMessageIds.add(messageId);
+			return;
+		}
+		case "TOOL_CALL_CHUNK": {
+			const id = str(event, "toolCallId");
+			const delta = str(event, "delta");
+			if (id === void 0) {
+				if (run.toolChunk === null) {
+					emit("AGUI504", {
+						type,
+						detail: "first TOOL_CALL_CHUNK for a tool call must include toolCallId and toolCallName"
+					}, { pointer: "/toolCallId" });
+					return;
+				}
+				if (delta !== void 0) {
+					run.toolChunk.args += delta;
+					run.toolChunk.sawArgs = true;
+				}
+				return;
+			}
+			const openExplicit = run.openToolCalls.get(id);
+			if (openExplicit !== void 0) {
+				if (delta !== void 0) {
+					openExplicit.args += delta;
+					openExplicit.sawArgs = true;
+				}
+				return;
+			}
+			if (run.toolChunk !== null && run.toolChunk.toolCallId === id) {
+				if (delta !== void 0) {
+					run.toolChunk.args += delta;
+					run.toolChunk.sawArgs = true;
+				}
+				return;
+			}
+			closeToolChunk(run, emit, index);
+			if (run.closedToolCalls.has(id)) {
+				emit("AGUI205", { toolCallId: id }, {
+					pointer: "/toolCallId",
+					relatedEventIndex: run.closedToolCalls.get(id)
+				});
+				return;
+			}
+			if (str(event, "toolCallName") === void 0) emit("AGUI504", {
+				type,
+				detail: "first TOOL_CALL_CHUNK for a tool call must include toolCallName"
+			}, { pointer: "/toolCallName" });
+			run.toolChunk = {
+				toolCallId: id,
+				startIndex: index,
+				args: delta ?? "",
+				sawArgs: delta !== void 0 && delta.length > 0
+			};
+			return;
+		}
+	}
+}
+function checkArgsJson(id, call, emit, atIndex) {
+	if (!call.sawArgs || call.args.length === 0) return;
+	try {
+		JSON.parse(call.args);
+	} catch (e) {
+		emit("AGUI204", {
+			toolCallId: id,
+			error: e instanceof Error ? e.message : String(e)
+		}, {
+			eventIndex: atIndex,
+			relatedEventIndex: call.startIndex
+		});
+	}
+}
+/** Chunk streams close implicitly on the next non-chunk event. */
+function closeToolChunk(run, emit, atIndex) {
+	if (run.toolChunk === null) return;
+	const { toolCallId, startIndex, args, sawArgs } = run.toolChunk;
+	run.toolChunk = null;
+	run.closedToolCalls.set(toolCallId, atIndex);
+	checkArgsJson(toolCallId, {
+		startIndex,
+		args,
+		sawArgs
+	}, emit, atIndex);
+}
+/** AGUI203 — open tool calls when the run reaches a clean end. */
+function endOfRunToolCalls(run, emit, atIndex) {
+	for (const [id, open] of run.openToolCalls) emit("AGUI203", { toolCallId: id }, {
+		eventIndex: atIndex,
+		relatedEventIndex: open.startIndex
+	});
+}
+//#endregion
+//#region src/rules/checks/transport.ts
+const TRANSPORT_SKIP_REASON = "transport-layer rule; only checkable against a live connection (validated by ag-ui-validate/transport)";
+const TRANSPORT_RULE_IDS = CATALOG.rules.filter((r) => r.checkedIn === "transport").map((r) => r.id);
+//#endregion
+//#region src/types.ts
+const CANONICAL_FEATURES = [
+	"agentic-chat",
+	"backend-tool-rendering",
+	"human-in-the-loop",
+	"agentic-generative-ui",
+	"tool-based-generative-ui",
+	"shared-state",
+	"predictive-state-updates"
+];
+//#endregion
+//#region src/index.ts
+const DRAFTS_META_URL = "https://docs.ag-ui.com/drafts/meta-events";
+const NOT_INFERABLE = ["agentic-generative-ui", "tool-based-generative-ui"];
+/** "runStarted" → "RUN_STARTED": case-insensitive match against wire types. */
+const CANONICAL_BY_SQUASHED = new Map(EVENT_TYPES.map((t) => [t.replace(/_/g, "").toLowerCase(), t]));
+function describeValue(v) {
+	if (v === null) return "null";
+	if (Array.isArray(v)) return "array";
+	return typeof v;
+}
+function createValidator(opts = {}) {
+	const overrides = opts.severityOverrides ?? {};
+	const declaredFeatures = new Set(opts.features ?? []);
+	const layers = /* @__PURE__ */ new Set(["core", ...opts.layers ?? []]);
+	const diagnostics = [];
+	const internalErrors = [];
+	const explicitSkips = /* @__PURE__ */ new Map();
+	const stream = {
+		eventCount: 0,
+		sawTimestamp: false,
+		anySnapshot: false,
+		agui001Fired: false,
+		features: /* @__PURE__ */ new Set()
+	};
+	let run = null;
+	let finalized = false;
+	function mkEmit(batch, current) {
+		return (ruleId, params, extra = {}) => {
+			const rule = RULES.get(ruleId);
+			if (rule === void 0) {
+				internalErrors.push(`emit() for unknown rule ${ruleId}`);
+				return;
+			}
+			const override = overrides[ruleId];
+			if (override === "off") return;
+			const severity = override ?? extra.severity ?? rule.severity;
+			const aboutCurrentEvent = extra.eventIndex === void 0 && current !== null;
+			const diag = {
+				rule: ruleId,
+				severity,
+				message: formatMessage(rule, params) + (extra.messageSuffix ?? ""),
+				eventIndex: extra.eventIndex ?? current?.index ?? -1,
+				specUrl: extra.specUrl ?? rule.specUrl
+			};
+			if (aboutCurrentEvent) diag.eventType = current.type;
+			if (extra.pointer !== void 0) diag.pointer = extra.pointer;
+			if (extra.relatedEventIndex !== void 0) diag.relatedEventIndex = extra.relatedEventIndex;
+			diagnostics.push(diag);
+			batch.push(diag);
+		};
+	}
+	function validateSchema(type, spec, ev, emit) {
+		for (const [field, fs] of Object.entries(spec.fields)) {
+			const v = ev[field];
+			if (v === void 0) {
+				if (fs.required) emit("AGUI504", {
+					type,
+					detail: `missing required field '${field}' (${fs.kind})`
+				}, { pointer: `/${field}` });
+				continue;
+			}
+			let kindOk = true;
+			switch (fs.kind) {
+				case "string":
+				case "number":
+				case "boolean":
+					kindOk = typeof v === fs.kind;
+					break;
+				case "array":
+					kindOk = Array.isArray(v);
+					break;
+				case "object": kindOk = typeof v === "object" && v !== null && !Array.isArray(v);
+			}
+			if (!kindOk) {
+				emit("AGUI504", {
+					type,
+					detail: `field '${field}' must be ${fs.kind === "array" ? "an" : "a"} ${fs.kind}, got ${describeValue(v)}`
+				}, { pointer: `/${field}` });
+				continue;
+			}
+			if (fs.enum !== void 0 && typeof v === "string" && !fs.enum.includes(v)) emit("AGUI504", {
+				type,
+				detail: `field '${field}' must be one of ${fs.enum.join("|")}, got '${v}'`
+			}, { pointer: `/${field}` });
+		}
+	}
+	/** Chunk streams close implicitly on any event of a different type. */
+	function closeChunks(r, emit, atIndex, except) {
+		if (except !== "TEXT_MESSAGE_CHUNK") closeTextChunk(r, atIndex);
+		if (except !== "TOOL_CALL_CHUNK") closeToolChunk(r, emit, atIndex);
+		if (except !== "REASONING_MESSAGE_CHUNK") closeReasoningChunk(r);
+	}
+	/** Unterminated-at-run-end rules. Only on a *clean* end (RUN_FINISHED or a
+	* stream that just stops): after RUN_ERROR, open streams are expected
+	* debris of the failure, and flagging them would manufacture noise. */
+	function endOfRunChecks(r, emit, atIndex) {
+		endOfRunText(r, emit, atIndex);
+		endOfRunToolCalls(r, emit, atIndex);
+		endOfRunSteps(r, emit, atIndex);
+		endOfRunReasoning(r, emit, atIndex);
+	}
+	/** Opens the implicit run scope for streams that never announced one. */
+	function ensureRun(index, type, emit) {
+		if (run === null) {
+			if (!stream.agui001Fired) {
+				emit("AGUI001", { type }, {});
+				stream.agui001Fired = true;
+			}
+			run = newRunState({
+				runId: null,
+				threadId: null,
+				startIndex: index,
+				implicit: true
+			});
+		}
+		return run;
+	}
+	function processEvent(input, batch) {
+		const index = stream.eventCount;
+		stream.eventCount += 1;
+		let parsed = input;
+		if (typeof input === "string") try {
+			parsed = JSON.parse(input);
+		} catch (e) {
+			mkEmit(batch, {
+				index,
+				type: ""
+			})("AGUI502", { error: e instanceof Error ? e.message : String(e) });
+			return;
+		}
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+			mkEmit(batch, {
+				index,
+				type: ""
+			})("AGUI502", { error: `payload is ${describeValue(parsed)}, expected a JSON object` });
+			return;
+		}
+		const ev = parsed;
+		if (typeof ev.type !== "string") {
+			mkEmit(batch, {
+				index,
+				type: ""
+			})("AGUI504", {
+				type: "(untyped)",
+				detail: "event has no string 'type' property"
+			}, { pointer: "/type" });
+			return;
+		}
+		const type = ev.type;
+		const emit = mkEmit(batch, {
+			index,
+			type
+		});
+		if ("timestamp" in ev && ev.timestamp !== void 0) {
+			if (typeof ev.timestamp === "number") stream.sawTimestamp = true;
+			else emit("AGUI504", {
+				type,
+				detail: `field 'timestamp' must be a number, got ${describeValue(ev.timestamp)}`
+			}, { pointer: "/timestamp" });
+		}
+		const spec = EVENT_TABLE[type];
+		if (spec === void 0) {
+			if (DRAFT_EVENT_TYPES.includes(type)) emit("AGUI503", {
+				type,
+				sdkVersion: SDK_VERSION
+			}, {
+				severity: "info",
+				specUrl: DRAFTS_META_URL,
+				messageSuffix: " — documented draft event type, not yet in @ag-ui/core"
+			});
+			else {
+				const canonical = CANONICAL_BY_SQUASHED.get(type.replace(/[_\-\s]/g, "").toLowerCase());
+				emit("AGUI503", {
+					type,
+					sdkVersion: SDK_VERSION
+				}, { ...canonical !== void 0 ? { messageSuffix: ` — did you mean '${canonical}'? AG-UI wire types use SCREAMING_SNAKE_CASE` } : {} });
+			}
+			return;
+		}
+		validateSchema(type, spec, ev, emit);
+		if (type === "RUN_STARTED") {
+			if (run === null) run = newRunState({
+				runId: str(ev, "runId") ?? null,
+				threadId: str(ev, "threadId") ?? null,
+				startIndex: index,
+				implicit: false
+			});
+			else if (run.terminal !== null) run = newRunState({
+				runId: str(ev, "runId") ?? null,
+				threadId: str(ev, "threadId") ?? null,
+				startIndex: index,
+				implicit: false
+			});
+			else if (run.implicit) {
+				closeChunks(run, emit, index);
+				run.implicit = false;
+				run.runId = str(ev, "runId") ?? null;
+				run.threadId = str(ev, "threadId") ?? null;
+			} else {
+				closeChunks(run, emit, index);
+				emit("AGUI002", { runId: str(ev, "runId") ?? "(missing)" }, { relatedEventIndex: run.startIndex });
+			}
+			return;
+		}
+		const r = ensureRun(index, type, emit);
+		if (r.terminal !== null) {
+			const terminalType = r.terminal.type;
+			if ((type === "RUN_FINISHED" || type === "RUN_ERROR") && type !== terminalType) emit("AGUI005", {
+				type,
+				terminalType
+			}, { relatedEventIndex: r.terminal.index });
+			else emit("AGUI004", {
+				type,
+				terminalType
+			}, { relatedEventIndex: r.terminal.index });
+			return;
+		}
+		closeChunks(r, emit, index, type);
+		if (type === "RUN_FINISHED" || type === "RUN_ERROR") {
+			if (type === "RUN_FINISHED") {
+				checkRunIdStability(api(index, type, ev, r, emit));
+				endOfRunChecks(r, emit, index);
+				const outcome = ev.outcome;
+				if (typeof outcome === "object" && outcome !== null && outcome.type === "interrupt") stream.features.add("human-in-the-loop");
+			}
+			r.terminal = {
+				type,
+				index
+			};
+			return;
+		}
+		const a = api(index, type, ev, r, emit);
+		switch (spec.category) {
+			case "lifecycle":
+				handleStepEvent(a);
+				break;
+			case "text":
+				handleTextEvent(a);
+				break;
+			case "toolcall":
+				handleToolCallEvent(a);
+				break;
+			case "state":
+				handleStateEvent(a);
+				break;
+			case "reasoning":
+				handleReasoningEvent(a);
+				break;
+			case "thinking": break;
+			case "activity": break;
+			case "special": if (type === "RAW") {
+				const wrapped = ev.event;
+				if (typeof wrapped === "object" && wrapped !== null) {
+					const wrappedType = wrapped.type;
+					if (typeof wrappedType === "string" && EVENT_TABLE[wrappedType] !== void 0) emit("AGUI901", { wrappedType }, { pointer: "/event/type" });
+				}
+			} else if (type === "CUSTOM") {
+				const name = str(ev, "name");
+				if (name !== void 0) {
+					if (name === "PredictState") stream.features.add("predictive-state-updates");
+					if (!/[.:/]/.test(name)) emit("AGUI903", { name }, { pointer: "/name" });
+				}
+			}
+		}
+	}
+	function api(index, type, event, r, emit) {
+		return {
+			index,
+			type,
+			event,
+			run: r,
+			stream,
+			emit,
+			feature: (f) => stream.features.add(f)
+		};
+	}
+	return {
+		feed(event) {
+			const batch = [];
+			try {
+				processEvent(event, batch);
+			} catch (e) {
+				internalErrors.push(`feed(event ${stream.eventCount - 1}): ${e instanceof Error ? e.stack ?? e.message : String(e)}`);
+			}
+			return batch;
+		},
+		finalize() {
+			if (finalized) return [];
+			finalized = true;
+			const batch = [];
+			const emit = mkEmit(batch, null);
+			try {
+				if (run !== null && run.terminal === null) {
+					closeChunks(run, emit, -1);
+					emit("AGUI003", { runId: run.runId ?? "(unknown)" }, {
+						eventIndex: -1,
+						relatedEventIndex: run.startIndex
+					});
+					endOfRunChecks(run, emit, -1);
+				}
+				if (stream.eventCount > 0 && !stream.sawTimestamp) emit("AGUI902", { eventCount: stream.eventCount }, { eventIndex: -1 });
+				if (declaredFeatures.has("shared-state") && !stream.anySnapshot) emit("AGUI305", {}, { eventIndex: -1 });
+			} catch (e) {
+				internalErrors.push(`finalize(): ${e instanceof Error ? e.stack ?? e.message : String(e)}`);
+			}
+			return batch;
+		},
+		emitExternal(rule, params = {}, extra = {}) {
+			const batch = [];
+			try {
+				mkEmit(batch, null)(rule, params, extra);
+			} catch (e) {
+				internalErrors.push(`emitExternal(${rule}): ${e instanceof Error ? e.message : String(e)}`);
+			}
+			return batch[0] ?? null;
+		},
+		markSkipped(rule, reason) {
+			explicitSkips.set(String(rule), String(reason));
+		},
+		report() {
+			const summary = {
+				errors: 0,
+				warnings: 0,
+				info: 0
+			};
+			for (const d of diagnostics) if (d.severity === "error") summary.errors += 1;
+			else if (d.severity === "warning") summary.warnings += 1;
+			else summary.info += 1;
+			const features = {};
+			for (const f of CANONICAL_FEATURES) features[f] = NOT_INFERABLE.includes(f) ? "not-inferable" : stream.features.has(f) ? "exercised" : "not-exercised";
+			let skipped = layers.has("transport") ? [] : TRANSPORT_RULE_IDS.filter((id) => overrides[id] !== "off").map((rule) => ({
+				rule,
+				reason: TRANSPORT_SKIP_REASON
+			}));
+			if (!declaredFeatures.has("shared-state") && overrides.AGUI305 !== "off") skipped.push({
+				rule: "AGUI305",
+				reason: "only evaluated when the 'shared-state' feature is declared via options.features"
+			});
+			for (const [rule, severity] of Object.entries(overrides)) if (severity === "off" && RULES.has(rule)) skipped.push({
+				rule,
+				reason: "disabled by severityOverrides"
+			});
+			if (explicitSkips.size > 0) {
+				skipped = skipped.filter((s) => !explicitSkips.has(s.rule));
+				for (const [rule, reason] of explicitSkips) skipped.push({
+					rule,
+					reason
+				});
+			}
+			return {
+				diagnostics: [...diagnostics],
+				summary,
+				features,
+				skipped,
+				eventCount: stream.eventCount,
+				internalErrors: [...internalErrors]
+			};
+		}
+	};
+}
+//#endregion
+//#region src/transport/ndjson.ts
+async function* ndjsonLines(source) {
+	const decoder = new TextDecoder("utf-8");
+	let buffer = "";
+	function clean(line) {
+		const trimmed = line.endsWith("\r") ? line.slice(0, -1) : line;
+		return trimmed.trim() === "" ? null : trimmed;
+	}
+	for await (const chunk of source) {
+		buffer += decoder.decode(chunk, { stream: true });
+		let i;
+		while ((i = buffer.indexOf("\n")) !== -1) {
+			const line = clean(buffer.slice(0, i));
+			buffer = buffer.slice(i + 1);
+			if (line !== null) yield line;
+		}
+	}
+	buffer += decoder.decode();
+	const last = clean(buffer);
+	if (last !== null) yield last;
+}
+//#endregion
+//#region src/transport/sse.ts
+const truncate = (s, n) => s.length > n ? `${s.slice(0, n)}…` : s;
+async function* sseItems(source) {
+	const decoder = new TextDecoder("utf-8");
+	let buffer = "";
+	let sawFirstChars = false;
+	let dataLines = [];
+	let eventName = "";
+	let lastId;
+	function handleLine(line) {
+		if (line === "") {
+			const data = dataLines.join("\n");
+			const hadData = dataLines.length > 0;
+			dataLines = [];
+			const name = eventName;
+			eventName = "";
+			if (!hadData || data === "") return null;
+			const item = {
+				kind: "event",
+				data
+			};
+			if (name !== "") item.event = name;
+			if (lastId !== void 0) item.id = lastId;
+			return item;
+		}
+		if (line.startsWith(":")) return {
+			kind: "comment",
+			text: line.slice(1)
+		};
+		const colon = line.indexOf(":");
+		const field = colon === -1 ? line : line.slice(0, colon);
+		let value = colon === -1 ? "" : line.slice(colon + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		switch (field) {
+			case "data":
+				dataLines.push(value);
+				return null;
+			case "event":
+				eventName = value;
+				return null;
+			case "id":
+				if (!value.includes("\0")) lastId = value;
+				return null;
+			case "retry": return null;
+			default: {
+				const trimmed = line.trimStart();
+				if (trimmed.startsWith("{") || trimmed.startsWith("[")) return {
+					kind: "problem",
+					code: "json-line-without-data-prefix",
+					detail: `line '${truncate(trimmed, 60)}' looks like a JSON payload but lacks the 'data:' field prefix, so SSE clients silently drop it`
+				};
+				return null;
+			}
+		}
+	}
+	function* drainLines(eof) {
+		for (;;) {
+			const nl = buffer.indexOf("\n");
+			const cr = buffer.indexOf("\r");
+			let end;
+			let next;
+			if (cr !== -1 && (nl === -1 || cr < nl)) {
+				if (cr === buffer.length - 1 && !eof) return;
+				end = cr;
+				next = buffer[cr + 1] === "\n" ? cr + 2 : cr + 1;
+			} else if (nl !== -1) {
+				end = nl;
+				next = nl + 1;
+			} else return;
+			const line = buffer.slice(0, end);
+			buffer = buffer.slice(next);
+			const item = handleLine(line);
+			if (item !== null) yield item;
+		}
+	}
+	for await (const chunk of source) {
+		buffer += decoder.decode(chunk, { stream: true });
+		if (!sawFirstChars && buffer.length > 0) {
+			if (buffer.startsWith("")) buffer = buffer.slice(1);
+			sawFirstChars = true;
+		}
+		yield* drainLines(false);
+	}
+	buffer += decoder.decode();
+	yield* drainLines(true);
+	if (buffer !== "") yield {
+		kind: "problem",
+		code: "truncated-frame",
+		detail: `stream ended mid-line: '${truncate(buffer, 60)}' (no trailing newline; the frame was never dispatched)`
+	};
+	else if (dataLines.length > 0) yield {
+		kind: "problem",
+		code: "truncated-frame",
+		detail: "stream ended with a pending frame that was never terminated by a blank line"
+	};
+}
+//#endregion
+//#region src/transport/index.ts
+const DEFAULT_KEEPALIVE_MS = 3e4;
+/** Operational failure (unreachable endpoint, non-2xx, no body) — distinct
+* from conformance findings, which are diagnostics. */
+var TransportError = class extends Error {
+	status;
+	constructor(message, status) {
+		super(message);
+		this.name = "TransportError";
+		if (status !== void 0) this.status = status;
+	}
+};
+function randomId(prefix) {
+	const c = globalThis.crypto;
+	return `${prefix}_${c !== void 0 && "randomUUID" in c ? c.randomUUID().slice(0, 8) : Math.random().toString(36).slice(2, 10)}`;
+}
+/** The minimal valid RunAgentInput POSTed when none is supplied. */
+function defaultRunAgentInput() {
+	return {
+		threadId: randomId("thread"),
+		runId: randomId("run"),
+		state: {},
+		messages: [{
+			id: randomId("msg"),
+			role: "user",
+			content: "Hello! Please respond briefly."
+		}],
+		tools: [],
+		context: [],
+		forwardedProps: {}
+	};
+}
+async function* iterateBody(body) {
+	if (Symbol.asyncIterator in body) {
+		yield* body;
+		return;
+	}
+	const reader = body.getReader();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return;
+			if (value !== void 0) yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+/** Buffers up to the first line to guess SSE vs NDJSON, then replays. */
+async function sniffFormat(source) {
+	const held = [];
+	const decoder = new TextDecoder();
+	let text = "";
+	while (!text.includes("\n") && text.length < 4096) {
+		const { done, value } = await source.next();
+		if (done) break;
+		held.push(value);
+		text += decoder.decode(value, { stream: true });
+	}
+	const firstLine = (text.split("\n")[0] ?? "").trim();
+	const format = firstLine.startsWith("{") || firstLine.startsWith("[") ? "ndjson" : "sse";
+	async function* replay() {
+		yield* held;
+		for (;;) {
+			const { done, value } = await source.next();
+			if (done) return;
+			yield value;
+		}
+	}
+	return {
+		format,
+		replay: replay()
+	};
+}
+async function validateBody(body, contentType, opts = {}) {
+	const userLayers = opts.validator?.layers ?? [];
+	const layers = [.../* @__PURE__ */ new Set([
+		...userLayers,
+		"core",
+		"transport"
+	])];
+	const v = createValidator({
+		...opts.validator ?? {},
+		layers
+	});
+	const now = opts.now ?? Date.now;
+	const keepaliveWindow = opts.keepaliveWindowMs ?? DEFAULT_KEEPALIVE_MS;
+	const recorded = opts.recorded === true;
+	const emitTransport = (rule, params, extra) => {
+		const d = v.emitExternal(rule, params, extra);
+		if (d !== null) opts.onDiagnostic?.(d);
+		return d;
+	};
+	let chunkCount = 0;
+	let maxGapMs = 0;
+	let lastArrival = null;
+	async function* tapped() {
+		for await (const chunk of iterateBody(body)) {
+			const t = now();
+			if (lastArrival !== null) maxGapMs = Math.max(maxGapMs, t - lastArrival);
+			lastArrival = t;
+			chunkCount += 1;
+			yield chunk;
+		}
+	}
+	const mime = contentType === null ? null : (contentType.split(";")[0] ?? "").trim().toLowerCase();
+	if (contentType === null) v.markSkipped("AGUI505", "no Content-Type header is available for this input");
+	else if (mime !== "text/event-stream" && mime !== "application/x-ndjson") emitTransport("AGUI505", { contentType: mime === "" ? "(none)" : mime });
+	if (recorded) {
+		v.markSkipped("AGUI506", "keepalive timing is not meaningful for recorded input");
+		v.markSkipped("AGUI507", "chunk arrival timing is not meaningful for recorded input");
+		v.markSkipped("AGUI508", "abnormal disconnects cannot be distinguished from end-of-capture in recorded input");
+	}
+	let format;
+	let stream = tapped();
+	if (mime === "text/event-stream") format = "sse";
+	else if (mime === "application/x-ndjson") format = "ndjson";
+	else ({format, replay: stream} = await sniffFormat(stream));
+	if (format === "ndjson") v.markSkipped("AGUI501", "the stream is NDJSON; there is no SSE framing to check");
+	let eventCount = 0;
+	let runOpen = false;
+	let openRunId = null;
+	const feedRaw = (raw) => {
+		eventCount += 1;
+		const diags = v.feed(raw);
+		try {
+			const parsed = JSON.parse(raw);
+			if (parsed?.type === "RUN_STARTED") {
+				runOpen = true;
+				openRunId = typeof parsed.runId === "string" ? parsed.runId : null;
+			} else if (parsed?.type === "RUN_FINISHED" || parsed?.type === "RUN_ERROR") runOpen = false;
+		} catch {}
+		opts.onEvent?.(raw, diags);
+		if (opts.onDiagnostic !== void 0) for (const d of diags) opts.onDiagnostic(d);
+	};
+	let transportError;
+	try {
+		if (format === "sse") {
+			for await (const item of sseItems(stream)) if (item.kind === "event") feedRaw(item.data);
+			else if (item.kind === "problem") emitTransport("AGUI501", { detail: item.detail });
+		} else for await (const line of ndjsonLines(stream)) feedRaw(line);
+	} catch (e) {
+		if (recorded) throw e instanceof TransportError ? e : new TransportError(`failed to read recorded input: ${e instanceof Error ? e.message : String(e)}`);
+		transportError = e instanceof Error ? e.message : String(e);
+		if (runOpen) emitTransport("AGUI508", { runId: openRunId ?? "(unknown)" });
+	}
+	if (!recorded) {
+		if (lastArrival !== null) maxGapMs = Math.max(maxGapMs, now() - lastArrival);
+		if (maxGapMs > keepaliveWindow) emitTransport("AGUI506", { seconds: Math.round(maxGapMs / 1e3) });
+		if (chunkCount === 1 && eventCount >= 3) emitTransport("AGUI507", { detail: `entire body (${eventCount} events) arrived in a single chunk` });
+	}
+	const finalDiags = v.finalize();
+	if (opts.onDiagnostic !== void 0) for (const d of finalDiags) opts.onDiagnostic(d);
+	const result = {
+		report: v.report(),
+		status: null,
+		contentType,
+		eventCount
+	};
+	if (transportError !== void 0) result.transportError = transportError;
+	return result;
+}
+async function validateEndpoint(url, opts = {}) {
+	const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+	if (fetchImpl === void 0) throw new TransportError("no fetch implementation available; pass fetchImpl");
+	const method = opts.method ?? "POST";
+	const headers = {
+		accept: "text/event-stream, application/x-ndjson",
+		...method === "POST" ? { "content-type": "application/json" } : {},
+		...opts.headers ?? {}
+	};
+	const controller = new AbortController();
+	const timers = [];
+	if (opts.timeoutMs !== void 0) timers.push(setTimeout(() => controller.abort(new TransportError(`timed out after ${opts.timeoutMs}ms`)), opts.timeoutMs));
+	opts.signal?.addEventListener("abort", () => controller.abort(opts.signal?.reason), { once: true });
+	try {
+		let res;
+		try {
+			const init = {
+				method,
+				headers,
+				signal: controller.signal
+			};
+			if (method === "POST") init.body = JSON.stringify(opts.input ?? defaultRunAgentInput());
+			res = await fetchImpl(url, init);
+		} catch (e) {
+			throw e instanceof TransportError ? e : new TransportError(`request failed: ${e instanceof Error ? e.message : String(e)}`);
+		}
+		if (res.status < 200 || res.status >= 300) throw new TransportError(`endpoint responded with HTTP ${res.status}`, res.status);
+		if (res.body === null) throw new TransportError("response has no body", res.status);
+		const contentType = res.headers.get("content-type") ?? "";
+		return {
+			...await validateBody(res.body, contentType, opts),
+			status: res.status
+		};
+	} finally {
+		for (const timer of timers) clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/cli.ts
+const TOOL_NAME = "ag-ui-validate";
+function toolVersion() {
+	try {
+		return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}
+function transportOptions(config, onDiagnostic) {
+	const validator = {};
+	if (config.features !== void 0) validator.features = config.features;
+	if (Object.keys(config.severityOverrides).length > 0) validator.severityOverrides = config.severityOverrides;
+	const opts = { validator };
+	if (onDiagnostic !== void 0) opts.onDiagnostic = onDiagnostic;
+	return opts;
+}
+async function main() {
+	const parsed = parseCliArgs(process.argv.slice(2));
+	if (!parsed.ok) {
+		process.stderr.write(`error: ${parsed.error}\n\n${USAGE}`);
+		return 2;
+	}
+	const config = parsed.config;
+	if (config.help) {
+		process.stdout.write(USAGE);
+		return 0;
+	}
+	const version = toolVersion();
+	if (config.version) {
+		process.stdout.write(`${TOOL_NAME} ${version}\n`);
+		return 0;
+	}
+	const color = config.color ?? (process.stdout.isTTY === true && process.env.NO_COLOR === void 0);
+	const pretty = config.format === "pretty";
+	let printed = 0;
+	const onDiagnostic = pretty ? (d) => {
+		printed += 1;
+		process.stdout.write(`${formatDiagnosticLine(d, { color })}\n`);
+	} : void 0;
+	const isUrl = /^https?:\/\//i.test(config.target);
+	let result;
+	let targetLabel;
+	if (isUrl) {
+		targetLabel = config.target;
+		const opts = transportOptions(config, onDiagnostic);
+		if (Object.keys(config.headers).length > 0) opts.headers = config.headers;
+		if (config.timeoutMs !== void 0) opts.timeoutMs = config.timeoutMs;
+		result = await validateEndpoint(config.target, opts);
+	} else if (config.target === "-") {
+		targetLabel = "stdin";
+		if (process.stdin.isTTY === true) {
+			process.stderr.write("error: stdin is a terminal — pipe a recording in, or pass a file path\n");
+			return 2;
+		}
+		result = await validateBody(process.stdin, null, {
+			...transportOptions(config, onDiagnostic),
+			recorded: true
+		});
+	} else {
+		targetLabel = config.target;
+		result = await validateBody(createReadStream(config.target), null, {
+			...transportOptions(config, onDiagnostic),
+			recorded: true
+		});
+	}
+	const report = result.report;
+	const sarifOptions = !isUrl && config.target !== "-" && /\.(jsonl|ndjson)$/i.test(config.target) ? {
+		toolVersion: version,
+		artifactUri: config.target
+	} : { toolVersion: version };
+	if (config.jsonFile !== void 0) {
+		const doc = toJsonReport(report, {
+			tool: {
+				name: TOOL_NAME,
+				version
+			},
+			target: targetLabel
+		});
+		writeFileSync(config.jsonFile, `${JSON.stringify(doc, null, 2)}\n`);
+	}
+	if (config.sarifFile !== void 0) writeFileSync(config.sarifFile, `${JSON.stringify(toSarif(report, sarifOptions), null, 2)}\n`);
+	if (config.junitFile !== void 0) writeFileSync(config.junitFile, toJUnit(report, { name: targetLabel }));
+	if (pretty) {
+		if (printed > 0) process.stdout.write("\n");
+		process.stdout.write(`${formatReportSummary(report, { color })}\n`);
+	} else if (config.format === "json") {
+		const doc = toJsonReport(report, {
+			tool: {
+				name: TOOL_NAME,
+				version
+			},
+			target: targetLabel
+		});
+		process.stdout.write(`${JSON.stringify(doc, null, 2)}\n`);
+	} else if (config.format === "sarif") process.stdout.write(`${JSON.stringify(toSarif(report, sarifOptions), null, 2)}\n`);
+	else process.stdout.write(toJUnit(report, { name: targetLabel }));
+	return decideExitCode(report.summary, config.maxWarnings);
+}
+main().then((code) => {
+	process.exitCode = code;
+}, (e) => {
+	const message = e instanceof TransportError ? e.message : e instanceof Error ? e.stack ?? e.message : String(e);
+	process.stderr.write(`error: ${message}\n`);
+	process.exitCode = 2;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.js.map