@yaklabs-ai/plugin-sdk 0.45.0 → 0.47.0

package/dist/kay-app.d.ts

@@ -34,6 +34,60 @@ export declare interface AccessApprovalTypeDefinition {
     }, ctx: AccessApprovalContext) => Promise<FinalizedAccessApproval>;
 }
 
+/**
+ * Action binding — maps an event to an action invocation.
+ *
+ * Used inside the `on` field of a UIElement:
+ * ```json
+ * { "on": { "press": { "action": "setState", "params": { "statePath": "/x", "value": 1 } } } }
+ * ```
+ */
+declare interface ActionBinding {
+    /** Action name (must be in catalog) */
+    action: string;
+    /** Parameters to pass to the action handler */
+    params?: Record<string, DynamicValue>;
+    /** Confirmation dialog before execution */
+    confirm?: ActionConfirm;
+    /** Handler after successful execution */
+    onSuccess?: ActionOnSuccess;
+    /** Handler after failed execution */
+    onError?: ActionOnError;
+    /** Whether to prevent default browser behavior (e.g. navigation on links) */
+    preventDefault?: boolean;
+}
+
+/**
+ * Confirmation dialog configuration
+ */
+declare interface ActionConfirm {
+    title: string;
+    message: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    variant?: "default" | "danger";
+}
+
+/**
+ * Action error handler
+ */
+declare type ActionOnError = {
+    set: Record<string, unknown>;
+} | {
+    action: string;
+};
+
+/**
+ * Action success handler
+ */
+declare type ActionOnSuccess = {
+    navigate: string;
+} | {
+    set: Record<string, unknown>;
+} | {
+    action: string;
+};
+
 declare const AdapterPlacement: z.ZodEnum<{
     "local-only": "local-only";
     anywhere: "anywhere";
@@ -107,6 +161,15 @@ export declare type AgentToolUpdateCallback<T = any> = (partialResult: AgentTool
 
 declare const Alpha: TAlpha;
 
+/**
+ * AND wrapper — all child conditions must be true.
+ * This is the explicit form of the implicit array AND (`SingleCondition[]`).
+ * Unlike the implicit form, `$and` supports nested `$or` and `$and` conditions.
+ */
+declare type AndCondition = {
+    $and: VisibilityCondition[];
+};
+
 /** Compatibility settings for Anthropic Messages-compatible APIs. */
 declare interface AnthropicMessagesCompat extends Static<typeof AnthropicMessagesCompatSchema> {
 }
@@ -581,6 +644,9 @@ declare function Capitalize_2<Type extends TSchema>(type: Type, options?: TSchem
 /** Creates a deferred Capitalize action. */
 declare function CapitalizeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TCapitalizeDeferred<Type>;
 
+/** Build a json-render card; state is shared by every child through JSON pointers. */
+export declare function card(title: string, children: readonly KayAppCardLayout[], state?: Record<string, unknown>): KayAppCardLayout;
+
 declare namespace Char {
     export {
         TAlpha,
@@ -676,6 +742,34 @@ declare const CompareResultLeftInside = 2;
 
 declare const CompareResultRightInside = 3;
 
+/**
+ * Shared comparison operators for visibility conditions.
+ *
+ * Use at most ONE comparison operator per condition. If multiple are
+ * provided, only the first matching one is evaluated (precedence:
+ * eq > neq > gt > gte > lt > lte). With no operator, truthiness is checked.
+ *
+ * `not` inverts the final result of whichever operator (or truthiness
+ * check) is used.
+ */
+declare type ComparisonOperators = {
+    eq?: unknown;
+    neq?: unknown;
+    gt?: number | {
+        $state: string;
+    };
+    gte?: number | {
+        $state: string;
+    };
+    lt?: number | {
+        $state: string;
+    };
+    lte?: number | {
+        $state: string;
+    };
+    not?: true;
+};
+
 declare const COMPOSER_REFERENCES_CUSTOM_TYPE = "composer_references";
 
 declare interface ComposerReferencesDetails {
@@ -1193,6 +1287,16 @@ declare interface DynamicContextSection {
     readonly items?: readonly DynamicContextItem[];
 }
 
+/**
+ * Dynamic value - can be a literal or a `{ $state }` reference to the state model.
+ *
+ * Used in action params and validation args where values can either be
+ * hardcoded or resolved from state at runtime.
+ */
+declare type DynamicValue<T = unknown> = T | {
+    $state: string;
+};
+
 declare const Element: (input: string) => [unknown, string] | [];
 
 declare const ElementBase: (input: string) => [unknown, string] | [];
@@ -1715,6 +1819,14 @@ declare const IndexArray_0: (input: string, result?: unknown[]) => [unknown[], s
 
 declare function IndexArrayMapping(input: ([unknown, unknown, unknown] | [unknown, unknown])[]): unknown;
 
+/**
+ * A condition that resolves `$index` to the current repeat array index.
+ * Only meaningful inside a `repeat` scope.
+ */
+declare type IndexCondition = {
+    $index: true;
+} & ComparisonOperators;
+
 /** Creates a deferred Index action. */
 declare function IndexDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TIndexDeferred<Type, Indexer>;
 
@@ -2005,6 +2117,16 @@ declare function IsUnsafe(value: unknown): value is TUnsafe;
 /** Returns true if the given value is TVoid. */
 declare function IsVoid(value: unknown): value is TVoid;
 
+/**
+ * A condition that resolves `$item` to a field on the current repeat item.
+ * Only meaningful inside a `repeat` scope.
+ *
+ * Use `""` to reference the whole item, or `"field"` for a specific field.
+ */
+declare type ItemCondition = {
+    $item: string;
+} & ComparisonOperators;
+
 declare const JsonObject: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
 
 declare type JsonObject = z.infer<typeof JsonObject>;
@@ -2745,9 +2867,21 @@ declare const KAY_PLUGIN_PROTOCOL_VERSION: "kay.plugin.v1";
  * 0.44.0 adds `words.kinds` to a reference presentation (#15905): an ordered list of address patterns
  * and the kind each one names. Additive: a plugin that lists them declares ^0.44.0.
  *
- * 0.45.0 adds declared plugin cards and app.implementCard for their read/submit endpoints.
+ * 0.45.0 adds declared plugin cards and app.implementCard for their read/submit endpoints. It also
+ * lets a plugin declare what the window hardcoded about it (#15906). A reference presentation gains
+ * `accountLinks`, how a page opens under the account an address means, and a `local-app` open, for
+ * an item an app on this machine shows; a plugin the person installed can't declare that open. A
+ * `webSession` gains `signInFirst`. A URI module defines `lookupWebLink` and sets `looksUpWebLinks`
+ * to find a page when someone opens the address, and a preview field marks which `part` of a message
+ * it is. A claim's `brandIcon` is a file path and no longer inline markup, which only this repo's
+ * Microsoft plugin used. Otherwise additive: a plugin using any of these declares ^0.45.0.
+ *
+ * 0.46.0 adds `@bonsai/plugin-sdk/artifact-provenance`, so a plugin shipped as files can finalize
+ * and read the provenance the host captured. Additive: a plugin that imports it declares ^0.46.0.
+ *
+ * 0.47.0 adds card layouts and builders; successful card submits now require a summary.
  */
-declare const KAY_PLUGIN_SDK_VERSION: "0.45.0";
+declare const KAY_PLUGIN_SDK_VERSION: "0.47.0";
 
 declare const KAY_PLUGIN_TARGET_NAMES: readonly ["kay.agent", "kay.app", "kay.ui"];
 
@@ -3653,14 +3787,15 @@ export declare type KayAppAutomationMatch = {
     readonly requestedBy?: "user" | "agent" | undefined;
 };
 
-/** Match any listed type; filters use strict equality or scalar-list containment. */
+/**
+ * Match any listed type. `where` is an expression over the event: `==` and `!=` compare a whole
+ * value, and `contains` looks inside a list, as in
+ * `payload.status == 'open' && payload.labels contains 'urgent'`.
+ */
 export declare interface KayAppAutomationPluginEventCondition {
     readonly kind: "plugin-event";
     readonly events: readonly string[];
-    readonly where?: readonly {
-        readonly path: string;
-        readonly equals: string | number | boolean;
-    }[];
+    readonly where?: string;
 }
 
 /**
@@ -3972,17 +4107,38 @@ export declare interface KayAppBackgroundCredentialRequest {
     readonly jobId: string;
 }
 
+export declare interface KayAppCardFieldOptions {
+    readonly label: string;
+    readonly placeholder?: string;
+    readonly required?: boolean;
+}
+
 /** The background operations of a manifest-declared plugin card. */
 export declare interface KayAppCardImplementation<Input = unknown, Data = unknown, Values = unknown> {
-    read(inputs: Input): KayAppCardResult<Data> | Promise<KayAppCardResult<Data>>;
+    read(inputs: Input): KayAppCardReadResult<Data> | Promise<KayAppCardReadResult<Data>>;
     submit(request: {
         readonly inputs: Input;
         readonly values: Values;
-    }): KayAppCardResult<Data> | Promise<KayAppCardResult<Data>>;
+    }): KayAppCardSubmitResult<Data> | Promise<KayAppCardSubmitResult<Data>>;
 }
 
+export declare type KayAppCardLayout = Extract<PluginCardReadResult<never>, {
+    presentation: "layout";
+}>["layout"];
+
+export declare type KayAppCardReadResult<T> = PluginCardReadResult<T>;
+
 export declare type KayAppCardResult<T> = PluginCardResult<T>;
 
+export declare interface KayAppCardSelectOptions extends KayAppCardFieldOptions {
+    readonly options: readonly {
+        readonly value: string;
+        readonly label: string;
+    }[];
+}
+
+export declare type KayAppCardSubmitResult<T> = PluginCardSubmitResult<T>;
+
 /**
  * The `kay.app` system-prompt contract (`app.systemPrompt`): text a plugin adds to every chat's
  * system prompt, rendered by the daemon from a few facts about the chat and reused across chats.
@@ -9050,6 +9206,8 @@ declare function ModuleDeferred<Declarations extends TProperties>(declarations:
 
 declare function ModuleMapping(input: [unknown, unknown]): unknown;
 
+export declare function multiSelect(name: string, options: KayAppCardSelectOptions): KayAppCardLayout;
+
 /** A tool call that another tool made while it ran, for example from a codemode script. */
 declare interface NestedToolCallRecord {
     id: string;
@@ -9315,6 +9473,13 @@ declare const OptionalSemiColon: (input: string) => [unknown, string] | [];
 
 declare function OptionalSemiColonMapping(input: [unknown] | []): unknown;
 
+/**
+ * OR wrapper — at least one child condition must be true.
+ */
+declare type OrCondition = {
+    $or: VisibilityCondition[];
+};
+
 declare const PackageAssetPath: z.ZodString;
 
 declare type PackageAssetPath = z.infer<typeof PackageAssetPath>;
@@ -9817,6 +9982,12 @@ export declare const PluginAgentDefinitionPermissionRule: z.ZodObject<{
 
 export declare type PluginAgentDefinitionPermissionRule = z.infer<typeof PluginAgentDefinitionPermissionRule>;
 
+declare type PluginCardReadResult<T> = PluginCardResult<T> | {
+    readonly ok: true;
+    readonly presentation: "layout";
+    readonly layout: Spec;
+};
+
 declare type PluginCardResult<T> = {
     readonly ok: true;
     readonly data: T;
@@ -9826,6 +9997,14 @@ declare type PluginCardResult<T> = {
     readonly message: string;
 };
 
+declare type PluginCardSubmitResult<T> = {
+    readonly ok: true;
+    readonly data: T;
+    readonly summary: string;
+} | Extract<PluginCardResult<T>, {
+    readonly ok: false;
+}>;
+
 export declare const PluginEventEnvelope: z.ZodObject<{
     id: z.ZodString;
     localId: z.ZodString;
@@ -10234,6 +10413,7 @@ declare function refineWebSessionScopeConfined(webSession: {
     readonly probe: {
         readonly url: string;
     };
+    readonly signInFirst?: string | undefined;
 }, ctx: z.RefinementCtx): void;
 
 export declare interface RegisteredHostApprovalType {
@@ -10438,6 +10618,8 @@ declare function ReturnType_2<Type extends TSchema>(type: Type, options?: TSchem
 /** Creates a deferred ReturnType action. */
 declare function ReturnTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnTypeDeferred<Type>;
 
+export declare function row(children: readonly KayAppCardLayout[]): KayAppCardLayout;
+
 /**
  * The hidden message a continued run rides as its admission ticket (a mid-turn compaction
  * resume, a run-recovery re-drive). The engine writes it; this package's placement rows keep it
@@ -11013,6 +11195,8 @@ declare const SdkSessionDoor: z.ZodEnum<{
 
 declare type SdkSessionDoor = z.infer<typeof SdkSessionDoor>;
 
+export declare function select(name: string, options: KayAppCardSelectOptions): KayAppCardLayout;
+
 declare type SelectorDisposition = {
     readonly kind: "deferred";
     readonly window?: LineSelector;
@@ -11281,6 +11465,9 @@ declare const SignedInStatusCode: z.ZodNumber;
 
 declare type SignedInStatusCode = z.infer<typeof SignedInStatusCode>;
 
+/** A single visibility condition (state, item, or index). */
+declare type SingleCondition = StateCondition | ItemCondition | IndexCondition;
+
 declare interface SourceInfo {
     path: string;
     source: string;
@@ -11303,6 +11490,33 @@ declare type SourceScope = "user" | "project" | "temporary";
 /** Matches from Start and End capturing everything in-between. Start and End are consumed. */
 declare function Span<Start extends string, End extends string, MultiLine extends boolean, Input extends string>(start: Start, end: End, multiLine: MultiLine, input: Input): TSpan<Start, End, MultiLine, Input>;
 
+/**
+ * Flat UI tree structure (optimized for LLM generation)
+ */
+declare interface Spec {
+    /** Root element key */
+    root: string;
+    /** Flat map of elements by key */
+    elements: Record<string, UIElement>;
+    /** Optional initial state to seed the state model.
+     *  Components using statePath will read from / write to this state. */
+    state?: Record<string, unknown>;
+}
+
+export declare function stack(children: readonly KayAppCardLayout[]): KayAppCardLayout;
+
+/**
+ * A single state-based condition.
+ * Resolves `$state` to a value from the state model, then applies the operator.
+ * Without an operator, checks truthiness.
+ *
+ * When `not` is `true`, the result of the entire condition is inverted.
+ * For example `{ $state: "/count", gt: 5, not: true }` means "NOT greater than 5".
+ */
+declare type StateCondition = {
+    $state: string;
+} & ComparisonOperators;
+
 /** Infers a static type from a TypeBox type. */
 declare type Static<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Encode', Context, {}, Type>> = Result;
 
@@ -11497,6 +11711,8 @@ declare type SubagentResultMessage = CustomMessage<SubagentResultDetails> & {
     readonly display: boolean;
 };
 
+export declare function submit(label: string): KayAppCardLayout;
+
 export declare interface SummarizeSessionInput {
     readonly sessions: KayAppSessions;
     readonly models: KayAppModels;
@@ -11508,6 +11724,8 @@ export declare interface SummarizeSessionInput {
 
 declare const SUMMARY_VERSION: 4;
 
+export declare function switchField(name: string, options: KayAppCardFieldOptions): KayAppCardLayout;
+
 /** Creates a Symbol type. */
 declare function Symbol_2(options?: TSchemaOptions): TSymbol;
 
@@ -12526,6 +12744,8 @@ declare type TExprTermTail<Input extends string> = ((Token.TConst<'&', Input> ex
 
 declare type TExprTermTailMapping<Input extends [unknown, unknown, unknown] | []> = (Input);
 
+export declare function textArea(name: string, options: KayAppCardFieldOptions): KayAppCardLayout;
+
 declare interface TextContent {
     type: "text";
     text: string;
@@ -12674,6 +12894,8 @@ declare type TExtendsUnknown<Inferred extends TProperties, Left extends TUnknown
 
 declare type TExtendsVoid<Inferred extends TProperties, Left extends TVoid, Right extends TSchema> = (Right extends TVoid ? ExtendsResult_2.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
 
+export declare function textField(name: string, options: KayAppCardFieldOptions): KayAppCardLayout;
+
 /** Applies an Extract action using the given types. */
 declare type TExtract<Left extends TSchema, Right extends TSchema> = (TExtractAction<Left, Right>);
 
@@ -13901,6 +14123,7 @@ declare const toolCallFailureCauseSchema: z.ZodObject<{
         errorName: z.ZodOptional<z.ZodString>;
         errorCode: z.ZodOptional<z.ZodString>;
         providerCode: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodNumber>;
         editIndex: z.ZodOptional<z.ZodNumber>;
         occurrences: z.ZodOptional<z.ZodNumber>;
@@ -15508,6 +15731,33 @@ declare type UiActionMessage = CustomMessage<UiActionDetails> & {
     readonly display: true;
 };
 
+/**
+ * Base UI element structure for v2
+ */
+declare interface UIElement<T extends string = string, P = Record<string, unknown>> {
+    /** Component type from the catalog */
+    type: T;
+    /** Component props */
+    props: P;
+    /** Child element keys (flat structure) */
+    children?: string[];
+    /** Visibility condition */
+    visible?: VisibilityCondition;
+    /** Event bindings — maps event names to action bindings */
+    on?: Record<string, ActionBinding | ActionBinding[]>;
+    /** Repeat children once per item in a state array */
+    repeat?: {
+        statePath: string;
+        key?: string;
+    };
+    /**
+     * State watchers — maps JSON Pointer state paths to action bindings.
+     * When the value at a watched path changes, the bound actions fire.
+     * Useful for cascading dependencies (e.g. country → city option loading).
+     */
+    watch?: Record<string, ActionBinding | ActionBinding[]>;
+}
+
 /** Applies a Uncapitalize action to the given type. */
 declare function Uncapitalize_2<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalize<Type>;
 
@@ -15652,6 +15902,11 @@ declare type UriClaim = UriSchemeClaim | UriPatternClaim | UrlPatternClaim;
  * - `base64`: unpadded base64 of the UTF-8 text (`{base64(:id :calendar)}`).
  * - `slackTimestamp`: a Slack archive message token as the API's timestamp
  *   (`p1783350000000100` becomes `1783350000.000100`).
+ * - `beforeColon`: the part of a `<team>:<user>` id before the colon. It fills nothing for an id
+ *   with no colon or nothing before it.
+ * - `beforeTilde`: the part of an id before its last `~`. It fills nothing with no `~`.
+ * - `encoded`: every reserved character escaped, `:` and `@` too, for a whole URL carried as a
+ *   query value (`continue={encoded(:url)}`).
  *
  * A transform that cannot read its input fills nothing. A claim whose `normalizeTo` fills nothing
  * does not match; a `sourceUrl` that fills nothing paints no link.
@@ -15893,6 +16148,13 @@ declare interface UriModule_2 {
         readonly uri: string;
         readonly payload: unknown;
     }, ctx: UriResolveContext): Promise<UriOperationDescription | undefined>;
+    /**
+     * Find the web address of `uri` by asking the provider, for a resource whose address alone can't
+     * name its page. Called only when someone opens the address, under the account it means, and never
+     * to draw a reference. `undefined` means there's no page to open. A plugin module that defines
+     * this sets `looksUpWebLinks` in its manifest.
+     */
+    lookupWebLink?(uri: string, ctx: UriResolveContext): Promise<string | undefined>;
     /**
      * Set false when the generic write tool must reject `source` copies before
      * fetching the source. Inline `content` writes remain available.
@@ -16090,6 +16352,11 @@ declare interface UriOperationDescription {
             readonly editable?: true;
             /** Longest edited value, in UTF-16 code units. Meaningful only with `editable`. */
             readonly maxLength?: number;
+            /**
+             * Which part of a message this field is, when the call sends one. A preview with a `to` and
+             * a `text` is drawn as a message; without them it stays labelled rows.
+             */
+            readonly part?: "to" | "cc" | "bcc" | "subject" | "text";
         }[];
     };
     /** True only when every displayed fact comes from the input, independent of the executing account. */
@@ -16816,6 +17083,16 @@ declare type VendoredMcpOutcome =
     readonly serviceId?: string;
 };
 
+/**
+ * Visibility condition types.
+ * - `boolean` — always/never
+ * - `SingleCondition` — single condition (`$state`, `$item`, or `$index`)
+ * - `SingleCondition[]` — implicit AND (all must be true)
+ * - `AndCondition` — `{ $and: [...] }`, explicit AND (all must be true)
+ * - `OrCondition` — `{ $or: [...] }`, at least one must be true
+ */
+declare type VisibilityCondition = boolean | SingleCondition | SingleCondition[] | AndCondition | OrCondition;
+
 /** Creates a Void type. */
 declare function Void(options?: TSchemaOptions): TVoid;
 
@@ -16935,9 +17212,6 @@ export declare const WhiteboardTypeInfo: z.ZodObject<{
     displayName: z.ZodString;
     schemaVersion: z.ZodNumber;
     available: z.ZodBoolean;
-    presentation: z.ZodOptional<z.ZodObject<{
-        app: z.ZodString;
-    }, z.core.$strict>>;
 }, z.core.$strict>;
 
 export declare type WhiteboardTypeInfo = Readonly<z.infer<typeof WhiteboardTypeInfo>>;

package/dist/kay-app.js

@@ -70,6 +70,65 @@ var JsonValue = z.lazy(() => z.union([
 var JsonObject = z.record(z.string(), JsonValue);
 var JsonSchema = z.record(z.string(), JsonValue);
 
+// packages/plugin-sdk/dist/kay-app/card-layout.js
+function element(type, props) {
+  return { root: "root", elements: { root: { type, props } } };
+}
+function group(type, props, children) {
+  const layout = element(type, props);
+  layout.elements.root.children = children.map((child, index) => {
+    const prefix = `${index}-`;
+    for (const [key, value] of Object.entries(child.elements)) {
+      layout.elements[prefix + key] = {
+        ...value,
+        ...value.children ? { children: value.children.map((id) => prefix + id) } : {}
+      };
+    }
+    return prefix + child.root;
+  });
+  return layout;
+}
+function card(title, children, state) {
+  return { ...group("Card", { title }, children), ...state ? { state } : {} };
+}
+function row(children) {
+  return group("Row", {}, children);
+}
+function stack(children) {
+  return group("Stack", {}, children);
+}
+function field(type, name, options) {
+  const key = name.replaceAll("~", "~0").replaceAll("/", "~1");
+  return element(type, { ...options, value: { $bindState: `/form/${key}` } });
+}
+function textField(name, options) {
+  return field("Field", name, options);
+}
+function textArea(name, options) {
+  return field("TextArea", name, options);
+}
+function select(name, options) {
+  return field("Select", name, options);
+}
+function multiSelect(name, options) {
+  return field("MultiSelect", name, options);
+}
+function switchField(name, options) {
+  return field("Switch", name, options);
+}
+function submit(label) {
+  return {
+    root: "root",
+    elements: {
+      root: {
+        type: "Button",
+        props: { label },
+        on: { press: { action: "submit" } }
+      }
+    }
+  };
+}
+
 // packages/plugin-sdk/dist/signals.js
 import { z as z2 } from "zod";
 function createFallbackOnlySignals() {
@@ -125,8 +184,8 @@ var quoted = (value) => JSON.stringify(value.length > 40 ? `${value.slice(0, 40)
 function grammarProblem(input) {
   const shape = ObserveShape.safeParse(input);
   if (!shape.success) {
-    const field = shape.error.issues[0]?.path.join(".") ?? "";
-    return field === "" ? "`observe` takes an object with `detector`, `source`, `state`, and `questions`." : `\`${field}\` is missing or has the wrong type.`;
+    const field2 = shape.error.issues[0]?.path.join(".") ?? "";
+    return field2 === "" ? "`observe` takes an object with `detector`, `source`, `state`, and `questions`." : `\`${field2}\` is missing or has the wrong type.`;
   }
   const { detector, source, questions, subject, after, reuse } = shape.data;
   const { state } = input;
@@ -139,7 +198,7 @@ function grammarProblem(input) {
   if (!fits(detector.version, VERSION)) {
     return "`detector.version` must be at most 64 characters: letters and digits in parts joined by single `.`, `-`, or `_`.";
   }
-  for (const [field, grammar, rule] of [
+  for (const [field2, grammar, rule] of [
     ["sessionId", POINTER, POINTER_RULE],
     ["entryId", POINTER, POINTER_RULE],
     ["openerEntryId", POINTER, POINTER_RULE],
@@ -149,9 +208,9 @@ function grammarProblem(input) {
       `1 to ${MAX_POINTER} characters with no control character`
     ]
   ]) {
-    const id = source[field];
+    const id = source[field2];
     if (id !== void 0 && !(id.length <= MAX_POINTER && grammar.test(id))) {
-      return `\`source.${field}\` must be ${rule}.`;
+      return `\`source.${field2}\` must be ${rule}.`;
     }
   }
   const occurredAtMs = source.occurredAtMs;
@@ -964,6 +1023,7 @@ export {
   UriProviderError,
   UriUnsupportedOperationError,
   UriValidationError,
+  card,
   createConsoleKayPluginLog,
   createFallbackOnlySignals,
   createKayPluginLog,
@@ -976,12 +1036,20 @@ export {
   invalidObservation,
   isCredentialShapedText,
   isRetryable,
+  multiSelect,
   parseLineSelector,
   parseStoredTranscriptKindFilter,
   pathToFileURL,
   payload,
   requireWriteContent,
+  row,
+  select,
+  stack,
   storedTranscriptKindOf,
+  submit,
+  switchField,
+  textArea,
+  textField,
   transcriptMessageText,
   transcriptMessageTexts,
   transcriptRoleLabel,

package/dist/vendored-mcp.d.ts

@@ -377,6 +377,11 @@ declare type UriClaim = UriSchemeClaim | UriPatternClaim | UrlPatternClaim;
  * - `base64`: unpadded base64 of the UTF-8 text (`{base64(:id :calendar)}`).
  * - `slackTimestamp`: a Slack archive message token as the API's timestamp
  *   (`p1783350000000100` becomes `1783350000.000100`).
+ * - `beforeColon`: the part of a `<team>:<user>` id before the colon. It fills nothing for an id
+ *   with no colon or nothing before it.
+ * - `beforeTilde`: the part of an id before its last `~`. It fills nothing with no `~`.
+ * - `encoded`: every reserved character escaped, `:` and `@` too, for a whole URL carried as a
+ *   query value (`continue={encoded(:url)}`).
  *
  * A transform that cannot read its input fills nothing. A claim whose `normalizeTo` fills nothing
  * does not match; a `sourceUrl` that fills nothing paints no link.
@@ -635,6 +640,13 @@ declare interface UriModule {
         readonly uri: string;
         readonly payload: unknown;
     }, ctx: UriResolveContext): Promise<UriOperationDescription | undefined>;
+    /**
+     * Find the web address of `uri` by asking the provider, for a resource whose address alone can't
+     * name its page. Called only when someone opens the address, under the account it means, and never
+     * to draw a reference. `undefined` means there's no page to open. A plugin module that defines
+     * this sets `looksUpWebLinks` in its manifest.
+     */
+    lookupWebLink?(uri: string, ctx: UriResolveContext): Promise<string | undefined>;
     readonly getCachePolicy?: UriCachePolicyResolver;
     /**
      * Code matching, for the host's own modules whose addresses no claim can describe (a bare file
@@ -756,6 +768,11 @@ declare interface UriOperationDescription {
             readonly editable?: true;
             /** Longest edited value, in UTF-16 code units. Meaningful only with `editable`. */
             readonly maxLength?: number;
+            /**
+             * Which part of a message this field is, when the call sends one. A preview with a `to` and
+             * a `text` is drawn as a message; without them it stays labelled rows.
+             */
+            readonly part?: "to" | "cc" | "bcc" | "subject" | "text";
         }[];
     };
     /** True only when every displayed fact comes from the input, independent of the executing account. */