@grampro/kit 2.7.2 → 2.7.3

package/source/components/shared/core/agent/write.ts

@@ -1,58 +1,62 @@
-/*
- * Writing to a field the way a person does.
- *
- * This is the one file under `agent/` that needs a browser. Everything else
- * here validates, and validation runs anywhere; executing has to touch
- * something real. It is kept separate so the split is visible rather than
- * discovered when a server build fails.
- *
- * Why not simply assign `input.value = x`: React tracks the last value it
- * wrote on the DOM node, and an assignment that bypasses the prototype setter
- * leaves that tracker in step with the new value. React then concludes nothing
- * changed and never fires `onChange`, so a controlled field snaps back on the
- * next render. Going through the prototype setter and dispatching a real
- * bubbling event is what makes the change indistinguishable from typing — to
- * React, to form libraries, and to any plain listener.
- *
- * `Input.clear()` has worked this way since before there was an agent runtime.
- * This is the same technique, generalised to textareas and to checkedness.
- */
-
-type Writable = HTMLInputElement | HTMLTextAreaElement;
-
-/** The prototype that owns the real setter for this element. */
-const prototypeOf = (element: Writable) =>
-  element instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
-
-function nativeSetter(element: Writable, property: "value" | "checked") {
-  return Object.getOwnPropertyDescriptor(prototypeOf(element), property)?.set;
-}
-
-/**
- * Set a field's text through the prototype setter, then fire the events a
- * person typing would have fired.
- */
-export function writeValue(element: Writable, value: string): void {
-  nativeSetter(element, "value")?.call(element, value);
-  element.dispatchEvent(new Event("input", { bubbles: true }));
-  element.dispatchEvent(new Event("change", { bubbles: true }));
-}
-
-/**
- * Set a checkbox or radio, as a click would.
- *
- * `checked` rather than `value`, and a `click` is not used: clicking a radio
- * that is already selected does nothing, and clicking a disabled one is
- * silently dropped. Setting the property and announcing it is both more
- * predictable and easier to reason about from a validator's point of view —
- * by the time this runs, the policy layer has already decided it is allowed.
- */
-export function writeChecked(element: HTMLInputElement, checked: boolean): void {
-  nativeSetter(element, "checked")?.call(element, checked);
-  element.dispatchEvent(new Event("input", { bubbles: true }));
-  element.dispatchEvent(new Event("change", { bubbles: true }));
-}
-
-/** True when the element can still be written to at all. */
-export const writable = (element: Writable | null | undefined): element is Writable =>
-  Boolean(element) && !(element as Writable).disabled && !(element as Writable).readOnly;
+/*
+ * Writing to a field the way a person does.
+ *
+ * This is the one file under `agent/` that needs a browser. Everything else
+ * here validates, and validation runs anywhere; executing has to touch
+ * something real. It is kept separate so the split is visible rather than
+ * discovered when a server build fails.
+ *
+ * Why not simply assign `input.value = x`: React tracks the last value it
+ * wrote on the DOM node, and an assignment that bypasses the prototype setter
+ * leaves that tracker in step with the new value. React then concludes nothing
+ * changed and never fires `onChange`, so a controlled field snaps back on the
+ * next render. Going through the prototype setter and dispatching a real
+ * bubbling event is what makes the change indistinguishable from typing — to
+ * React, to form libraries, and to any plain listener.
+ *
+ * `Input.clear()` has worked this way since before there was an agent runtime.
+ * This is the same technique, generalised to textareas and to checkedness.
+ */
+
+type Writable = HTMLInputElement | HTMLTextAreaElement;
+
+/** The prototype that owns the real setter for this element. */
+const prototypeOf = (element: Writable) =>
+  element instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+
+function nativeSetter(element: Writable, property: "value" | "checked") {
+  return Object.getOwnPropertyDescriptor(prototypeOf(element), property)?.set;
+}
+
+/**
+ * Set a field's text through the prototype setter, then fire the events a
+ * person typing would have fired.
+ */
+export function writeValue(element: Writable, value: string): void {
+  nativeSetter(element, "value")?.call(element, value);
+  element.dispatchEvent(new Event("input", { bubbles: true }));
+  element.dispatchEvent(new Event("change", { bubbles: true }));
+}
+
+/**
+ * Set a checkbox or radio by clicking it, when it is not already as asked.
+ *
+ * Not the setter-plus-events used for text. React hears a checkbox change
+ * through its `click` event, not `change`, so a set property announced with
+ * `change` updates the box and leaves a controlled one's state behind — the
+ * write reports success and the application never learns of it. 2.7.0 shipped
+ * that way; the e2e surface test is what caught it.
+ *
+ * A click is what a person does, so everything downstream sees exactly that:
+ * React, form libraries, a host that cancels the click. Already in the asked
+ * state is a no-op, as clicking a selected radio is. A disabled element was
+ * refused before this ran.
+ */
+export function writeChecked(element: HTMLInputElement, checked: boolean): void {
+  if (element.checked === checked) return;
+  element.click();
+}
+
+/** True when the element can still be written to at all. */
+export const writable = (element: Writable | null | undefined): element is Writable =>
+  Boolean(element) && !(element as Writable).disabled && !(element as Writable).readOnly;

