@copilotkit/learning 0.0.1 → 1.81.0

package/README.md

@@ -15,6 +15,19 @@ Redaction runs on the first 16 KiB of a body, before the 4 KiB limit applies. Ev
 
 Use `capture`, `beforeSend`, `ignoreUrls`, and `data-copilotkit-ignore` for your app's exclusions. The deprecated `routes` option no longer masks or transforms paths.
 
+Click events also include `target.label`, a short, cleaned name of the clicked control. Automatic Learning shows this name to the model. It comes from the first of `aria-labelledby`, `aria-label`, the caption of a submit, button, reset, or image input, `title` (controls only), and the text of a control named by its content: buttons, links with `href`, `summary`, and roles such as `tab`, `menuitem`, or `option`. Images inside a control count with their `alt`, `aria-label`, or `<title>`, and a clicked icon without its own name takes the name of the control around it. Control text is not used when it looks like separate fields, as cards do: longer than 80 characters, containing headings, lists, tables, fields, or more than one paragraph, or split across two `div`s that hold text, directly or through inline elements, or three text-carrying siblings. ARIA autocomplete suggestions, and anything inside them, get no label from any source: `aria-labelledby`, `aria-label`, `title`, and text are all ignored, and `aria-labelledby` elsewhere that points into a suggestion list gives no name. Use `data-copilotkit-action` to name a suggestion. Containers, editable content, text slotted into web components, and the `<label>` of a native checkbox or radio button (use `aria-label` or `data-copilotkit-action` there) never contribute their text; script, style, template, and hidden content is skipped. Invisible characters are removed, passwords and credentials become `[redacted]`, URLs `[url]`, emails `[email]`, and JWT or other token-like strings `[redacted]`. Other names are cut at 80 characters with `…`, and `label` is omitted when no name remains. Raw `text`, `attributes`, and values are unchanged. `data-copilotkit-action` gives a control an explicit name in `target.action`. To exclude a control or a suggestion list without ARIA roles, add `data-copilotkit-ignore`, or remove the label in `beforeSend`:
+
+```ts
+beforeSend: (event) => {
+  if (event.name === "click") delete (event.value.target as { label?: string }).label;
+  return event;
+},
+```
+
+See [Click labels](https://docs.copilotkit.ai/intelligence/captured-data#click-labels) for the full rules.
+
+Text edits are combined per field and recorded after a 300 ms pause. Committing or leaving the field, pressing Enter outside input-method composition, clicking, navigating, emitting a developer event, or stopping capture records the pending edit first. Paired `input` and `change` notifications for the same edit produce one record; a later user edit can record the same value again. Checkbox and select changes remain immediate. See [Form edit timing](https://docs.copilotkit.ai/intelligence/captured-data#form-edit-timing) for composition and delivery behavior.
+
 ## Authenticated Trajectories
 
 Use Core to connect capture to CopilotKit Intelligence. This experimental integration targets the join and batch APIs in [Intelligence #1569](https://github.com/CopilotKit/Intelligence/pull/1569).
@@ -39,9 +52,25 @@ if (result.status === "started") {
 copilotkit.stopTrajectory();
 ```
 
-An omitted `trajectoryId` generates a UUID. Start succeeds after Runtime authentication and the Phoenix channel join. The Runtime resolves the user on the server and sends only their ID to Intelligence. Browser-supplied identity and container IDs are ignored; container assignment is deferred. Setting `learningContainerIds` for authenticated capture produces a warning. That option applies only to custom sinks.
+An omitted `trajectoryId` generates a UUID. Start succeeds after Runtime authentication and the Phoenix channel join. The Runtime resolves the user on the server. Browser-supplied identity and container IDs are ignored. Setting `learningContainerIds` in browser capture configuration produces a warning; that option applies only to custom sinks.
+
+To assign authenticated capture to an existing Learning Space, configure the Runtime on the server:
+
+```ts
+const intelligence = new CopilotKitIntelligence({
+  apiKey: process.env.CPK_INTELLIGENCE_API_KEY!,
+  getTrajectoryLearningContainerIds: ({ trajectoryId, user }) => {
+    // Use the verified application user to choose existing Spaces.
+    return ["expense-review"];
+  },
+});
+```
+
+The selector accepts synchronous or asynchronous results. Return `[]` to request no new assignments explicitly. Return `null` or `undefined` to omit assignments from the connect request. Each connect adds memberships; none of these results removes existing memberships, and a membership removed in Intelligence stays removed. Keep the result stable across reconnects. The selector needs no agent run or Thread, and a linked Thread's Space does not add the Trajectory. The browser chooses the Trajectory ID; the user comes from the Runtime. Intelligence validates that the selected Spaces belong to the API key's project.
 
-Capture includes page context, navigation, clicks, form edits, network requests, and developer events. Paths remain unchanged. Thread linking and agent events are deferred for this connection path.
+Assignment problems never stop capture. If a selected Space does not exist, the Runtime logs a warning with the Trajectory and Space IDs and connects without any assignments, including the Spaces that exist. The selector has a five-second deadline and receives an optional second `AbortSignal` argument for cancelling its work when the request ends or the deadline expires. A callback error, invalid result, or deadline expiry logs a server error, and the Trajectory connects without assignments. Processing assigned events requires an Intelligence backend with Trajectory inputs enabled for Automatic Learning.
+
+Capture includes page context, navigation, clicks, form edits, network requests, and developer events. Paths remain unchanged. When Runtime starts an agent run, Core sends `thread.linked` with the run's `threadId`, once for each Thread. Runtime creates the Thread before the run starts, so Intelligence can store the link. Click Thread context and agent events are deferred for this connection path.
 
 Core sends Phoenix `events` messages with `{ events, dropped }`. It flushes after two seconds, at 50 events, or before the batch exceeds 64 KiB. Each event must fit within 16 KiB, including sequence metadata. Sizes use serialized UTF-8 JSON. The Gateway replies with `{ highestSeq, accepted, rejected }`. This receipt confirms Redis acceptance, not a Postgres commit. Postgres projection follows asynchronously. The receipt does not identify individual rejected events.
 
@@ -53,7 +82,38 @@ Capture pauses while disconnected. Reconnect requests fresh credentials. Develop
 
 Stop cancels pending starts and reconnects. It attempts one final queued batch if no receipt is pending, then disconnects without waiting. Stop is not a guarantee that the last batch was saved. A batch still awaiting its receipt reports `PERSISTENCE_UNKNOWN`, including during a normal stop.
 
-In React, pass the same configuration to `CopilotKitProvider`. Set `learning.trajectoryId` to start automatically, or call the Core methods to control capture.
+If a start or an established capture ends with an error and no `onError` is set, Core logs a console warning with the error code and a setup hint, such as a missing `runtimeUrl`, a Runtime without `intelligence`, or a missing `identifyUser`. Each outcome warns once per Core instance. Server error messages are never shown in the browser. Setting `onError` replaces the warning. Stops and recoverable connection loss do not warn.
+
+### React
+
+Capture needs a Runtime configured with `intelligence` and `identifyUser`, and a project with Trajectories enabled. Then turn capture on in the provider:
+
+```tsx
+<CopilotKitProvider runtimeUrl="/api/copilotkit" learning>
+  {children}
+</CopilotKitProvider>
+```
+
+`learning` turns capture on. For options, pass an object, such as `learning={{ onError }}`. `learning={false}` or removing the prop turns capture off, which suits a consent switch: `learning={hasConsent}`.
+
+Capture starts after mount. Without `learning.trajectoryId`, the provider generates the Trajectory ID. The ID stays the same across rerenders, React StrictMode effect replays, reconnects, and option changes. Turning capture off and on again starts a new Trajectory with a new ID. Unmounting the provider stops capture. Read the active ID from `copilotkit.trajectoryId`, or subscribe with `onTrajectoryChanged`.
+
+Set `learning.trajectoryId` to use your own ID instead.
+
+To decide yourself when capture starts, set `autoStart: false`. The provider configures capture and waits for your app to call `copilotkit.startTrajectory()`:
+
+```tsx
+<CopilotKitProvider
+  runtimeUrl="/api/copilotkit"
+  learning={{ autoStart: false }}
+>
+  {children}
+</CopilotKitProvider>
+```
+
+With `autoStart: false`, the provider ignores `learning.trajectoryId` and logs a console warning. Pass the ID to `startTrajectory({ trajectoryId })` instead.
+
+Earlier versions waited for `startTrajectory()` when the object had no `trajectoryId`, for example `learning={{ onError }}`. Those objects now start capture after mount. Add `autoStart: false` to keep the manual start.
 
 ## Custom batch sinks
 

package/dist/index.cjs

@@ -117,13 +117,17 @@ function createRedactor() {
 	const toggled = (records) => {
 		for (const record of records) if (record.oldValue?.toLowerCase() === "password") seen.add(record.target);
 	};
-	/** Replaces remembered values, raw and in their JSON and URL encodings. */
-	const scrub = (text) => {
+	/**
+	* Replaces remembered values, raw and in their JSON and URL encodings, plus
+	* `normalize(value)` when given and at least 4 characters long.
+	*/
+	const scrub = (text, normalize) => {
 		for (const value of [...remembered.values()].sort((a, b) => b.length - a.length)) for (const form of [
 			value,
 			JSON.stringify(value).slice(1, -1),
 			encodeURIComponent(value),
-			new URLSearchParams({ v: value }).toString().slice(2)
+			new URLSearchParams({ v: value }).toString().slice(2),
+			...[normalize?.(value) ?? ""].filter((normal) => normal.length >= 4)
 		]) text = /^\d+$/.test(form) ? text.replace(RegExp(`(?<!\\d)${form}(?!\\d)`, "g"), REDACTED) : text.split(form).join(REDACTED);
 		return text;
 	};
@@ -141,6 +145,7 @@ function createRedactor() {
 	};
 	return {
 		isPassword,
+		scrub,
 		watch() {
 			try {
 				for (const input of document.querySelectorAll("input[type=password]")) seen.add(input);
@@ -224,6 +229,172 @@ function describeTarget(el, redact) {
 		}
 	};
 }
+const MAX_LABEL_LENGTH = 80;
+const MAX_WALK_NODES = 1e3;
+const MAX_WALK_CHARS = 4 * MAX_LABEL_LENGTH;
+const CONTROL_ROLE = /^(button|link|tab|menuitem(checkbox|radio)?|option|checkbox|switch|radio|treeitem)$/;
+const CONTENTEDITABLE = "[contenteditable]:not([contenteditable=\"false\"])";
+const TEXT_ENTRY = `${CONTENTEDITABLE}, [role~=textbox], [role~=searchbox], [role~=combobox]`;
+const EDITABLE = `input, textarea, select, ${TEXT_ENTRY}`;
+const HEADING = "h1, h2, h3, h4, h5, h6, [role~=heading]";
+const STRUCTURE = `${HEADING}, p, ul, ol, li, dl, table, article, section, blockquote`;
+const SKIPPED = "script, style, template, [hidden], [aria-hidden=\"true\"]";
+const PHRASING = /^(b|i|u|em|strong|mark|small|sub|sup|abbr|code|kbd|s|q|cite|dfn|var|time|data|bdi|bdo|wbr|span)$/;
+const CAPTION_INPUT = /^(submit|button|reset|image)$/;
+const NON_TEXT_INPUT = /^(submit|button|reset|image|checkbox|radio|range|color|file|hidden)$/;
+const IGNORABLE = /\p{Default_Ignorable_Code_Point}/gu;
+const URL_LIKE = /(?:\b[a-z][\w+.-]{0,31}:\/\/|\bwww\.)[^\s<>"']*[^\s<>"'.,;:!?)]/gi;
+const EMAIL = /[\p{L}\p{N}_.%+-]{1,64}@[\p{L}\p{N}-]{1,63}(?:\.[\p{L}\p{N}-]{1,63})+/gu;
+const JWT = /(^|[^\w-])(?:eyJ[\w-]*\.[\w-]*\.[\w-]*|[\w-]{16,}\.[\w-]{16,}\.[\w-]{16,}|(?=[\w-]*\d)[\w-]{8,}\.(?=[\w-]*\d)[\w-]{8,}\.(?=[\w-]*\d)[\w-]{8,})/g;
+const TOKEN_RUN = /[\w+/=-]{24,}/g;
+const roleOf = (element) => (element.getAttribute("role") ?? "").trim().split(/\s+/)[0].toLowerCase();
+const idRefs = (element, name) => (element.getAttribute(name) ?? "").split(/\s+/).filter(Boolean);
+const rootOf = (element) => {
+	const root = element.getRootNode();
+	return root instanceof Document || root instanceof ShadowRoot ? root : null;
+};
+/** Buttons, links with `href`, `summary`, and elements with a control role. */
+const isControl = (element) => {
+	const role = roleOf(element);
+	return role ? CONTROL_ROLE.test(role) : element.matches("button, a[href], summary");
+};
+/** Text-like inputs, text areas, selects, and anything inside editable content or a text-entry role. */
+const holdsValue = (element) => element instanceof HTMLInputElement ? !NON_TEXT_INPUT.test(element.type) : element.matches("textarea, select") || element.closest(TEXT_ENTRY) !== null;
+/**
+* The name an image contributes: `alt` of an `img`, or `aria-label` (else a
+* plain `<title>`) of an `svg` or `role="img"` element. `undefined` when the
+* element is not an image.
+*/
+function imageName(element) {
+	if (element.localName === "img") return element.getAttribute("alt");
+	if (element.localName !== "svg" && roleOf(element) !== "img") return void 0;
+	const title = Array.from(element.children).find((child) => child.localName === "title" && child.childElementCount === 0);
+	return element.getAttribute("aria-label") ?? title?.textContent ?? null;
+}
+/**
+* Rendered text. Inline formatting joins words; other elements separate them.
+* Skips hidden subtrees, uses image names, and does
+* not walk into images. Yields nothing for editable content or editable
+* descendants. In `strict` mode (a control's own text) it also yields nothing
+* past the walk bounds, for card-like structure, and for text that looks like
+* separate fields: two `div`s that directly hold text, or three sibling
+* elements that each carry text.
+*/
+function safeText(root, strict) {
+	if (holdsValue(root)) return "";
+	let text = "";
+	let nodes = 0;
+	let paragraphs = 0;
+	let div;
+	const bearers = /* @__PURE__ */ new Map();
+	const add = (part) => text = (text + part).replace(/\s+/g, " ");
+	const bear = (start) => {
+		if (!strict) return true;
+		for (let child = start, parent = start.parentNode; child !== root && parent !== null; child = parent, parent = parent.parentNode) {
+			const siblings = bearers.get(parent) ?? /* @__PURE__ */ new Set();
+			bearers.set(parent, siblings);
+			if (siblings.has(child)) break;
+			if (siblings.add(child).size > 2) return false;
+		}
+		return true;
+	};
+	let node = root.firstChild;
+	while (node !== null) {
+		if (++nodes > MAX_WALK_NODES || text.length > MAX_WALK_CHARS) {
+			if (strict) return "";
+			break;
+		}
+		let descend = false;
+		if (node instanceof Text) {
+			const parent = node.parentNode;
+			let holder = parent;
+			while (holder !== root && PHRASING.test(holder.localName)) holder = holder.parentElement;
+			if (/\S/.test(node.data) && (!bear(parent) || strict && holder.localName === "div" && (div ??= holder) !== holder)) return "";
+			add(node.data);
+		} else if (node instanceof Element) {
+			if (node.matches(EDITABLE)) return "";
+			if (strict && node.matches(STRUCTURE) && !(root.localName === "summary" && node.matches(HEADING)) && (node.localName !== "p" || ++paragraphs > 1)) return "";
+			const name = node.matches(SKIPPED) ? null : imageName(node);
+			if (name) {
+				if (!bear(node)) return "";
+				add(` ${name} `);
+			} else if (name === void 0) {
+				if (!PHRASING.test(node.localName)) add(" ");
+				descend = true;
+			}
+		}
+		if (descend && node.firstChild !== null) node = node.firstChild;
+		else {
+			while (node !== root && node.nextSibling === null) {
+				node = node.parentNode;
+				if (!PHRASING.test(node.localName)) add(" ");
+			}
+			node = node === root ? null : node.nextSibling;
+		}
+	}
+	return text;
+}
+/** An option or tree item of an autocomplete or search popup, whose text usually repeats what the user typed. */
+const isSuggestion = (element) => (element.localName === "option" || /^(option|treeitem)$/.test(roleOf(element))) && inSuggestionList(element);
+/** Whether `element` is, or is inside, a combobox, a datalist, or the popup a combobox or autocomplete field controls or owns. */
+function inSuggestionList(element) {
+	if (element.closest("[role~=combobox], datalist") !== null) return true;
+	const root = rootOf(element);
+	return root !== null && Array.from(root.querySelectorAll("[role~=combobox], [aria-autocomplete]")).some((owner) => [...idRefs(owner, "aria-controls"), ...idRefs(owner, "aria-owns")].some((id) => root.getElementById(id)?.contains(element)));
+}
+function labelledBy(element) {
+	const root = rootOf(element);
+	return root === null ? null : idRefs(element, "aria-labelledby").map((id) => {
+		const referenced = root.getElementById(id);
+		return referenced === null || inSuggestionList(referenced) ? "" : safeText(referenced, false);
+	}).join(" ");
+}
+/** A control's own text, unless it is longer than a label: then it is content, not a name. */
+const normalize = (text) => text.replace(IGNORABLE, "").replace(/\s+/g, " ").trim();
+function contentText(element) {
+	const text = safeText(element, true);
+	return Array.from(normalize(text)).length > MAX_LABEL_LENGTH ? "" : text;
+}
+/** Removes invisible characters, credentials, emails, URLs, and tokens, then caps the length. */
+function cleanLabel(raw, redact) {
+	const chars = Array.from(redact.scrub(normalize(redact.body(raw.replace(IGNORABLE, "")) ?? ""), normalize).replace(URL_LIKE, "[url]").replace(EMAIL, "[email]").replace(JWT, `$1${REDACTED}`).replace(TOKEN_RUN, (run) => /\d/.test(run) ? REDACTED : run));
+	return chars.length > MAX_LABEL_LENGTH ? `${chars.slice(0, MAX_LABEL_LENGTH - 1).join("").trimEnd()}…` : chars.join("");
+}
+function firstLabel(sources, redact) {
+	for (const source of sources) {
+		const label = cleanLabel(source() ?? "", redact);
+		if (label) return label;
+	}
+}
+/**
+* A short name for the clicked control, from the first source that yields one:
+* `aria-labelledby`, `aria-label`, an input caption or `alt`, `title` (controls
+* only), then the text of a control named by its content. Containers, cards,
+* and editable content never contribute their text. An autocomplete suggestion,
+* or anything inside one, gets no label from any source; `data-copilotkit-action`
+* names it instead. An icon without its own name takes the name of the control
+* around it.
+*/
+function clickLabel(element, redact) {
+	const option = element.closest("option, [role~=option], [role~=treeitem]");
+	if (option !== null && isSuggestion(option)) return void 0;
+	const named = [() => labelledBy(element), () => element.getAttribute("aria-label")];
+	if (/^(img|svg)$/.test(element.localName) || /^(img|presentation|none)$/.test(roleOf(element))) {
+		const own = firstLabel([...named, () => imageName(element) ?? null], redact);
+		if (own !== void 0) return own;
+		let control = element.parentElement;
+		while (control !== null && !isControl(control)) control = control.parentElement;
+		return control === null ? void 0 : clickLabel(control, redact);
+	}
+	const control = isControl(element) && !holdsValue(element);
+	const captionInput = element instanceof HTMLInputElement && CAPTION_INPUT.test(element.type);
+	return firstLabel([
+		...named,
+		() => captionInput ? element.type === "image" ? element.getAttribute("alt") : element.value : null,
+		() => control || captionInput ? element.getAttribute("title") : null,
+		() => control ? contentText(element) : null
+	], redact);
+}
 /** Snapshot live control properties; HTML attributes do not reflect edited values. */
 function readControlValue(element, redact) {
 	if (element instanceof HTMLInputElement) return {
@@ -241,7 +412,7 @@ function readControlValue(element, redact) {
 		selectedValues: Array.from(element.selectedOptions, (option) => option.value)
 	};
 	if (element instanceof HTMLTextAreaElement) return { value: element.value };
-	if (element.matches("[contenteditable]:not([contenteditable=\"false\"])")) return { value: element.textContent ?? "" };
+	if (element.matches(CONTENTEDITABLE)) return { value: element.textContent ?? "" };
 	return {};
 }
 function eventElement(event) {
@@ -262,12 +433,21 @@ function isNear(origin, event) {
 function installClickCapture(params) {
 	const { emit, getRoute, enrich, isTrusted = (event) => event.isTrusted, redact = createRedactor() } = params;
 	let origin = null;
+	const describeClick = (el) => {
+		const described = describeTarget(el, redact);
+		if (described === null) return null;
+		try {
+			const label = clickLabel(described.element, redact);
+			if (label !== void 0) described.target.label = label;
+		} catch {}
+		return described;
+	};
 	const onPointerDown = (event) => {
 		try {
 			if (event.isPrimary === false) return;
 			const el = eventElement(event);
 			origin = {
-				described: el === null ? null : describeTarget(el, redact),
+				described: el === null ? null : describeClick(el),
 				x: event.clientX,
 				y: event.clientY
 			};
@@ -282,7 +462,7 @@ function installClickCapture(params) {
 			if (!isTrusted(event)) return;
 			const el = eventElement(event);
 			if (el === null) return;
-			const described = pointerOrigin !== null && isRootOrDetached(el) && isNear(pointerOrigin, event) ? pointerOrigin.described : describeTarget(el, redact);
+			const described = pointerOrigin !== null && isRootOrDetached(el) && isNear(pointerOrigin, event) ? pointerOrigin.described : describeClick(el);
 			if (described === null) return;
 			const input = event.detail === 0 ? "keyboard" : "pointer";
 			emit("click", {
@@ -312,41 +492,138 @@ function installClickCapture(params) {
 
 //#endregion
 //#region src/inputs.ts
-/** Records user edits without changing the control or interfering with its listeners. */
+const TEXT_DEBOUNCE_MS = 300;
+const TEXT_INPUT_TYPES = new Set([
+	"text",
+	"search",
+	"tel",
+	"url",
+	"email",
+	"password",
+	"number"
+]);
+/** Records settled user edits without interfering with the host app's controls. */
 function installInputCapture(params) {
 	const { emit, isTrusted = (event) => event.isTrusted, redact = createRedactor() } = params;
-	const onInput = (event) => {
+	let active = true;
+	const pending = /* @__PURE__ */ new Map();
+	const changeEcho = /* @__PURE__ */ new WeakMap();
+	const composing = /* @__PURE__ */ new WeakMap();
+	const cancel = (element) => {
+		clearTimeout(pending.get(element)?.timer);
+		pending.delete(element);
+	};
+	const deliver = (element, edit) => {
 		try {
-			if (!isTrusted(event)) return;
-			const [element] = event.composedPath();
-			if (!(element instanceof Element)) return;
-			const described = describeTarget(element, redact);
-			if (described === null) return;
-			const value = readControlValue(element, redact);
-			if (!("value" in value)) return;
-			emit("input", {
-				eventType: event.type,
+			if (!active || describeTarget(element, redact) === null) return;
+			if (redact.isPassword(element) && edit.state.value !== REDACTED) return;
+			if (edit.payload.eventType === "input") changeEcho.set(element, JSON.stringify(edit.state));
+			edit.payload.url = redact.url(edit.payload.url);
+			edit.payload.target.text = redact.url(edit.payload.target.text);
+			edit.payload.target.attributes = Object.fromEntries(Object.entries(edit.payload.target.attributes).map(([key, value]) => [key, redact.url(value)]));
+			emit("input", edit.payload);
+		} catch {}
+	};
+	const flush = () => {
+		const edits = [...pending];
+		for (const [element] of edits) cancel(element);
+		for (const [element, edit] of edits) deliver(element, edit);
+	};
+	const observe = (element, eventType, settle) => {
+		if (pending.size > 0 && !pending.has(element)) flush();
+		if (!active) return;
+		const described = describeTarget(element, redact);
+		if (described === null) {
+			cancel(element);
+			return;
+		}
+		const state = readControlValue(element, redact);
+		if (!("value" in state)) return;
+		const text = element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement && TEXT_INPUT_TYPES.has(element.type) || element.matches("[contenteditable]:not([contenteditable=\"false\"])");
+		if (!text) flush();
+		const signature = JSON.stringify(state);
+		const echo = eventType === "change" && (signature === JSON.stringify(pending.get(element)?.state) || signature === changeEcho.get(element));
+		changeEcho.delete(element);
+		if (echo) {
+			flush();
+			changeEcho.delete(element);
+			return;
+		}
+		cancel(element);
+		const edit = {
+			state,
+			payload: {
+				eventType,
 				target: {
 					...described.target,
-					...value
+					...state
 				},
 				url: redact.url(location.href),
 				route: location.pathname
-			});
+			}
+		};
+		if (!text) {
+			deliver(element, edit);
+			return;
+		}
+		if (settle) edit.timer = setTimeout(() => {
+			cancel(element);
+			deliver(element, edit);
+		}, TEXT_DEBOUNCE_MS);
+		pending.set(element, edit);
+	};
+	const onEdit = (event) => {
+		try {
+			if (!active || !isTrusted(event)) return;
+			const [element] = event.composedPath();
+			if (!(element instanceof Element)) return;
+			if (event.type === "compositionstart") {
+				composing.set(element, true);
+				clearTimeout(pending.get(element)?.timer);
+				return;
+			}
+			if (event.type === "compositionend") composing.set(element, false);
+			const inComposition = composing.get(element) === true || composing.get(element) !== false && "isComposing" in event && event.isComposing === true;
+			observe(element, event.type === "compositionend" ? "input" : event.type, !inComposition);
+			if (event.type === "change") flush();
 		} catch {}
 	};
-	window.addEventListener("input", onInput, {
+	const onAction = (event) => {
+		if (event.type !== "pagehide" && !isTrusted(event)) return;
+		if (event.type === "keydown") {
+			const [element] = event.composedPath();
+			if (!(event instanceof KeyboardEvent) || event.key !== "Enter" || event.isComposing || event.keyCode === 229 || element instanceof Element && composing.get(element) === true) return;
+		}
+		flush();
+	};
+	const editTypes = [
+		"input",
+		"change",
+		"compositionstart",
+		"compositionend"
+	];
+	const actionTypes = [
+		"click",
+		"submit",
+		"focusout",
+		"pagehide",
+		"keydown"
+	];
+	for (const type of editTypes) window.addEventListener(type, onEdit, {
 		capture: true,
 		passive: true
 	});
-	window.addEventListener("change", onInput, {
+	for (const type of actionTypes) window.addEventListener(type, onAction, {
 		capture: true,
 		passive: true
 	});
-	return () => {
-		window.removeEventListener("input", onInput, { capture: true });
-		window.removeEventListener("change", onInput, { capture: true });
+	const uninstall = () => {
+		active = false;
+		for (const element of pending.keys()) cancel(element);
+		for (const type of editTypes) window.removeEventListener(type, onEdit, true);
+		for (const type of actionTypes) window.removeEventListener(type, onAction, true);
 	};
+	return Object.assign(uninstall, { flush });
 }
 
 //#endregion
@@ -866,6 +1143,8 @@ function createCollector(options) {
 	const record = (name, value) => {
 		const current = session;
 		if (current === null) return;
+		if (name !== "input" && name !== "network") current.flushInputs?.();
+		if (session !== current) return;
 		try {
 			seq += 1;
 			const event = {
@@ -878,7 +1157,7 @@ function createCollector(options) {
 				timestamp: Date.now()
 			};
 			const kept = beforeSend === void 0 ? event : beforeSend(event);
-			if (kept === null) return;
+			if (kept === null || session !== current) return;
 			current.queue.push(kept);
 			if (current.queue.length >= FLUSH_SIZE) flush();
 		} catch {}
@@ -921,10 +1200,14 @@ function createCollector(options) {
 			ignoreUrls,
 			redact
 		}));
-		if (capture.inputs) current.uninstalls.push(installInputCapture({
-			emit: recordCurrent,
-			redact
-		}));
+		if (capture.inputs) {
+			const inputs = installInputCapture({
+				emit: recordCurrent,
+				redact
+			});
+			current.flushInputs = inputs.flush;
+			current.uninstalls.push(inputs);
+		}
 		const onPageHide = () => flush({ beacon: true });
 		window.addEventListener("pagehide", onPageHide);
 		current.uninstalls.push(() => window.removeEventListener("pagehide", onPageHide));
@@ -939,6 +1222,8 @@ function createCollector(options) {
 	const stop = () => {
 		const current = session;
 		if (current === null) return;
+		current.flushInputs?.();
+		if (session !== current) return;
 		clearInterval(current.timer);
 		for (const uninstall of current.uninstalls) uninstall();
 		flush();
@@ -1018,7 +1303,9 @@ function isJson(value, ancestors = /* @__PURE__ */ new Set()) {
 */
 function createTrajectoryCollector(options) {
 	let active = false;
+	let generation = 0;
 	let uninstalls = [];
+	let flushInputs;
 	const report = (code, message) => {
 		try {
 			options.onError?.({
@@ -1030,6 +1317,9 @@ function createTrajectoryCollector(options) {
 	const getRoute = () => toRoute(location.pathname);
 	const record = (name, value) => {
 		if (!active) return;
+		const current = generation;
+		if (name !== "input" && name !== "network") flushInputs?.();
+		if (!active || generation !== current) return;
 		let payload;
 		try {
 			const event = {
@@ -1039,7 +1329,7 @@ function createTrajectoryCollector(options) {
 				value
 			};
 			const kept = options.beforeSend === void 0 ? event : options.beforeSend(event);
-			if (kept === null || !active) return;
+			if (kept === null || !active || generation !== current) return;
 			if (kept.type !== "CUSTOM" || typeof kept.name !== "string" || !kept.name.trim() || kept.name.length > 200 || kept.name.includes("\0") || !Number.isFinite(kept.timestamp) || kept.timestamp <= 0 || kept.timestamp >= 0xe677d21fdc00 || !isJson(kept.value)) {
 				report("INVALID_EVENT", "The event must contain a name, timestamp, and JSON value.");
 				return;
@@ -1069,6 +1359,12 @@ function createTrajectoryCollector(options) {
 		record(name, value);
 	};
 	const stop = () => {
+		const current = generation;
+		const flush = flushInputs;
+		flushInputs = void 0;
+		flush?.();
+		if (generation !== current) return;
+		generation++;
 		active = false;
 		const installed = uninstalls;
 		uninstalls = [];
@@ -1078,6 +1374,7 @@ function createTrajectoryCollector(options) {
 		start() {
 			if (active || typeof window === "undefined") return;
 			active = true;
+			generation++;
 			if (typeof window.addEventListener !== "function") return;
 			const redact = createRedactor();
 			try {
@@ -1091,10 +1388,14 @@ function createTrajectoryCollector(options) {
 					emit: capture,
 					redact
 				}));
-				if (options.capture?.inputs !== false) uninstalls.push(installInputCapture({
-					emit: capture,
-					redact
-				}));
+				if (options.capture?.inputs !== false) {
+					const inputs = installInputCapture({
+						emit: capture,
+						redact
+					});
+					flushInputs = inputs.flush;
+					uninstalls.push(inputs);
+				}
 				if (options.capture?.network !== false) uninstalls.push(installNetworkCapture({
 					emit: capture,
 					ignoreUrls: options.ignoreUrls ?? [],