ag-ui-validate 0.1.0

package/dist/src-rGZ2G4qA.js

@@ -0,0 +1,1555 @@
+import { n as RULES, r as formatMessage, t as CATALOG } from "./catalog-BglXBNbL.js";
+//#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
+export { EVENT_TABLE as a, validatePatchShape as i, CANONICAL_FEATURES as n, EVENT_TYPES as o, applyPatch as r, SDK_VERSION as s, createValidator as t };
+
+//# sourceMappingURL=src-rGZ2G4qA.js.map