package/source/components/shared/index.ts

@@ -15,3 +15,10 @@ export {
   type GramproAIProviderProps,
 } from "./react/GramproAIProvider";
 export { useAskAgent, type AskableAgent, type AskExecution, type UseAskAgent } from "./react/useAskAgent";
+export { useFieldAgent, type UseFieldAgentOptions } from "./react/useFieldAgent";
+export { AgentSurface, useAgentSurface, type AgentSurfaceProps } from "./react/AgentSurface";
+export {
+  useInAgentSurface,
+  type SurfaceFieldSource,
+  type SurfaceGridAgent,
+} from "./react/agentSurfaceContext";

package/source/components/shared/react/AgentSurface.tsx

@@ -0,0 +1,145 @@
+"use client";
+
+/*
+ * <AgentSurface>: the page describes itself to an agent.
+ *
+ *   <AgentSurface>
+ *     <Input label="Name" />
+ *     <Select label="Team" options={teams} />
+ *     <DatePicker label="Due date" minDate={today} />
+ *     <DataGrid data={rows} columns={columns} />
+ *   </AgentSurface>
+ *
+ * Every operable component inside registers itself, with what it holds and
+ * accepts as it is rendered now. In a browser with WebMCP, one tool,
+ * `operate_page`, is registered: `describe` returns that live manifest,
+ * `operate` sends intents to one component by id. Each request goes through
+ * that component's own validator; nothing reaches the DOM that the component
+ * would not accept from a person.
+ *
+ * Without WebMCP nothing is registered and nothing breaks. `useAgentSurface()`
+ * hands the same surface to an application that runs its own agent loop.
+ */
+
+import { createContext, useContext, useEffect, useMemo, useState, type ReactNode } from "react";
+import {
+  autoFieldExecutors,
+  createAgentSurface,
+  createFieldAgent,
+  describeFieldContract,
+  projectFieldAgent,
+  registerSurfaceTool,
+  type AgentSurfaceHandle as Surface,
+  type ToolCallLog,
+} from "../core/agent";
+import {
+  AgentSurfaceRegistrar,
+  type SurfaceFieldSource,
+  type SurfaceGridAgent,
+  type SurfaceRegistrar,
+} from "./agentSurfaceContext";
+
+const SurfaceContext = createContext<Surface | null>(null);
+
+export interface AgentSurfaceProps {
+  children: ReactNode;
+  /** Register the `operate_page` WebMCP tool when the browser has it. Default true. */
+  webmcp?: boolean;
+  /** Override the tool name. One name per page: WebMCP cannot unregister a tool. */
+  toolName?: string;
+  /** Observe every tool call, for a UI log or a test. */
+  onCall?: (entry: ToolCallLog) => void;
+}
+
+/** A field as a member: rebuilt from its current source on every request. */
+function fieldMember(source: () => SurfaceFieldSource) {
+  const first = source().contract;
+  const agentNow = () => {
+    const { contract, target } = source();
+    return createFieldAgent({
+      contract,
+      executors: autoFieldExecutors(target, {
+        checkable: contract.kind === "boolean",
+        component: contract.component,
+      }),
+    });
+  };
+  return {
+    kind: "field" as const,
+    component: first.component,
+    label: first.label,
+    agent: projectFieldAgent(agentNow),
+    describe: () => describeFieldContract(source().contract),
+  };
+}
+
+/** A grid as a member: its columns, operations and the schema of one intent. */
+function gridMember(label: string | undefined, agent: SurfaceGridAgent) {
+  return {
+    kind: "grid" as const,
+    component: "DataGrid",
+    label,
+    agent,
+    describe: () => {
+      const contract = agent.contract();
+      return {
+        columns: contract.columns
+          // A policy-restricted column is not offered; the grid refuses it anyway.
+          .filter((column) => !column.restricted)
+          .map((column) => ({
+            id: column.id,
+            label: column.label,
+            type: column.type,
+            ...(column.sortable ? { sortable: true } : {}),
+            ...(column.filterable ? { filterable: true, operators: column.operators } : {}),
+            ...(column.options ? { options: column.options } : {}),
+          })),
+        operations: contract.operations,
+        rows: { showing: contract.stats?.filteredRows, total: contract.stats?.totalRows },
+        input: agent.schema(),
+      };
+    },
+    summarise: () => {
+      const contract = agent.contract();
+      return {
+        rowsShowing: contract.stats?.filteredRows,
+        rowsTotal: contract.stats?.totalRows,
+        canUndo: contract.state?.canUndo,
+      };
+    },
+  };
+}
+
+export function AgentSurface({ children, webmcp = true, toolName, onCall }: AgentSurfaceProps) {
+  const [surface] = useState(createAgentSurface);
+
+  const registrar = useMemo<SurfaceRegistrar>(
+    () => ({
+      field: (source) => surface.register(fieldMember(source)).unregister,
+      grid: (label, agent) => surface.register(gridMember(label, agent)).unregister,
+    }),
+    [surface],
+  );
+
+  useEffect(() => {
+    if (!webmcp) return undefined;
+    const registration = registerSurfaceTool(() => surface, { name: toolName, onCall });
+    return registration.release;
+  }, [surface, webmcp, toolName, onCall]);
+
+  return (
+    <SurfaceContext.Provider value={surface}>
+      <AgentSurfaceRegistrar.Provider value={registrar}>{children}</AgentSurfaceRegistrar.Provider>
+    </SurfaceContext.Provider>
+  );
+}
+
+/**
+ * The surface in scope, or null outside an <AgentSurface>.
+ *
+ * For an application that runs its own agent: `manifest()` is what to put in
+ * front of the model, `run(id, intents)` is how to act on its answer.
+ */
+export function useAgentSurface(): Surface | null {
+  return useContext(SurfaceContext);
+}

