@joewinke/jatui 0.36.3 → 0.38.0

package/dist/artifact-blocks/types.d.ts

@@ -0,0 +1,513 @@
+/**
+ * Artifact blocks (jatui `jatui/artifact-blocks`; origin MOS epic mos-ab*,
+ * moved into jatui by jatui-vsuzi so MOS and the jat IDE render ONE thing).
+ *
+ * A BLOCKS artifact is DATA, not code: a title plus an ordered list of block
+ * instances, each `{ id, type, params }`. The host renders every block with
+ * its own Svelte component (jatui, theme tokens, a11y), so an agent never
+ * hand-builds a chart, table or media picker in raw HTML again.
+ *
+ * Adding a block = one folder `blocks/<type>/` whose `block.ts`
+ * default-exports an `ArtifactBlockDef`, plus one line in `builtins.ts`
+ * (a library cannot discover folders at runtime the way a Vite app can).
+ * Hosts may add their own blocks with `registerBlocks()`.
+ *
+ * Everything that used to be a host import (comments API, composer,
+ * uploads, the review send, desk actions, listen, maps, 3D, sandbox…) goes
+ * through ONE typed object, the `HostAdapter` below. Contract: ./CONTRACT.md.
+ */
+import type { Component, Snippet } from "svelte";
+import type { z } from "zod";
+import type { HistorySnapshot, HistoryVersion } from "./history.js";
+/** Per-viewer state a block may persist (verdicts, notes, picks). JSON only. */
+export type BlockState = Record<string, unknown>;
+export interface BlockContext {
+    artifactId: string;
+    /** The artifact version being viewed; state is keyed per version. */
+    version: number;
+    blockId: string;
+    /** This viewer's saved state for THIS block (null = none yet). */
+    state: BlockState | null;
+    /**
+     * Persist this viewer's state for this block (debounced by the renderer;
+     * resolves when saved). Undefined when the viewer cannot save (anonymous
+     * share link, print/preview, tests).
+     */
+    saveState?: (next: BlockState) => Promise<void>;
+    /** Live data published for the artifact; {} when none. */
+    data: Record<string, unknown>;
+    /** True on a read-only surface — blocks must not show viewer chrome. */
+    readonly: boolean;
+    /**
+     * The section's own controls: the per-block comment pill, when the host
+     * has comments on. A block whose def says `hostsTools` renders them
+     * through <SectionTools> on its heading row; undefined = nothing to render.
+     */
+    tools?: Snippet;
+    /**
+     * Optional host services (maps loader, 3D explorer, sandboxed mockup
+     * frame, team lookup…) — `HostAdapter.services`. Always an object; a block
+     * whose service is missing degrades to a visible, quiet fallback.
+     */
+    services: BlockServices;
+}
+export interface BlockProps<P> {
+    params: P;
+    ctx: BlockContext;
+}
+/** A word in one block's verdict vocabulary (matches jatui ReviewProgress). */
+export interface VerdictWord {
+    id: string;
+    label: string;
+    tone: "success" | "warning" | "error" | "info";
+}
+/** An item verdict, normalized across the item-review vocabularies. */
+export type ItemVerdict = "approved" | "needs-work" | "rejected";
+/** One item inside an item-review block, with this viewer's verdict on it. */
+export interface ReviewItem {
+    id: string;
+    /** null = undecided (no verdict, untested, or awaiting a retest). */
+    verdict: ItemVerdict | null;
+    /** The block's own word for it (approve / redo / modify / pass / fail…). */
+    raw: string | null;
+    note?: string;
+    /** The note's attachments, read straight from the saved entry. */
+    attachments?: NoteAttachment[];
+    /** The viewer saved a verdict on this item (vs. an authored seed or a
+     * verdict from an earlier round, which answers nothing now). */
+    explicit: boolean;
+    /** The team reopened the item and this viewer owes the new round. */
+    retest: boolean;
+}
+/**
+ * Item-review hooks (jatui-vsuzi): blocks whose verdicts live PER ITEM
+ * inside their own state (checklist, media-picker, diff-review) declare
+ * this, and the core census, still-open walk and Send read their items
+ * through it — the core never hardcodes a block type. Params here are the
+ * AUTHORED params (untrusted JSON), not the parsed ones: the census runs on
+ * stored specs, server-side too.
+ */
+export interface BlockItemReview {
+    /** The block's own verdict words (ids = ReviewItem.raw values). */
+    vocabulary: VerdictWord[];
+    /** A name for the block kind when params carry no title ("Checklist"). */
+    name: string;
+    /** The items and this state's verdict on each, in the block's order. */
+    items(params: unknown, state: unknown): ReviewItem[];
+    /** An item's title for a jump card; the item id when absent. */
+    itemLabel?(params: unknown, itemId: string): string;
+    /** Best-effort thumbnail URL for a jump card. */
+    itemThumb?(params: unknown, itemId: string): string | undefined;
+}
+export interface ArtifactBlockDef<P = unknown> {
+    /** Stable kebab-case id, equals the folder name: "chart", "media-picker". */
+    type: string;
+    /** Human label for the catalog. */
+    title: string;
+    /**
+     * One paragraph an AGENT reads to decide when to use this block and how to
+     * fill it (the catalog a host serves to agents).
+     */
+    description: string;
+    /** Validates params at publish; also the source of the catalog JSON Schema. */
+    schema: z.ZodType<P>;
+    component: Component<BlockProps<P>>;
+    /** A complete, valid params example (used in docs, catalog and tests). */
+    example: P;
+    /** True when the block saves per-viewer state (verdicts, picks, notes). */
+    interactive?: boolean;
+    /**
+     * Optional: `params.dataKey`-style binding. When set, the renderer passes
+     * `ctx.data[params[dataParam]]` so live data replaces inline params.
+     */
+    dataParam?: string;
+    /**
+     * Optional: true when these params make the block BREAK OUT of the reading
+     * column (a wide table). The renderer gives the per-block comment trigger
+     * the same breakout. Must agree with what the component itself renders.
+     */
+    wide?: (params: P) => boolean;
+    /**
+     * Optional: true when, for these params, the component renders
+     * <SectionTools ctx={ctx} /> on its heading row, so the section's Listen +
+     * comment controls sit beside the heading. The renderer then draws no
+     * controls row of its own above the block.
+     */
+    hostsTools?: (params: P) => boolean;
+    /** Item-review blocks only — see BlockItemReview. */
+    itemReview?: BlockItemReview;
+    /**
+     * Block types that present a WORK PRODUCT to judge (mockup, compare,
+     * collage, diff) set this: they take the block-level approve /
+     * needs-a-pass strip unless the spec says `params.reviewable: false`.
+     * Every other block is information (no strip, not a review unit) unless
+     * the spec opts in with `params.reviewable: true`.
+     */
+    reviewableByDefault?: boolean;
+}
+/**
+ * A group a card belongs to (PARAMS-SPEC §1/§5, jat-j49id): the renderer
+ * draws a header BETWEEN cards when the key changes, anchored
+ * `#group-<key>`; a `quiet` group may start collapsed.
+ */
+export interface BlockGroup {
+    /** `[a-z0-9-]{1,32}` — question | decision | hold-human | … */
+    key: string;
+    /** ≤60, the header text ("Agent asked a question"). */
+    label: string;
+    quiet?: boolean;
+}
+export interface BlockInstance {
+    /** Unique within the artifact; stable across re-publishes (state keys on it). */
+    id: string;
+    type: string;
+    params: unknown;
+    /**
+     * Optional per-block OWNER — the agent (or role) that should hear about
+     * viewer decisions on this block. Never rendered; the host's owner-routing
+     * reads it SERVER-SIDE and the client never names it. Max 80 chars.
+     */
+    owner?: string;
+    /**
+     * Optional per-block jat task link (provider contract P11): a finished
+     * review answers THIS block's verdict on this task, as the viewer.
+     */
+    taskId?: string;
+    /**
+     * Optional, decision blocks with a `taskId` only: the jat-decision the
+     * card mirrors (`dec-…`). A `chose` on the card also answers it.
+     */
+    decisionId?: string;
+}
+export interface BlocksSpec {
+    version: 1;
+    title: string;
+    summary?: string;
+    blocks: BlockInstance[];
+}
+export interface BlockValidationError {
+    blockId: string;
+    type: string;
+    /** Dotted path into params, e.g. "series.0.points". */
+    path: string;
+    message: string;
+}
+export type AttachmentKind = "screen" | "voice" | "audio" | "video" | "image" | "file";
+/**
+ * The descriptor one note attachment carries (stored by the HOST, never
+ * bytes here). Shape-compatible with MOS's noteAttachments.ts; jatui only
+ * displays it and passes it through.
+ */
+export interface NoteAttachment {
+    /** Stored object name in the host's asset store. */
+    name: string;
+    /** Original filename for a picked file; the stored name for a recording. */
+    label?: string;
+    /** URL serving the bytes behind the host's access check. */
+    url: string;
+    contentType: string;
+    sizeBytes: number;
+    kind: AttachmentKind;
+    durationSeconds: number | null;
+    /** Best-effort LOCAL transcription of a recording — never cloud. */
+    transcript: string | null;
+}
+/**
+ * The host's upload leg: stores the bytes FIRST (never lose the blob) and
+ * returns the descriptor the note keeps.
+ */
+export type ComposerUpload = (blob: Blob | File, lane: "file" | "clip", durationSeconds?: number) => Promise<NoteAttachment>;
+/**
+ * The props every note composer takes — jatui's default text composer and
+ * any host composer (MOS's ReviewComposer is this shape). Either the
+ * composer renders its own submit row (`submitLabel` + `onSubmit`) or the
+ * host drives the send through `bind:text` / `bind:clips`.
+ */
+export interface NoteComposerProps {
+    /** The surface's upload leg. Omitted → text-only (no attach affordances). */
+    upload?: ComposerUpload;
+    placeholder?: string;
+    label?: string;
+    maxLength?: number;
+    rows?: number;
+    submitLabel?: string;
+    onSubmit?: (payload: {
+        text: string;
+        clips: NoteAttachment[];
+    }) => void | Promise<void>;
+    busy?: boolean;
+    disabled?: boolean;
+    error?: string | null;
+    onInput?: (text: string) => void;
+    onBlur?: () => void;
+    clips?: NoteAttachment[];
+    onClipsChange?: (clips: NoteAttachment[]) => void;
+    maxClips?: number;
+    autofocus?: boolean;
+    text?: string;
+    class?: string;
+}
+export type ReviewVerdict = "approved" | "needs-pass" | "chose";
+export interface VerdictEntry {
+    verdict: ReviewVerdict;
+    /** `chose` only: the letter picked. */
+    option?: string;
+    note?: string;
+    attachments?: NoteAttachment[];
+}
+/** The block-level verdict a viewer saves on an ordinary block. */
+export interface BlockReviewState {
+    verdict?: "approved" | "needs-pass";
+    note?: string;
+    attachments?: NoteAttachment[];
+}
+/**
+ * The per-item verdicts map a review's answer carries for item-review
+ * blocks: `{ blockId: { itemId: { verdict, note?, attachments? } } }`.
+ */
+export type SentItemsMap = Record<string, Record<string, {
+    verdict: string;
+    note?: string;
+    attachments?: NoteAttachment[];
+}>>;
+/**
+ * What the host hands the view about THIS viewer's last Send on this
+ * version. The view seeds its done state from it, so a reload remembers.
+ */
+export interface SentAnswer {
+    /** ISO timestamp of the Send. */
+    sentAt: string;
+    /** The Send's event id (the delivery poll's key). */
+    eventId?: string;
+    /** When the owner got it; null = queued. */
+    deliveredAt?: string | null;
+    /** False when nobody owns the page, so nothing will ever deliver it. */
+    deliverable?: boolean;
+    /** Who the answer reached (the publisher's label). */
+    sentTo: string | null;
+    verdicts?: Record<string, VerdictEntry>;
+    items?: SentItemsMap;
+}
+/** One folded earlier round (a page that superseded older rounds). */
+export interface FoldedRound {
+    slug: string;
+    title: string;
+    version: number;
+    publishedBy: string;
+    /** ISO timestamp. */
+    publishedAt: string;
+    reason?: string | null;
+    /** Every viewer's locked verdicts/notes (jatui RoundHistory entries). */
+    entries: import("../components/review/reviewSummary").ReviewRound[];
+}
+/** One comment in a block's thread. */
+export interface BlockComment {
+    id: string;
+    body: string;
+    resolved: boolean;
+    /** ISO timestamp. */
+    created_at: string;
+    /** True when THIS viewer posted it (the host stamps it). */
+    mine?: boolean;
+    attachments?: NoteAttachment[] | null;
+}
+/** Per-block comment threads. Every call may throw; the drawer says so. */
+export interface CommentsService {
+    load(args: {
+        artifactId: string;
+        version: number;
+        blockId: string;
+    }): Promise<BlockComment[]>;
+    /** Resolves with the stored comment. Throw an Error with a human message. */
+    post(args: {
+        artifactId: string;
+        version: number;
+        blockId: string;
+        body: string;
+        attachments: NoteAttachment[];
+    }): Promise<BlockComment>;
+    /** Flip the poster's OWN resolved flag. */
+    setResolved(args: {
+        artifactId: string;
+        commentId: string;
+        resolved: boolean;
+    }): Promise<void>;
+}
+/** What a Send answered. */
+export interface ReviewSendResult {
+    answered: boolean;
+    sentTo?: string | null;
+    delivery?: {
+        eventId?: string | null;
+        delivered?: boolean;
+        deliverable?: boolean;
+    };
+    error?: string;
+}
+/** The review moment's network legs. */
+export interface ReviewService {
+    /**
+     * Finish review: ONE answer to the linked task. `version` is the layout
+     * version THIS tab answered — a stale tab answering an older version must
+     * be detectable (the host stores verdicts per version). `taskId` is the
+     * page's linked task; `blockTasks` maps each block that carries its own
+     * task link (provider contract P11) to `{ taskId, decisionId }`, so the
+     * host answers each linked block on its own task.
+     */
+    send(args: {
+        artifactId: string;
+        version: number;
+        taskId: string | null;
+        blockTasks: Record<string, {
+            taskId: string;
+            decisionId: string | null;
+        }>;
+        verdicts: Record<string, VerdictEntry>;
+        text?: string;
+        attachments?: NoteAttachment[];
+    }): Promise<ReviewSendResult>;
+    /**
+     * "Done reviewing" (no linked task): record that this viewer finished
+     * this version. Throw an Error with a human message on failure — the view
+     * shows it beside the control. Omit → no Done-reviewing control and no
+     * auto-send; a page whose picks then go nowhere says so.
+     */
+    markReviewed?(args: {
+        artifactId: string;
+        version: number;
+        taskId: string | null;
+    }): Promise<void>;
+    /**
+     * Poll a queued Send's delivery stamp. Omit → every Send reads as
+     * delivered the moment `send` resolves (nothing would ever stop a
+     * "Sending…" state otherwise).
+     */
+    deliveryStatus?(args: {
+        artifactId: string;
+        eventId: string;
+    }): Promise<{
+        delivered: boolean;
+        deliveredAt?: string | null;
+    }>;
+    /**
+     * A drafted note the host keeps in the viewer's state (MOS: the desk's
+     * `desk:note`). The Finish composer pre-fills from it; `label` names
+     * where it came from ("Drafted on your desk: Needs work").
+     */
+    draftNote?(blocks: Record<string, unknown>): {
+        note: string;
+        label: string;
+    } | null;
+}
+/** The page as it was at one instant. */
+export interface HistoryPastState {
+    at: string;
+    version: number;
+    kind: "html" | "blocks";
+    spec: BlocksSpec | null;
+    data: Record<string, unknown>;
+    snapshotId: string | null;
+    dataAt: string | null;
+    beforeTrail: boolean;
+}
+/** The history scrubber's two reads. Omit → no History control. */
+export interface HistoryService {
+    timeline(args: {
+        artifactId: string;
+    }): Promise<{
+        versions: HistoryVersion[];
+        snapshots: HistorySnapshot[];
+        trailStart?: string | null;
+    }>;
+    at(args: {
+        artifactId: string;
+        at: string;
+    }): Promise<HistoryPastState>;
+}
+/**
+ * Live data refresh. Omit → the page shows the data it was given, with no
+ * "live" claim. A host that is rate limited throws an object with
+ * `status: 429` (e.g. `Object.assign(new Error("slow down"), { status: 429 })`):
+ * the page keeps the last good data and its freshness line says a refresh
+ * is pending; any other throw reads as a failed refresh.
+ */
+export interface LiveDataService {
+    fetch(args: {
+        artifactId: string;
+    }): Promise<{
+        data: Record<string, unknown>;
+        dataUpdatedAt: string | null;
+    }>;
+    /** Poll cadence; default 30s. */
+    intervalMs?: number;
+}
+/** What a block's Listen control reads (its own section). */
+export interface BlockListenArgs {
+    /** The section id the segments are grouped under (`block-<id>`). */
+    group: string;
+    /** "What this page is" — completes "Listen to: <label>". */
+    label: string;
+    /** CSS selector of the section to highlight / follow. */
+    anchor: string;
+}
+/** The done states' "Back to desk / Next review" slot. */
+export interface NextActionsArgs {
+    compact: boolean;
+    autofocus: boolean;
+    /** The full-size placement offers a Next key binding. */
+    nextKey: boolean;
+}
+/**
+ * Optional services a block may use. Every key is optional; block tasks
+ * refine the shapes they consume. A missing service is a visible, quiet
+ * fallback inside that block — never a throw.
+ */
+export interface BlockServices {
+    /** Map block: load Google Maps (jatui's loadGoogleMapsAPI fits). */
+    loadGoogleMaps?: (opts: {
+        libraries?: string[];
+    }) => Promise<unknown>;
+    /** Explainer block: a 3D explorer component. */
+    explorer3d?: Component<Record<string, unknown>>;
+    /** Mockup block: the `sandbox` attribute for untrusted HTML frames. */
+    sandboxAttr?: string;
+    /** Team lookup for review chips (ids → display names). */
+    teamLookup?: (ids: string[]) => Promise<Record<string, string>>;
+    [key: string]: unknown;
+}
+/**
+ * ONE typed object the host passes to BlocksArtifactView (or BlockRenderer).
+ * Every key is optional and its absence DEGRADES TO READ-ONLY, LOUDLY: no
+ * `comments` → no comment pills; no `review.send` → no Finish review; no
+ * `review.markReviewed` → no Done reviewing and no auto-send. A page that
+ * carries answerable content but cannot send it shows a notice: "read-only"
+ * without `onSaveBlock` (a view prop — blocks then get no saveState),
+ * "unsent" when picks save but no review leg sends them.
+ */
+export interface HostAdapter {
+    /** Note composer (verdict notes, comments, the Finish note). Default: jatui text composer. */
+    composer?: Component<NoteComposerProps>;
+    /** Upload leg factory, handed to the composer. Omit → text-only notes. */
+    upload?: (artifactId: string) => ComposerUpload;
+    /** Attachment chip renderer. Default: a labelled link chip. */
+    attachmentChip?: Component<{
+        clip: NoteAttachment;
+    }>;
+    comments?: CommentsService;
+    review?: ReviewService;
+    history?: HistoryService;
+    liveData?: LiveDataService;
+    /** A block's Listen control (jatui ListenControl fits). Omit → no Listen. */
+    listen?: Snippet<[BlockListenArgs]>;
+    /** Header crumb slot (team / "Artifacts" / "Your desk"). */
+    crumb?: Snippet;
+    /** "Back to desk / Next review" in the done states. */
+    nextActions?: Snippet<[NextActionsArgs]>;
+    /** Right-click menu on the title ("Copy reference for an agent"…). */
+    titleMenu?: {
+        header?: string;
+        items: import("../components/ContextMenu.types.js").ContextMenuItem[];
+    };
+    /** Optional block services (maps, 3D, sandbox, team). */
+    services?: BlockServices;
+}

