@opencx/widget-react 5.0.0-beta.1 → 5.0.0-beta.10

package/dist/src/json-render/chart-axis.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Y-axis sizing for the cartesian charts.
+ *
+ * recharts 2.x has no auto-width axis: `YAxis.width` is a fixed number, and a
+ * tick label wider than the room left of its tick pokes out past the svg's
+ * left edge, where the viewport clips it. That is how a 120/80/150/90/200 bar
+ * chart rendered "0" for every tick in the 400px chat panel — only the last
+ * digit of each label survived. The axis is sized from the labels recharts
+ * actually painted instead: measured in a browser, estimated where the text
+ * cannot be measured (jsdom, a hidden embed).
+ */
+/** recharts' painted Y tick labels (`<text>`, right-anchored at their `x`). */
+export declare const Y_TICK_LABEL_SELECTOR = ".recharts-yAxis .recharts-cartesian-axis-tick-value";
+export declare function estimateTextWidth(text: string, fontSize: number): number;
+/**
+ * The painted width of an svg text node: the browser's glyph run when it can
+ * report one (a non-positive length means not laid out — a hidden embed), the
+ * estimate otherwise.
+ */
+export declare function measureSvgTextWidth(node: Element, fontSize: number): number;
+/**
+ * The narrowest `YAxis.width` that keeps every painted tick label inside the
+ * svg, or `null` when no Y ticks are in the DOM (a pie, or nothing painted
+ * yet). Derived from geometry, not from recharts constants: each label's
+ * right edge sits at its tick's `x`, and `currentWidth - x` is whatever gap
+ * the axis reserves between label and plot — so the requirement is the widest
+ * label plus that gap, whichever tick size/margin recharts applied.
+ */
+export declare function requiredYAxisWidth(container: ParentNode, currentWidth: number, fontSize: number): number | null;
+//# sourceMappingURL=chart-axis.d.ts.map

package/dist/src/json-render/chart-axis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-axis.d.ts","sourceRoot":"","sources":["../../../src/json-render/chart-axis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAYH,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,wDACqB,CAAC;AAExD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAExE;AAYD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM3E;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAaf"}

package/dist/src/json-render/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/json-render/registry.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAkE5E,eAAO,MAAQ,QAAQ,gDAsOrB,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,EAAE,iBAOhC,CAAC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/json-render/registry.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAwE5E,eAAO,MAAQ,QAAQ,gDA4OrB,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,EAAE,iBAOhC,CAAC"}

package/dist/src/json-render/segment-content.d.ts