package/source/components/shared/react/agentSurfaceContext.ts

@@ -0,0 +1,92 @@
+"use client";
+
+/*
+ * How a component joins an <AgentSurface>, if there is one.
+ *
+ * Every operable component imports this, so it is kept to a context and two
+ * hooks with type-only imports: an app that never renders an <AgentSurface>
+ * pays for a `useContext` per component and nothing else. The validators,
+ * executors and WebMCP code live behind AgentSurface.tsx, and are only in a
+ * bundle that imports it.
+ *
+ * Components register *themselves*. That is the point: a page gets an agent
+ * interface without its author writing a single tool definition, and without
+ * one drifting from the UI, because the description is the component's own.
+ */
+import { createContext, useContext, useEffect, useRef } from "react";
+import type { FieldContract, FieldHandleTarget, ProjectableAgent } from "../core/agent";
+
+/** What a field hands the surface: what it accepts now, and how to write to it. */
+export interface SurfaceFieldSource {
+  readonly contract: FieldContract;
+  /** The element or handle to write through, read when an action runs. */
+  readonly target: () => HTMLInputElement | HTMLTextAreaElement | FieldHandleTarget | null;
+}
+
+/**
+ * A grid's agent, described structurally: `shared/` cannot import the
+ * DataGrid, and does not need to — anything with a schema, a validator and a
+ * live contract of columns can join.
+ */
+export interface SurfaceGridAgent extends ProjectableAgent {
+  contract(): {
+    readonly columns: readonly {
+      readonly id: string;
+      readonly label: string;
+      readonly type: string;
+      readonly sortable: boolean;
+      readonly filterable: boolean;
+      readonly operators?: readonly string[];
+      readonly options?: readonly unknown[];
+      readonly restricted?: string;
+    }[];
+    readonly operations: readonly string[];
+    readonly stats?: { readonly filteredRows?: number | null; readonly totalRows?: number | null };
+    readonly state?: { readonly canUndo?: boolean };
+  };
+}
+
+export interface SurfaceRegistrar {
+  field(source: () => SurfaceFieldSource): () => void;
+  grid(label: string | undefined, agent: SurfaceGridAgent): () => void;
+}
+
+export const AgentSurfaceRegistrar = createContext<SurfaceRegistrar | null>(null);
+
+/** Whether this component is inside an <AgentSurface>. */
+export const useInAgentSurface = (): boolean => useContext(AgentSurfaceRegistrar) !== null;
+
+/**
+ * Join the surface as a field, for as long as this component is mounted.
+ *
+ * `build` is read when an agent asks, not when the component renders, so a
+ * field that has just become disabled is refused on the very next request.
+ * `enabled: false` keeps a field out entirely — a password input is never
+ * offered to an agent.
+ */
+export function useAgentSurfaceField(build: () => SurfaceFieldSource, enabled = true): void {
+  const registrar = useContext(AgentSurfaceRegistrar);
+  const latest = useRef(build);
+  latest.current = build;
+  useEffect(() => {
+    if (!registrar || !enabled) return undefined;
+    return registrar.field(() => latest.current());
+  }, [registrar, enabled]);
+}
+
+/** Join the surface as a grid, once its agent exists. */
+export function useAgentSurfaceGrid(agent: SurfaceGridAgent | null, label: string | undefined): void {
+  const registrar = useContext(AgentSurfaceRegistrar);
+  useEffect(() => {
+    if (!registrar || !agent) return undefined;
+    return registrar.grid(label, agent);
+  }, [registrar, agent, label]);
+}
+
+/** The text of a label prop, when it is text. A ReactNode label has none to offer. */
+export const labelText = (...candidates: unknown[]): string | undefined => {
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+  }
+  return undefined;
+};