package/dist/artifact-blocks/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/Button.svelte

@@ -187,6 +187,14 @@
 {/if}
 
 <style>
+	/* ── Flat by default ──────────────────────────────────────────
+	   DaisyUI v5 gives colored variants (primary, error, …) a drop shadow
+	   through --btn-shadow. jatui buttons are flat. Only the variable is
+	   cleared, so a consumer `shadow-*` utility still applies when wanted. */
+	.jatui-btn {
+		--btn-shadow: 0 0 0 0 transparent;
+	}
+
 	/* ── Press Squish ─────────────────────────────────────────────
 	   Quick down on :active, spring back on release. Transform-only.
 	   Local @media guard — motion.css is the backstop but not guaranteed. */

package/dist/components/TextInput.svelte

@@ -7,8 +7,35 @@
 	 * opt-in floatingLabel prop (label translates/scales on focus-or-filled, pure CSS).
 	 */
 
-	interface Props {
-		label: string;
+	import type { HTMLInputAttributes } from 'svelte/elements';
+
+	/**
+	 * Any other native attribute (aria-label, aria-labelledby, data-*, title,
+	 * list, inputmode, step, min, max, event handlers…) passes straight through
+	 * to the <input>. `label` is optional: a compact input with no visible label
+	 * must pass `aria-label` (or `aria-labelledby`) to get an accessible name.
+	 */
+	interface Props
+		extends Omit<
+			HTMLInputAttributes,
+			| 'value'
+			| 'type'
+			| 'size'
+			| 'class'
+			| 'id'
+			| 'name'
+			| 'autocomplete'
+			| 'placeholder'
+			| 'required'
+			| 'disabled'
+			| 'readonly'
+			| 'maxlength'
+			| 'minlength'
+			| 'pattern'
+			| 'children'
+		> {
+		/** Visible label. Omit it only with `aria-label` / `aria-labelledby`. */
+		label?: string;
 		value?: string;
 		placeholder?: string;
 		type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url';
@@ -54,7 +81,8 @@
 		class: className = '',
 		id = `text-input-${Math.random().toString(36).substr(2, 9)}`,
 		name = '',
-		autocomplete = ''
+		autocomplete = '',
+		...rest
 	}: Props = $props();
 
 	const sizeClass = $derived({ sm: 'input-sm', md: '', lg: 'input-lg' }[size]);
@@ -97,7 +125,7 @@
 </script>
 
 <div class="form-control w-full" class:jatui-float-wrap={floatingLabel}>
-	{#if !floatingLabel}
+	{#if label && !floatingLabel}
 		<label for={id} class="label">
 			<span class="text-[0.8125rem] font-medium text-base-content/85">
 				{label}
@@ -110,6 +138,7 @@
 
 	<div class:jatui-float-field={floatingLabel}>
 		<input
+			{...rest}
 			bind:this={inputEl}
 			{id}
 			{name}
@@ -124,12 +153,16 @@
 			autocomplete={autocomplete as AutoFill}
 			bind:value
 			class={inputClass}
-			aria-describedby={error ? `${id}-error` : helpText ? `${id}-help` : undefined}
+			aria-describedby={error
+				? `${id}-error`
+				: helpText
+					? `${id}-help`
+					: rest['aria-describedby']}
 			aria-invalid={error ? 'true' : 'false'}
 			onanimationend={() => inputEl?.classList.remove('jatui-input-shake')}
 		/>
 
-		{#if floatingLabel}
+		{#if label && floatingLabel}
 			<label for={id} class="jatui-float-label">
 				{label}
 				{#if required}

package/dist/components/TextInput.svelte.d.ts

@@ -1,12 +1,20 @@
 /**
- * TextInput Component
- *
- * Labeled text input with validation, error state, help text, and character count.
- * Adds: motion-token error shake (embedded keyframe, no host-app dependency),
- * opt-in floatingLabel prop (label translates/scales on focus-or-filled, pure CSS).
+     * TextInput Component
+     *
+     * Labeled text input with validation, error state, help text, and character count.
+     * Adds: motion-token error shake (embedded keyframe, no host-app dependency),
+     * opt-in floatingLabel prop (label translates/scales on focus-or-filled, pure CSS).
+     */
+import type { HTMLInputAttributes } from 'svelte/elements';
+/**
+ * Any other native attribute (aria-label, aria-labelledby, data-*, title,
+ * list, inputmode, step, min, max, event handlers…) passes straight through
+ * to the <input>. `label` is optional: a compact input with no visible label
+ * must pass `aria-label` (or `aria-labelledby`) to get an accessible name.
  */
-interface Props {
-    label: string;
+interface Props extends Omit<HTMLInputAttributes, 'value' | 'type' | 'size' | 'class' | 'id' | 'name' | 'autocomplete' | 'placeholder' | 'required' | 'disabled' | 'readonly' | 'maxlength' | 'minlength' | 'pattern' | 'children'> {
+    /** Visible label. Omit it only with `aria-label` / `aria-labelledby`. */
+    label?: string;
     value?: string;
     placeholder?: string;
     type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url';