@@ -14,12 +14,20 @@ export type ContentSegment = {
  * fence (persist raw, transform on serve). So the history path re-derives the
  * spec from the stored text here.
  *
- * There is exactly ONE spec format: JSONL patch lines inside a ` ```spec `
- * fence — what the prompt instructs the model to emit and what every tool
- * that hands back a card emits. Everything else is markdown. A fence is consumed only after its patches compile to nonempty UI;
- * malformed, unsupported, empty, and incomplete-only fences remain visible as
- * their original fenced markdown. An unclosed fence (turn cut mid-stream)
- * still compiles when enough valid patches arrived.
+ * There is exactly ONE spec format: JSONL patch lines — what the prompt
+ * instructs the model to emit inside a ` ```spec ` fence and what every tool
+ * that hands back a card emits. A model that forgets the fence still emits the
+ * same lines, and the live stream renders them as UI regardless (its transform
+ * drains every patch-shaped line, fenced or not), so a run of consecutive bare
+ * patch lines outside any fence is a spec block too — otherwise a reloaded
+ * transcript shows raw JSON where the customer watched a card.
+ *
+ * Everything else is markdown. A spec block (fenced or bare) is consumed only
+ * after its patches compile to renderable UI; malformed, unsupported, empty,
+ * and incomplete-only blocks remain visible as their original text. An
+ * unclosed fence (turn cut mid-stream) still compiles when enough valid
+ * patches arrived, and a cut-off patch line ending a bare run at the very end
+ * of the text is the run's tail, never a stray `{"op":...` bubble.
  */
 export declare function segmentContent(text: string): ContentSegment[];
 //# sourceMappingURL=segment-content.d.ts.map

package/dist/src/json-render/segment-content.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment-content.d.ts","sourceRoot":"","sources":["../../../src/json-render/segment-content.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,IAAI,EACV,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC;AAE/B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAmF7D"}
+{"version":3,"file":"segment-content.d.ts","sourceRoot":"","sources":["../../../src/json-render/segment-content.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,IAAI,EACV,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAoH7D"}

package/dist/src/motion.d.ts

@@ -11,6 +11,7 @@
  */
 /** Strong ease-out for entering/exiting chrome (fades, veils, headers). */
 export declare const EASE_OUT: readonly [0.23, 1, 0.32, 1];
+export declare const EASE_OUT_CSS: string;
 /** The default enter: a 200ms fade on `EASE_OUT`. */
 export declare const FADE_TRANSITION: {
     readonly duration: 0.2;

package/dist/src/motion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,QAAQ,6BAA8B,CAAC;AAEpD,qDAAqD;AACrD,eAAO,MAAM,eAAe;;;CAA6C,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;CAA8C,CAAC;AAEvE;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;CAKf,CAAC;AAUX,eAAO,MAAM,kBAAkB,QAA+C,CAAC;AAE/E;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,oIAC2G,CAAC;AAEpI,eAAO,MAAM,WAAW,gIACuG,CAAC;AAEhI,eAAO,MAAM,YAAY,oIAC0G,CAAC;AAEpI,eAAO,MAAM,WAAW,yIACgH,CAAC"}
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,QAAQ,6BAA8B,CAAC;AACpD,eAAO,MAAM,YAAY,QAAyC,CAAC;AAEnE,qDAAqD;AACrD,eAAO,MAAM,eAAe;;;CAA6C,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;CAA8C,CAAC;AAEvE;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;CAKf,CAAC;AAUX,eAAO,MAAM,kBAAkB,QAA+C,CAAC;AAE/E;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,oIAC2G,CAAC;AAEpI,eAAO,MAAM,WAAW,gIACuG,CAAC;AAEhI,eAAO,MAAM,YAAY,oIAC0G,CAAC;AAEpI,eAAO,MAAM,WAAW,yIACgH,CAAC"}

package/dist/src/page-controls/accessible-name.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The accessible name of a control — the words a screen reader would say.
+ *
+ * This is the whole point of reading the page: a customer says "the Change
+ * plan button", and the only way that matches a node is if we resolved the
+ * name the same way their browser does. A CSS class or a tag name is not a
+ * name; `aria-label`, a `<label>`, a `placeholder` and the visible text are.
+ *
+ * A trimmed-down accname resolution, in spec order for the cases that occur
+ * on real pages: aria-labelledby → aria-label → the native label (label
+ * element, legend, alt, title-of-image) → visible text → placeholder →
+ * title. `value` is NEVER a name source, even where the spec allows it for
+ * buttons, because an `<input type="submit" value="…">` is the one place
+ * where a field's value and its name are the same string, and letting it
+ * through would make "no values" depend on an input type.
+ */
+/**
+ * Resolve the name. Returns '' when the control has none — a nameless
+ * control is one the agent cannot talk about, so the reader drops it rather
+ * than inventing a name out of markup.
+ */
+export declare function accessibleName(el: HTMLElement): string;
+//# sourceMappingURL=accessible-name.d.ts.map

package/dist/src/page-controls/accessible-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessible-name.d.ts","sourceRoot":"","sources":["../../../src/page-controls/accessible-name.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAqDH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAwCtD"}

package/dist/src/page-controls/act-input.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+/**
+ * What the agent is allowed to ask for. `ref` is the only way to name a
+ * control — there is no selector and no text — and the action set is closed,
+ * so an invented verb is refused rather than interpreted.
+ */
+export declare const actOnPageInputSchema: z.ZodObject<{
+    ref: z.ZodString;
+    action: z.ZodEnum<{
+        fill: "fill";
+        select: "select";
+        check: "check";
+        click: "click";
+        uncheck: "uncheck";
+    }>;
+    value: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=act-input.d.ts.map

package/dist/src/page-controls/act-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"act-input.d.ts","sourceRoot":"","sources":["../../../src/page-controls/act-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;iBAK/B,CAAC"}

package/dist/src/page-controls/act-types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Doing something on the customer's page, and knowing whether it happened.
+ *
+ * The rule that shapes all of this: the agent may only report what the page
+ * actually did. Firing a click is easy; knowing whether the click DID
+ * anything is the work, and it is the difference between "I've cancelled
+ * your subscription" and the truth.
+ */
+/** What the agent can do to a control. Deliberately small. */
+export declare const PAGE_ACTIONS: readonly ["click", "fill", "select", "check", "uncheck"];
+export type PageAction = (typeof PAGE_ACTIONS)[number];
+/**
+ * Actions that COMMIT something on the customer's behalf — money moves, a
+ * record is destroyed, a form is submitted. These never happen without the
+ * visitor saying yes to that exact control, first.
+ *
+ * Recognised from what the control IS and what it SAYS, because that is all
+ * a page reliably tells us. It over-includes on purpose: asking about a
+ * harmless "Apply filters" button costs one chip, and not asking about
+ * "Delete account" costs an account.
+ */
+export declare const COMMITTING_WORDS: RegExp;
+/** The answer, in the same words the server and the agent use. */
+export type ActOutcome = 'done' | 'covered' | 'gone' | 'hidden' | 'unsupported' | 'no_change' | 'declined';
+export type ActResult = {
+    outcome: ActOutcome;
+    /** One short sentence for the agent to pass on. Never page text. */
+    detail?: string;
+};
+/**
+ * How long the page gets to react before we look at what changed. Long
+ * enough for a re-render, a menu to open or a fetch to come back on a local
+ * network; short enough that the turn's round trip stays under its budget.
+ */
+export declare const SETTLE_MS = 500;
+/**
+ * Controls the widget will never act on, whatever the agent asks and
+ * whatever the visitor allows. A password or a file picker is not something
+ * an agent types into, and a control inside a cross-origin frame is not
+ * something this page can honestly report on.
+ */
+export declare const NEVER_ACT_INPUT_TYPES: Set<string>;
+//# sourceMappingURL=act-types.d.ts.map

package/dist/src/page-controls/act-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"act-types.d.ts","sourceRoot":"","sources":["../../../src/page-controls/act-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,8DAA8D;AAC9D,eAAO,MAAM,YAAY,0DAMf,CAAC;AACX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,QAC4M,CAAC;AAE1O,kEAAkE;AAClE,MAAM,MAAM,UAAU,GAClB,MAAM,GACN,SAAS,GACT,MAAM,GACN,QAAQ,GACR,aAAa,GACb,WAAW,GACX,UAAU,CAAC;AAEf,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,UAAU,CAAC;IACpB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,MAAM,CAAC;AAE7B;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,aAA0C,CAAC"}

package/dist/src/page-controls/act.d.ts

@@ -0,0 +1,8 @@
+import { ActResult, PageAction } from './act-types';
+export declare function actOnPage(input: {
+    ref: string;
+    action: PageAction;
+    value?: string;
+    settleMs?: number;
+}): Promise<ActResult>;
+//# sourceMappingURL=act.d.ts.map

package/dist/src/page-controls/act.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"act.d.ts","sourceRoot":"","sources":["../../../src/page-controls/act.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AA+FrB,wBAAsB,SAAS,CAAC,KAAK,EAAE;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,SAAS,CAAC,CAerB"}

package/dist/src/page-controls/control-ref.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The table behind the references — held here, in the page, never sent.
+ *
+ * Every control the agent can talk about is one the reader put in this table
+ * in this turn. The wire carries `c7`; only this module knows which node
+ * that is. Three properties fall out of that, and they are the reason the
+ * table exists instead of the agent authoring CSS selectors:
+ *
+ * - The agent cannot reach a node we did not offer it. There is no selector
+ *   to widen, no text to guess at, no way to name the password field we
+ *   skipped.
+ * - A reference is checkable. Before drawing or clicking, `resolve` says
+ *   whether that exact node is still in the document — a stale reference
+ *   after a re-render is a "no", not a click on whatever moved into place.
+ * - The nodes are held weakly, so a table entry never keeps a detached
+ *   subtree of the customer's page alive.
+ */
+/** Open a new reading. Returns the mint function for its references. */
+export declare function beginSnapshot(): (el: HTMLElement) => string;
+/**
+ * The element behind a reference, or null — gone from the table, collected,
+ * or no longer in the document. "No longer the same node" and "not found"
+ * are deliberately the same answer: both mean do not act.
+ */
+export declare function resolveRef(ref: string): HTMLElement | null;
+/** Test seam: forget every reading. */
+export declare function resetRefsForTest(): void;
+//# sourceMappingURL=control-ref.d.ts.map

package/dist/src/page-controls/control-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-ref.d.ts","sourceRoot":"","sources":["../../../src/page-controls/control-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAYH,wEAAwE;AACxE,wBAAgB,aAAa,IAAI,CAAC,EAAE,EAAE,WAAW,KAAK,MAAM,CAW3D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAM1D;AAED,uCAAuC;AACvC,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC"}

package/dist/src/page-controls/cursor.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The pointer the visitor watches.
+ *
+ * Without it the page simply changes: a menu opens, a field fills, and the
+ * customer is left to work out whether they did that or something did it to
+ * them. A cursor that travels to the control and presses it answers that
+ * before they have to ask.
+ *
+ * It is drawn, never simulated input — the real events still come from
+ * `firePointerSequence`. The two are kept in step by aiming both at the same
+ * point: the control's centre. If the gesture and the event were allowed to
+ * drift apart this would be theatre, and theatre about what an agent did to
+ * someone's account is worse than no animation at all.
+ *
+ * Widget-owned and `pointer-events: none` throughout. It lives inside a
+ * fixed, clipped, full-viewport layer so travelling near an edge cannot
+ * grow the host page's scroll area, and it never touches a customer
+ * element or intercepts a click.
+ */
+export declare const CURSOR_APPEAR_MS = 260;
+/** The long haul. A hand crossing a dashboard takes about this. */
+export declare const CURSOR_TRAVEL_MS = 1600;
+/** A hand stops before it presses; without this the two moves read as one jerk. */
+export declare const CURSOR_REST_MS = 180;
+export declare const CURSOR_PRESS_MS = 240;
+type Cursor = {
+    /** Travel to a viewport point and stop there. */
+    moveTo(x: number, y: number): Promise<void>;
+    /** The squash and ring that read as a press. */
+    press(): Promise<void>;
+    /** Fade out and release the node. */
+    release(): void;
+};
+/**
+ * Take the pointer off the page NOW.
+ *
+ * `release` fades, which is right at the end of the work and wrong when
+ * something else is starting: the fade outlives the call, so effects in
+ * quick succession left ghosts drifting behind the live one. Anything still
+ * carrying the marker is removed outright here.
+ */
+export declare function dismissAgentCursor(): void;
+/**
+ * Put a pointer on the page, or hand back the one already there.
+ *
+ * Returns null when the document will not have it — the caller then does
+ * its own thing silently, because a missing animation must never stop the
+ * actual work.
+ */
+export declare function showAgentCursor(from?: {
+    x: number;
+    y: number;
+}): Cursor | null;
+/** The point both the gesture and the real event aim at. */
+export declare function centreOf(el: HTMLElement): {
+    x: number;
+    y: number;
+};
+/**
+ * Bring the control into view and walk the pointer to it.
+ *
+ * Every failure here is swallowed on purpose. The caller owes the waiting
+ * turn an answer, and an animation that cannot run is not a reason to
+ * withhold one — the work still happens, it just happens unaccompanied.
+ */
+export declare function travelTo(el: HTMLElement, { press }?: {
+    press?: boolean;
+}): Promise<{
+    done: () => void;
+}>;
+export {};
+//# sourceMappingURL=cursor.d.ts.map

package/dist/src/page-controls/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../../src/page-controls/cursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,OAAO,CAAC;AACrC,mFAAmF;AACnF,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,eAAe,MAAM,CAAC;AAqFnC,KAAK,MAAM,GAAG;IACZ,iDAAiD;IACjD,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,gDAAgD;IAChD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,qCAAqC;IACrC,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAwBF;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAOzC;AAQD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,CAAC,EAAE;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,GAAG,MAAM,GAAG,IAAI,CAgIhB;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,EAAE,EAAE,WAAW,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAGlE;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAC5B,EAAE,EAAE,WAAW,EACf,EAAE,KAAa,EAAE,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC,CAkB/B"}

package/dist/src/page-controls/guard.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The check that runs immediately before the widget touches a control —
+ * before it draws a mark, and (later) before it clicks.
+ *
+ * Between the reading that produced a reference and the tool call that uses
+ * it, a page can do anything: re-render, scroll, open a modal over the top.
+ * So the reference is not trusted as a permission to act; it is looked up,
+ * and then the element itself is asked three questions. Each "no" is a
+ * distinct answer, because the agent has to be able to say which one
+ * happened — "it is behind the dialog that just opened" is useful, "it
+ * didn't work" is not.
+ */
+export type GuardOutcome = 
+/** The element is there, visible, and the topmost thing at its own centre. */
+{
+    ok: true;
+    element: HTMLElement;
+}
+/** The reference means nothing here: never minted, expired, or detached. */
+ | {
+    ok: false;
+    reason: 'gone';
+}
+/** Still in the document, but not on screen. */
+ | {
+    ok: false;
+    reason: 'hidden';
+}
+/** On screen, but something else is in front of it. */
+ | {
+    ok: false;
+    reason: 'covered';
+}
+/**
+ * The page says hands off — a region marked private, something hidden
+ * from assistive tech, a credential field, our own UI. Re-checked HERE
+ * and not only when the page was read, because a page can mark a region
+ * private after the reference to it was handed out.
+ */
+ | {
+    ok: false;
+    reason: 'off-limits';
+    detail: string;
+};
+/** Look a reference up and ask the element whether it can be touched. */
+export declare function guardRef(ref: string): GuardOutcome;
+//# sourceMappingURL=guard.d.ts.map

package/dist/src/page-controls/guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../../src/page-controls/guard.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY;AACtB,8EAA8E;AAC5E;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE;AACpC,4EAA4E;GAC1E;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAC/B,gDAAgD;GAC9C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAA;CAAE;AACjC,uDAAuD;GACrD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE;AAClC;;;;;GAKG;GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AA6BxD,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CA6BlD"}

package/dist/src/page-controls/native-setter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Write a value the way a person would, so the framework notices.
+ *
+ * `el.value = x` sets the DOM property and nothing else. React tracks the
+ * last value it wrote on the node itself and compares against it, so a
+ * direct assignment followed by an `input` event looks to React like "the
+ * value is already what I think it is" and the change is swallowed — the
+ * field shows the new text and the app's state still holds the old one.
+ * Vue's v-model has the same shape of problem through its own listener.
+ *
+ * Going through the PROTOTYPE's setter is what a real keystroke does, and
+ * it is what makes the tracker see a change. Then the events: `input` for
+ * what is being typed, `change` for what was committed.
+ */
+export declare function setNativeValue(el: HTMLElement, value: string): boolean;
+//# sourceMappingURL=native-setter.d.ts.map

package/dist/src/page-controls/native-setter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-setter.d.ts","sourceRoot":"","sources":["../../../src/page-controls/native-setter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAkBtE"}

package/dist/src/page-controls/needs-consent.d.ts

@@ -0,0 +1,15 @@
+import { PageAction } from './act-types';
+/**
+ * Does this need the visitor to say yes first?
+ *
+ * Yes for anything that commits: a payment, a deletion, a form going in.
+ * The test is what the control says and what it is — a submit button, or a
+ * name with a committing word in it — because that is all a page reliably
+ * offers, and because the customer reading "Delete account" is the one who
+ * understands what it means here.
+ *
+ * Deliberately over-inclusive. A chip the visitor did not strictly need
+ * costs one tap; a missing chip costs whatever the button did.
+ */
+export declare function needsConsent(el: HTMLElement, action: PageAction): boolean;
+//# sourceMappingURL=needs-consent.d.ts.map

package/dist/src/page-controls/needs-consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"needs-consent.d.ts","sourceRoot":"","sources":["../../../src/page-controls/needs-consent.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAEhE;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAgBzE"}

package/dist/src/page-controls/off-limits.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The one list of things the agent may never read, point at or touch —
+ * checked when the page is read AND again in the instant before anything
+ * happens.
+ *
+ * Twice, because the two moments are not the same moment. An application
+ * marks its card form private when that form mounts, which can be after the
+ * message was sent; a dialog becomes `aria-hidden` behind a newer one. A
+ * reference minted before any of that still resolves, so a rule enforced
+ * only at read time is a rule with a window in it.
+ */
+export type OffLimitsReason = 'private' | 'hidden-from-assistive-tech' | 'credential-field' | 'widget-owned';
+export declare function offLimitsReason(el: HTMLElement): OffLimitsReason | null;
+/** What to tell the agent, without describing what it was kept away from. */
+export declare const OFF_LIMITS_DETAIL: Record<OffLimitsReason, string>;
+//# sourceMappingURL=off-limits.d.ts.map

package/dist/src/page-controls/off-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"off-limits.d.ts","sourceRoot":"","sources":["../../../src/page-controls/off-limits.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GACvB,SAAS,GACT,4BAA4B,GAC5B,kBAAkB,GAClB,cAAc,CAAC;AAEnB,wBAAgB,eAAe,CAAC,EAAE,EAAE,WAAW,GAAG,eAAe,GAAG,IAAI,CAWvE;AAED,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAQ7D,CAAC"}

package/dist/src/page-controls/pointer-sequence.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Click the way a pointer does, not the way `el.click()` does.
+ *
+ * `el.click()` dispatches one `click` event. Real interfaces listen for far
+ * more than that: a dropdown opens on `pointerdown`, a custom button
+ * highlights on `pointerover`, a menu item commits on `mouseup`. Anything
+ * built on a component library — which is most of what a support agent is
+ * ever asked to help with — simply does not respond to a bare click.
+ *
+ * So: the full sequence a mouse produces, at the control's own centre,
+ * with focus moved first like a real press does.
+ */
+export declare function firePointerSequence(el: HTMLElement): void;
+//# sourceMappingURL=pointer-sequence.d.ts.map

package/dist/src/page-controls/pointer-sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer-sequence.d.ts","sourceRoot":"","sources":["../../../src/page-controls/pointer-sequence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,CAyCzD"}

package/dist/src/page-controls/read-controls.d.ts

@@ -0,0 +1,4 @@
+import { PageControlSnapshot } from './types';
+/** Read the host page's controls for this turn. Never throws. */
+export declare function readPageControls(doc?: Document): PageControlSnapshot;
+//# sourceMappingURL=read-controls.d.ts.map

package/dist/src/page-controls/read-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-controls.d.ts","sourceRoot":"","sources":["../../../src/page-controls/read-controls.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,SAAS,CAAC;AAsJjB,iEAAiE;AACjE,wBAAgB,gBAAgB,CAC9B,GAAG,GAAE,QAAmB,GACvB,mBAAmB,CAyDrB"}

package/dist/src/page-controls/send-context.d.ts

@@ -0,0 +1,20 @@
+import { PageMark } from '../page-marks/page-mark';
+/**
+ * Everything about the customer's page that rides with one message.
+ *
+ * Two different things, sent together because they answer two different
+ * questions. The marks are what the visitor pointed at — deliberate, a
+ * gesture. The controls are what is simply THERE, read fresh at send time,
+ * so the agent can answer "where do I turn that off" without the visitor
+ * having to find and circle the switch first.
+ *
+ * Only the names go on the wire; the elements behind the references stay in
+ * the page (`control-ref.ts`). Reading happens at send time and nowhere
+ * else, which is what keeps a page turn free of an extra round trip.
+ */
+export declare function buildPageClientContext({ marks, readsPage, }: {
+    marks: PageMark[];
+    /** The org's page-context feature as the embed narrowed it. */
+    readsPage: boolean;
+}): Record<string, unknown> | undefined;
+//# sourceMappingURL=send-context.d.ts.map

package/dist/src/page-controls/send-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-context.d.ts","sourceRoot":"","sources":["../../../src/page-controls/send-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACd,MAAM,yBAAyB,CAAC;AAGjC;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,KAAK,EACL,SAAS,GACV,EAAE;IACD,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,+DAA+D;IAC/D,SAAS,EAAE,OAAO,CAAC;CACpB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAmBtC"}

package/dist/src/page-controls/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * What the agent knows about the controls on the customer's page.
+ *
+ * The widget reads the page itself and sends NAMES. The elements never
+ * leave the browser: each one is held here behind an opaque reference, and
+ * every later instruction — point at this, click that — comes back as one of
+ * those references. Nothing the agent says can name a node we did not offer
+ * it in this turn.
+ *
+ * What is deliberately absent: values. Not the text in a field, not the
+ * option a select is on, not a password, not a file name. A support agent
+ * needs to know that a "Change plan" button exists and is greyed out; it
+ * never needs to know what the visitor typed into "Card number".
+ */
+/** One control on the host page, as the agent reads it. */
+export type PageControl = {
+    /** Opaque handle for this turn. The agent points with it; only we resolve it. */
+    ref: string;
+    /** What the control IS: button, link, textbox, checkbox, … (ARIA role). */
+    role: string;
+    /** The control's accessible name — the words a screen reader would say. */
+    name: string;
+    /** Present and true only when the control cannot be used right now. */
+    disabled?: true;
+};
+/** One turn's reading of the page: the controls, and the table behind them. */
+export type PageControlSnapshot = {
+    controls: PageControl[];
+    /** Whether the page had more controls than the cap allowed us to send. */
+    truncated: boolean;
+};
+/**
+ * Attribute a customer puts on any part of their page the agent must never
+ * read. Everything inside is skipped whole — the control, its name, its
+ * existence. The one thing a page owner can say that the reader obeys
+ * without interpretation.
+ */
+export declare const PRIVATE_REGION_ATTRIBUTE = "data-opencx-private";
+/**
+ * Input types the reader refuses on sight, whatever else is true about them:
+ * a password is never described, and a file picker's name can carry the
+ * visitor's own file names.
+ */
+export declare const NEVER_READ_INPUT_TYPES: Set<string>;
+/**
+ * How many controls one message carries. A page with more than this is read
+ * in full (so the cap applies to the busiest part, not a random prefix) but
+ * sends only the first `MAX_CONTROLS` in document order, and says so.
+ * Chosen against the prompt, not the DOM: 300 names is roughly 3k tokens.
+ */
+export declare const MAX_CONTROLS = 300;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/page-controls/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/page-controls/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,2DAA2D;AAC3D,MAAM,MAAM,WAAW,GAAG;IACxB,iFAAiF;IACjF,GAAG,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,0EAA0E;IAC1E,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,aAA0C,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,YAAY,MAAM,CAAC"}

package/dist/src/page-marks/agent-mark.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 export declare const highlightElementInputSchema: z.ZodObject<{
-    selector: z.ZodOptional<z.ZodString>;
-    text: z.ZodOptional<z.ZodString>;
+    ref: z.ZodString;
     label: z.ZodOptional<z.ZodString>;
     type: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         circle: "circle";
@@ -22,10 +21,12 @@ export declare function dismissActiveHighlight(): void;
  * smooth scroll), and float an optional pointing callout. The page stays fully
  * interactive throughout — nothing is dimmed and no click is trapped.
  *
- * Returns false when the hint doesn't resolve to an element (the page may have
- * changed since the context was captured) — callers treat that as a no-op.
+ * Takes the element, not a way of finding one: WHICH element is the caller's
+ * decision (`guardRef` — the reference the reader handed out, checked to be
+ * the same node, on screen and not covered). The pen only draws. Returns
+ * false when the ink could not be laid down at all.
  */
-export declare function highlightElementOnHostPage(input: HighlightElementInput, { accentColor, surfaceColor, foregroundColor, zIndex, durationMs, seed, }?: {
+export declare function highlightElementOnHostPage(el: HTMLElement, input: Omit<HighlightElementInput, 'ref'>, { accentColor, surfaceColor, foregroundColor, zIndex, durationMs, seed, }?: {
     accentColor?: string;
     surfaceColor?: string;
     foregroundColor?: string;

package/dist/src/page-marks/agent-mark.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-mark.d.ts","sourceRoot":"","sources":["../../../src/page-marks/agent-mark.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwCxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;iBAStC,CAAC;AAEH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEzE,2FAA2F;AAC3F,eAAO,MAAM,6BAA6B,OAAO,CAAC;AA2BlD,yEAAyE;AACzE,wBAAgB,sBAAsB,SAErC;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,qBAAqB,EAC5B,EACE,WAA4B,EAC5B,YAA6B,EAC7B,eAAiC,EACjC,MAAmB,EACnB,UAA0C,EAC1C,IAAI,GACL,GAAE;IACD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;CACV,GACL,OAAO,CAmLT"}
+{"version":3,"file":"agent-mark.d.ts","sourceRoot":"","sources":["../../../src/page-marks/agent-mark.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuCxB,eAAO,MAAM,2BAA2B;;;;;;;;;;iBAetC,CAAC;AAEH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEzE,2FAA2F;AAC3F,eAAO,MAAM,6BAA6B,OAAO,CAAC;AA2BlD,yEAAyE;AACzE,wBAAgB,sBAAsB,SAErC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,KAAK,CAAC,EACzC,EACE,WAA4B,EAC5B,YAA6B,EAC7B,eAAiC,EACjC,MAAmB,EACnB,UAA0C,EAC1C,IAAI,GACL,GAAE;IACD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;CACV,GACL,OAAO,CAsLT"}

package/dist/src/screens/chat/ChatInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChatInput.d.ts","sourceRoot":"","sources":["../../../../src/screens/chat/ChatInput.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAuD,MAAM,OAAO,CAAC;AA+C5E;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EACxB,eAAe,EACf,WAAW,EACX,eAAe,GAChB,GAAE;IACD;;;;OAIG;IACH,eAAe,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAClC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CACtB,qBAipBL"}
+{"version":3,"file":"ChatInput.d.ts","sourceRoot":"","sources":["../../../../src/screens/chat/ChatInput.tsx"],"names":[],"mappings":"AAqBA,OAAO,KAAuD,MAAM,OAAO,CAAC;AA8C5E;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EACxB,eAAe,EACf,WAAW,EACX,eAAe,GAChB,GAAE;IACD;;;;OAIG;IACH,eAAe,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAClC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CACtB,qBA2qBL"}

package/dist/src/screens/chat/ChatMain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChatMain.d.ts","sourceRoot":"","sources":["../../../../src/screens/chat/ChatMain.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAa1D,wBAAgB,QAAQ,sBAkEvB"}
+{"version":3,"file":"ChatMain.d.ts","sourceRoot":"","sources":["../../../../src/screens/chat/ChatMain.tsx"],"names":[],"mappings":"AAUA,OAAO,KAA+C,MAAM,OAAO,CAAC;AAUpE,wBAAgB,QAAQ,sBAgFvB"}

package/dist/src/screens/chat/MessageGroups.d.ts

@@ -6,7 +6,9 @@ import { default as React } from 'react';
  * (server-resolved agent branding wins); human-agent groups prefer the
  * server-provided sender, patched by the `humanAgent` config override.
  */
-export declare function MessageGroups({ groups }: {
+export declare function MessageGroups({ groups, pendingReply, }: {
     groups: WidgetMessageU[][];
+    /** The latest reply is still being prepared, including between polled updates. */
+    pendingReply?: boolean;
 }): React.JSX.Element;
 //# sourceMappingURL=MessageGroups.d.ts.map

package/dist/src/screens/chat/MessageGroups.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageGroups.d.ts","sourceRoot":"","sources":["../../../../src/screens/chat/MessageGroups.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,MAAM,OAAO,CAAC;AAS1B;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,cAAc,EAAE,EAAE,CAAA;CAAE,qBAuDvE"}
+{"version":3,"file":"MessageGroups.d.ts","sourceRoot":"","sources":["../../../../src/screens/chat/MessageGroups.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,MAAM,OAAO,CAAC;AAS1B;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,YAAoB,GACrB,EAAE;IACD,MAAM,EAAE,cAAc,EAAE,EAAE,CAAC;IAC3B,kFAAkF;IAClF,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,qBAwDA"}

package/dist/src/screens/chat/agent/AgentChatMain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AgentChatMain.d.ts","sourceRoot":"","sources":["../../../../../src/screens/chat/agent/AgentChatMain.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAgBvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,sBAmM5B"}
+{"version":3,"file":"AgentChatMain.d.ts","sourceRoot":"","sources":["../../../../../src/screens/chat/agent/AgentChatMain.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAiBvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,sBAqN5B"}