package/source/components/shared/react/useFieldAgent.ts

@@ -1,88 +1,62 @@
-"use client";
-
-/*
- * Make a field agent-operable without changing the field.
- *
- * The DataGrid takes an `agent` prop because a grid's runtime needs to see the
- * data, the columns and the live state to say anything useful. A field needs
- * none of that: its contract is its own props, and its executor is the ref the
- * caller already holds. So this is a hook rather than a prop, and no component
- * had to grow an API to support it.
- *
- *   const ref = useRef<HTMLInputElement>(null);
- *   const agent = useFieldAgent({
- *     contract: { component: "Input", kind: "text", operations: ["setValue", "clear", "focus"], maxLength: 80 },
- *     target: ref,
- *   });
- *
- *   await agent.run({ action: "setValue", value: "Ada Lovelace" });
- *
- * `target` is whatever that component's ref gives you. Input, Textarea,
- * NumberInput, Checkbox, Switch and Radio hand back the DOM element; Combobox
- * and DatePicker hand back a handle. The hook tells them apart and nothing
- * above it has to care.
- */
-
-import { useMemo, useRef } from "react";
-import {
-  createFieldAgent,
-  domFieldExecutors,
-  handleFieldExecutors,
-  type FieldAgent,
-  type FieldContract,
-  type FieldHandleTarget,
-  type RegisteredExecutor,
-} from "../core/agent";
-
-type Target =
-  | { readonly current: HTMLInputElement | HTMLTextAreaElement | null }
-  | { readonly current: FieldHandleTarget | null };
-
-export interface UseFieldAgentOptions {
-  /** What this instance will accept. Rebuild it from props as they change. */
-  readonly contract: FieldContract;
-  /** The component's ref: a DOM element for most fields, a handle for some. */
-  readonly target: Target;
-}
-
-/** A handle, as opposed to a DOM node. Checked by capability, not by instanceof. */
-const isHandle = (value: unknown): value is FieldHandleTarget =>
-  Boolean(value) && typeof (value as FieldHandleTarget).setValue === "function";
-
-export function useFieldAgent({ contract, target }: UseFieldAgentOptions): FieldAgent {
-  // The ref object is stable; its contents are not, and the executors read
-  // them at call time rather than closing over whatever was there on mount.
-  const latest = useRef(target);
-  latest.current = target;
-
-  return useMemo(() => {
-    const read = () => latest.current.current as unknown;
-
-    /*
-     * Which kind of target this is cannot be decided here: a ref is null on
-     * the first render, and deciding then would type every component as a DOM
-     * field and never revisit it. Both registries are built, and the choice is
-     * made inside `execute`, by which point the ref is populated.
-     */
-    const dom = domFieldExecutors(() => read() as HTMLInputElement | HTMLTextAreaElement | null, {
-      checkable: contract.kind === "boolean",
-    });
-    const handle = handleFieldExecutors(() => read() as FieldHandleTarget | null);
-
-    const executors = new Map<string, RegisteredExecutor<FieldContract>>();
-    for (const name of new Set([...dom.keys(), ...handle.keys()])) {
-      executors.set(name, {
-        operation: name,
-        execute: (input, context) => {
-          const chosen = isHandle(read()) ? handle.get(name) : dom.get(name);
-          if (!chosen) throw new Error(`${contract.component} cannot ${name}.`);
-          return chosen.execute(input, context);
-        },
-      } as RegisteredExecutor<FieldContract>);
-    }
-
-    return createFieldAgent({ contract, executors });
-    // The contract is the dependency that matters: a field that has just
-    // become read-only must stop accepting writes on the very next render.
-  }, [contract]);
-}
+"use client";
+
+/*
+ * Make a field agent-operable without changing the field.
+ *
+ * The DataGrid takes an `agent` prop because a grid's runtime needs to see the
+ * data, the columns and the live state to say anything useful. A field needs
+ * none of that: its contract is its own props, and its executor is the ref the
+ * caller already holds. So this is a hook rather than a prop, and no component
+ * had to grow an API to support it.
+ *
+ *   const ref = useRef<HTMLInputElement>(null);
+ *   const agent = useFieldAgent({
+ *     contract: { component: "Input", kind: "text", operations: ["setValue", "clear", "focus"], maxLength: 80 },
+ *     target: ref,
+ *   });
+ *
+ *   await agent.run({ action: "setValue", value: "Ada Lovelace" });
+ *
+ * `target` is whatever that component's ref gives you. Input, Textarea,
+ * NumberInput, Checkbox, Switch and Radio hand back the DOM element; Combobox
+ * and DatePicker hand back a handle. The hook tells them apart and nothing
+ * above it has to care.
+ */
+
+import { useMemo, useRef } from "react";
+import {
+  autoFieldExecutors,
+  createFieldAgent,
+  type FieldAgent,
+  type FieldContract,
+  type FieldHandleTarget,
+} from "../core/agent";
+
+type Target =
+  | { readonly current: HTMLInputElement | HTMLTextAreaElement | null }
+  | { readonly current: FieldHandleTarget | null };
+
+export interface UseFieldAgentOptions {
+  /** What this instance will accept. Rebuild it from props as they change. */
+  readonly contract: FieldContract;
+  /** The component's ref: a DOM element for most fields, a handle for some. */
+  readonly target: Target;
+}
+
+export function useFieldAgent({ contract, target }: UseFieldAgentOptions): FieldAgent {
+  // The ref object is stable; its contents are not, and the executors read
+  // them at call time rather than closing over whatever was there on mount.
+  const latest = useRef(target);
+  latest.current = target;
+
+  return useMemo(() => {
+    // DOM element or handle is decided per call; see autoFieldExecutors.
+    const executors = autoFieldExecutors(() => latest.current.current, {
+      checkable: contract.kind === "boolean",
+      component: contract.component,
+    });
+    return createFieldAgent({ contract, executors });
+    // The contract is the dependency that matters: a field that has just
+    // become read-only must stop accepting writes on the very next render.
+  }, [contract]);
+}

package/source/components/shared/version.json

@@ -1,4 +1,4 @@
-{
-  "name": "shared",
-  "version": "1.3.0"
-}
+{
+  "name": "shared",
+  "version": "1.4.0"
+}

package/source/components/shared/version.ts

@@ -1,6 +1,6 @@
-/**
- * Bumped whenever anything in `shared/` changes. The installer copies
- * `version.json` next to it and compares the two, so a project is never left
- * with components built against a newer `shared/` than the one on disk.
- */
-export const version = "1.3.0";
+/**
+ * Bumped whenever anything in `shared/` changes. The installer copies
+ * `version.json` next to it and compares the two, so a project is never left
+ * with components built against a newer `shared/` than the one on disk.
+ */
+export const version = "1.4.0";

package/source/components/skeleton/passport.json

@@ -9,7 +9,7 @@
     ]
   },
   "source": {
-    "libraryVersion": "2.7.2",
+    "libraryVersion": "2.7.3",
     "files": [
       "core/index.ts",
       "core/lines.ts",

package/source/components/spinner/passport.json

@@ -8,7 +8,7 @@
     ]
   },
   "source": {
-    "libraryVersion": "2.7.2",
+    "libraryVersion": "2.7.3",
     "files": [
       "core/index.ts",
       "core/types.ts",

package/source/components/switch/passport.json

@@ -8,7 +8,7 @@
     ]
   },
   "source": {
-    "libraryVersion": "2.7.2",
+    "libraryVersion": "2.7.3",
     "files": [
       "core/agent.ts",
       "core/index.ts",
@@ -19,7 +19,7 @@
       "react/locale.ts",
       "react/props.ts"
     ],
-    "sourceHash": "sha256:4e168aeb5ca0aef334176cc4edb1b15c63546bf415df867085dadf871f9e24af"
+    "sourceHash": "sha256:a6a81781252ff87f408c06ac48e31dcd38c85d879d15fae37647205527630667"
   },
   "purpose": "A setting that takes effect as it is flipped, on a native checkbox with role=switch, with an optimistic pending state while the change is saved.",
   "props": [

package/source/components/switch/passport.manual.json

@@ -5,7 +5,7 @@
   "intentDomains": [
     "ActionIntent"
   ],
-  "$operationsNote": "Mirrors shared/core/agent/field.ts, which is what the runtime dispatches on. source/components/shared/core/agent/__tests__/field-passport.test.ts fails if the two drift. No `apiMethod`: a field is written through its ref — the element for most of these, a handle for Combobox and DatePicker — and that is a normal case, not a gap.",
+  "$operationsNote": "Mirrors shared/core/agent/field.ts, which is what the runtime dispatches on. source/components/shared/core/agent/__tests__/field-passport.test.ts fails if the two drift. No `apiMethod`: a field is written through its ref — the element for most of these, a handle for Combobox and DatePicker — and that is a normal case, not a gap. Inside an <AgentSurface> the component registers itself with these operations; NumberInput and RadioGroup are then written through their own commit path rather than the element.",
   "operations": {
     "setValue": {
       "summary": "Write a value into the field, as though a person had entered it.",

package/source/components/switch/react/Switch.tsx

@@ -15,6 +15,7 @@ import {
   type Ref,
 } from "react";
 import { describeField } from "../../shared/core/field";
+import { labelText, useAgentSurfaceField } from "../../shared/react/agentSurfaceContext";
 import { adopt, idleToggle, request, settle } from "../core/toggle";
 import type { SwitchLabelPosition, SwitchLocaleText, SwitchSize } from "../core/types";
 import { defaultSwitchText } from "./locale";
@@ -164,6 +165,21 @@ export function Switch(props: SwitchProps) {
     if (next !== checked) change(next);
   };
 
+  // Inside an <AgentSurface>, offered to an agent as a setting it can turn on
+  // or off. A switch still saving refuses, as it does a click.
+  useAgentSurfaceField(() => ({
+    contract: {
+      component: "Switch",
+      kind: "boolean",
+      label: labelText(label, inputProps["aria-label"], name, value),
+      disabled,
+      readOnly: readOnly || saving,
+      required,
+      operations: ["setValue", "clear", "focus"],
+    },
+    target: () => inputRef.current,
+  }));
+
   const invalid = Boolean(error);
   const describedBy = describeField(id, { extra: describedByProp, description, error });
 

package/source/components/tabs/passport.json

@@ -12,7 +12,7 @@
     ]
   },
   "source": {
-    "libraryVersion": "2.7.2",
+    "libraryVersion": "2.7.3",
     "files": [
       "core/index.ts",
       "core/navigation.ts",

package/source/components/textarea/passport.json

@@ -8,7 +8,7 @@
     ]
   },
   "source": {
-    "libraryVersion": "2.7.2",
+    "libraryVersion": "2.7.3",
     "files": [
       "core/agent.ts",
       "core/count.ts",
@@ -20,7 +20,7 @@
       "react/locale.ts",
       "react/props.ts"
     ],
-    "sourceHash": "sha256:161bed57c97bbdede609bde754dcbae8452083825fea7749ee035ce1ace510dc"
+    "sourceHash": "sha256:32d4cdc40c633e35034d2b20b829e916b3caee74abe1af0ce3235e1348fead9e"
   },
   "purpose": "A multi-line text field that can grow with its content, with the same label, hint, error and counter wiring as Input.",
   "props": [