march-hare 0.8.0 → 0.10.0

package/dist/actions/index.d.ts

@@ -0,0 +1,46 @@
+import { Data } from './types';
+import { Model, Props, Actions, UseActions } from '../types/index';
+/**
+ * A hook for managing state with actions.
+ *
+ * Call `useActions` first, then use `actions.useAction` to bind handlers
+ * to action symbols. Types are pre-baked from the generic parameters, so
+ * no additional type annotations are needed on handler calls.
+ *
+ * The hook returns a result containing:
+ * 1. The current model state
+ * 2. An actions object with `dispatch`, `inspect`, and `useAction`
+ * 3. A read-only snapshot of the data values produced by `getData` —
+ *    the same values handlers read via `context.data`, exposed here for
+ *    JSX consumption so the view and the handler share one named source.
+ *
+ * The `inspect` property provides access to Immertation's annotation system,
+ * allowing you to check for pending operations on model properties.
+ *
+ * @template M The model type representing the component's state.
+ * @template AC The actions class containing action definitions.
+ * @template D The data type for reactive external values.
+ * @param model The initial model state.
+ * @param getData Optional function that returns reactive values as data.
+ *   Values returned are accessible via `context.data` in action handlers,
+ *   always reflecting the latest values even after await operations.
+ * @returns A result `[model, actions, data]` with pre-typed `useAction` method.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const [model, actions] = useActions<Model, typeof Actions>(model);
+ *
+ * // Without a model (actions-only)
+ * const [, actions] = useActions<void, typeof Actions>();
+ *
+ * // With reactive data &mdash; consumed in JSX and handlers alike.
+ * const [model, actions, data] = useActions<
+ *   Model,
+ *   typeof Actions,
+ *   { query: string }
+ * >(model, () => ({ query: props.query }));
+ * ```
+ */
+export declare function useActions<M extends void = void, A extends Actions | void = void, D extends Props = Props>(getData?: Data<D>): UseActions<M, A, D>;
+export declare function useActions<M extends Model, A extends Actions | void = void, D extends Props = Props>(model: M, getData?: Data<D>): UseActions<M, A, D>;

package/dist/{hooks → actions}/utils.d.ts

@@ -63,45 +63,6 @@ export declare function useLifecycles({ unicast, broadcast, dispatchers, scope,
  * @returns A memoized data proxy of the object.
  */
 export declare function useData<P extends Props>(props: P): P;
-/**
- * Handler factories that wire an action directly to a model field.
- *
- * - {@link With.Update} assigns the dispatched payload to `model[key]`.
- * - {@link With.Invert} flips a boolean field on `model[key]`.
- *
- * Both are typed so the call site fails to compile when `key` is missing or
- * has an incompatible type.
- *
- * @example
- * ```ts
- * import { With } from "march-hare";
- *
- * type Model = { name: string; sidebar: boolean };
- *
- * class Actions {
- *   static SetName = Action<string>("SetName");
- *   static ToggleSidebar = Action("ToggleSidebar");
- * }
- *
- * actions.useAction(Actions.SetName, With.Update("name"));
- * actions.useAction(Actions.ToggleSidebar, With.Invert("sidebar"));
- * ```
- */
-export declare const With: {
-    /**
-     * Returns a handler that assigns the action payload to `model[key]`.
-     *
-     * Type-checks at the call site: the payload type must be assignable to
-     * the model property's type, and the key must exist on the model.
-     */
-    Update<K extends string>(key: K): <M extends Model, A extends Actions | void, D extends Props, P extends K extends keyof M ? M[K] : never>(context: HandlerContext<M, A, D>, payload: P) => void;
-    /**
-     * Returns a handler that inverts a boolean field on the model.
-     *
-     * Type-checks at the call site: `model[key]` must be a boolean.
-     */
-    Invert<K extends string>(key: K): <M extends Model & Record<K, boolean>, A extends Actions | void, D extends Props>(context: HandlerContext<M, A, D>) => void;
-};
 /**
  * Scans a handler registry for a lifecycle action of the given type.
  *

package/dist/app/index.d.ts

@@ -0,0 +1,132 @@
+import { Env } from '../boundary/components/env/index';
+import { Actions, Model, Props } from '../types/index';
+import { Scope } from '../scope/index';
+import { AppContextHandle, AppResource } from './types';
+import { Tap } from '../boundary/components/tap/types';
+import * as React from "react";
+export type { AppArgs, AppContextHandle, AppFetcher, AppResource, } from './types';
+/**
+ * Returned from {@link App}. Bundles the Boundary, hooks, and Resource
+ * factory bound to a single typed Env shape `S`.
+ */
+export type App<S extends object> = {
+    /**
+     * Boundary component for this App. By default, wraps the subtree with
+     * the `env` and `tap` passed to {@link App}; either can be overridden
+     * at the call site via the corresponding prop, which is useful when a
+     * single `App` definition is rendered against different envs in tests
+     * or storybooks.
+     */
+    readonly Boundary: React.FC<{
+        env?: S;
+        tap?: Tap;
+        children: React.ReactNode;
+    }>;
+    /**
+     * Hook returning a stable `Context` handle. The handle's
+     * `context.useActions(model?, getData?)` materialises the
+     * component's `[model, actions, data]` tuple. Every handler's
+     * `context.env` is typed as `S`.
+     */
+    readonly useContext: <M extends Model | void = void, AC extends Actions | void = void, D extends Props = Props>() => AppContextHandle<M, AC, D, S>;
+    /**
+     * Read-only Proxy over the per-Boundary Env, typed as `S`. Reads use
+     * dot notation (`env.session`) and always reflect the latest value
+     * across `await` boundaries. Writes flow through
+     * `context.actions.produce(({ env }) => { ... })`.
+     */
+    readonly useEnv: () => Readonly<S>;
+    /**
+     * `Resource` factory bound to this App's Env. Same shape as the
+     * top-level `Resource`: call directly for an in-memory cache, or use
+     * `app.Resource.Cachable(cache, fetcher)` for persistence.
+     */
+    readonly Resource: AppResource<S>;
+    /**
+     * Opens a typed multicast scope. The generic `MulticastActions` declares
+     * the `Distribution.Multicast` action class (or union of classes)
+     * whose dispatches are routed through this scope &mdash; the
+     * returned handle mirrors the App surface but widens
+     * `useContext().actions.dispatch` to accept actions from `MulticastActions`
+     * on top of the local `AC` class.
+     *
+     * Render `<scope.Boundary>` to open the scope at runtime; nesting
+     * multiple boundaries from different `app.Scope()` calls is fine,
+     * each runs as an independent emitter shadowed for its subtree.
+     *
+     * The Scope handle deliberately does NOT expose a further `Scope`
+     * method &mdash; the multicast surface must be declared at the
+     * `app.Scope<MulticastActions>()` call site so the type union is explicit.
+     */
+    readonly Scope: <MulticastActions>() => Scope<S, MulticastActions>;
+};
+/**
+ * Creates an `App` &mdash; the entrypoint for a typed Env shape `S`,
+ * inferred from `config.env`. `App<S>` exposes `Boundary`, hooks, and
+ * a `Resource` factory all wired against the same shape.
+ *
+ * Each `<app.Boundary>` instance owns its own Env, so different `App`s
+ * can coexist in the same tree with completely independent shapes.
+ *
+ * Pass `tap` to subscribe to every action handler's dispatch / settle /
+ * error inside the boundary &mdash; useful for analytics, audit logging,
+ * Sentry breadcrumbs. See `recipes/tap.md`. Both `env` and `tap` can
+ * also be supplied as props on `<app.Boundary>`, where they override the
+ * defaults set at `App()` time (handy for test renders and storybooks).
+ *
+ * @example
+ * ```tsx
+ * import { App, type Tapped } from "march-hare";
+ *
+ * type Session = { accessToken: string };
+ *
+ * function tap(event: Tapped) {
+ *   if (event.type === "error") {
+ *     Sentry.captureException(event.error, { tags: { action: event.action } });
+ *   }
+ * }
+ *
+ * export const app = App({
+ *   env: {
+ *     session: null as Session | null,
+ *     operating: "idle" as "idle" | "signing-out",
+ *   },
+ *   tap,
+ * });
+ *
+ * // Root render.
+ * <app.Boundary>
+ *   <Root />
+ * </app.Boundary>;
+ *
+ * // In a feature's actions.ts:
+ * export function useAuthActions() {
+ *   const context = app.useContext<void, typeof Actions>();
+ *   const actions = context.useActions();
+ *
+ *   actions.useAction(Actions.SignOut, async (context) => {
+ *     context.actions.produce(({ env }) => {
+ *       env.session = null;
+ *     });
+ *   });
+ *
+ *   return actions;
+ * }
+ *
+ * // In resources.ts:
+ * export const user = app.Resource<User>((context) =>
+ *   ky
+ *     .get("/api/user", {
+ *       headers: context.env.session
+ *         ? { Authorization: `Bearer ${context.env.session.accessToken}` }
+ *         : {},
+ *       signal: context.controller.signal,
+ *     })
+ *     .json<User>(),
+ * );
+ * ```
+ */
+export declare function App<S extends object = Env>(config?: {
+    env?: S;
+    tap?: Tap;
+}): App<S>;

package/dist/app/types.d.ts

@@ -0,0 +1,82 @@
+import { Args, ResourceHandle } from '../resource/types';
+import { Cache } from '../cache/index';
+import { Actions, Context, Model, Props, UseActions } from '../types/index';
+import { Data } from '../actions/types';
+import { Env } from '../boundary/components/env/index';
+import { WithHandle } from '../with/index';
+/**
+ * Args object passed to an `app.Resource` fetcher. Same shape as the
+ * base `Resource` fetcher's args but with `env` typed as `S`.
+ */
+export type AppArgs<S, P extends object = Record<never, never>> = Omit<Args<P>, "env"> & {
+    readonly env: Readonly<S>;
+};
+/**
+ * Fetcher signature for an `app.Resource` declaration. The fetcher's
+ * `context.env` is typed against the App's inferred Env shape `S`.
+ */
+export type AppFetcher<S, T, P extends object = Record<never, never>> = (context: AppArgs<S, P>) => Promise<T>;
+/**
+ * `app.Resource(fetcher)` &mdash; in-memory cache, no persistence.
+ * `app.Resource.Cachable(cache, fetcher)` &mdash; persistent cache wired
+ * to the supplied `Cache` adapter. Both forms type `context.env` as
+ * the App's Env shape.
+ */
+export type AppResource<S> = {
+    <T, P extends object = Record<never, never>>(fetcher: AppFetcher<S, T, P>): ResourceHandle<T, P>;
+    readonly Cachable: <T, P extends object = Record<never, never>>(cache: Cache, fetcher: AppFetcher<S, T, P>) => ResourceHandle<T, P>;
+};
+/**
+ * Tuple shape returned by `context.useActions(...)` on an App-bound
+ * Context. Re-exports the base {@link UseActions} with the App's `S`
+ * threaded through every `HandlerContext` and produce draft.
+ */
+type AppActionsResult<M, AC, D, S> = UseActions<M extends Model | void ? M : void, AC extends Actions | void ? AC : void, D extends Props ? D : Props, S extends Env ? S : Env>;
+/**
+ * `useActions(...)` signature on the App-bound Context. Has two forms:
+ * void-model components omit the model argument entirely; everyone else
+ * passes their initial model as the first argument and an optional data
+ * callback as the second.
+ */
+type AppUseActions<M, AC, D, S> = M extends void ? (getData?: Data<D & Props>) => AppActionsResult<M, AC, D, S> : (model: M, getData?: Data<D & Props>) => AppActionsResult<M, AC, D, S>;
+/**
+ * `Context` handle returned by `app.useContext()`. Mirrors the base
+ * {@link Context} but threads the App's Env shape `S` through every
+ * handler's `context.env` and produce draft.
+ *
+ * @template M The model type for the component's state, or `void`.
+ * @template AC The actions class containing this component's action
+ *   definitions, or `void` for actions-only consumers.
+ * @template D The reactive data type returned from the `useActions(...)`
+ *   data callback.
+ * @template S The App's Env shape, supplied at `App({env})` time.
+ */
+export type AppContextHandle<M, AC, D, S> = {
+    /**
+     * Stable dispatch surface available before `useActions(...)` runs.
+     * Exposes only `dispatch(action, payload?)` &mdash; useful when an
+     * external imperative library needs a dispatch callback at construction
+     * time. Inside handlers, prefer `context.actions.dispatch` for the same
+     * call.
+     */
+    readonly actions: {
+        dispatch: Context<M extends Model | void ? M : void, AC extends Actions | void ? AC : void, D extends Props ? D : Props>["actions"]["dispatch"];
+    };
+    /**
+     * Typed bag of handler factories bound to `M`. Methods accept
+     * lodash-style dotted paths and array indices; keys autocomplete from
+     * the model declared on `app.useContext<Model, …>()`. See
+     * {@link WithHandle}.
+     */
+    readonly with: WithHandle<M extends Model | void ? M : void>;
+    /**
+     * Materialises the component-local model and reactive data, returning
+     * the `[model, actions, data]` tuple with `useAction`, `dispatch`,
+     * `inspect`, and `stream` attached. Pass the initial model as the first
+     * argument (unless `M` is `void`) and an optional data callback as the
+     * second &mdash; the callback re-runs every render so handlers reading
+     * `context.data` always see fresh values across `await` boundaries.
+     */
+    readonly useActions: AppUseActions<M, AC, D, S>;
+};
+export {};

package/dist/boundary/components/broadcast/utils.d.ts

@@ -6,7 +6,7 @@ import * as React from "react";
  * When a broadcast or multicast action is dispatched, the payload is
  * stored so that late-mounting components can replay it via
  * {@link useLifecycles} and handlers can read it via
- * `context.actions.resolution()`.
+ * `context.actions.final()`.
  */
 export declare class BroadcastEmitter extends EventEmitter {
     private cache;

package/dist/boundary/components/env/index.d.ts

@@ -0,0 +1,26 @@
+import { Props } from './types';
+import * as React from "react";
+export { useEnv } from './utils';
+/**
+ * Loose runtime shape for the per-`<Boundary>` Env. Each {@link App}
+ * narrows this to its own typed env via `App<S>({ env })`; the
+ * loose type exists so the framework's internal plumbing
+ * (`<Boundary>`, `useEnv`, handler `context.env`, Resource
+ * fetcher `context.env`) does not need to be parametric over S.
+ *
+ * Consumers should declare their Env shape inline via `App({ env })`
+ * &mdash; the inferred `S` is what flows through `app.useContext`,
+ * `app.useEnv`, and `app.Resource`. Module augmentation of `Env`
+ * is no longer required.
+ */
+export type Env = Record<string, unknown>;
+/**
+ * Provides a per-Boundary {@link Env} value to every component inside
+ * the boundary. Usually wired in via the `<Boundary env={initial}>`
+ * prop rather than used directly.
+ *
+ * The Env is **not** reactive. Mutating it does not trigger a
+ * re-render. Drive view state through the model; use the Env for
+ * cross-handler coordination.
+ */
+export declare function Env({ initial, children }: Props): React.ReactNode;

package/dist/boundary/components/env/types.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { Env } from './index';
+export type { Env } from './index';
+/**
+ * Props for the Env provider component. Accepts the initial Env
+ * value that satisfies the augmented {@link Env} interface.
+ */
+export type Props = {
+    initial: Env;
+    children: ReactNode;
+};

package/dist/boundary/components/env/utils.d.ts

@@ -0,0 +1,36 @@
+import { RefObject } from 'react';
+import { Env } from './index';
+import * as React from "react";
+/**
+ * React context exposing the per-Boundary Env ref. The ref itself is
+ * stable across renders — readers grab `.current` at call time.
+ *
+ * @internal
+ */
+export declare const Context: React.Context<React.RefObject<Env>>;
+/**
+ * Hook that returns a read-only handle to the per-Boundary {@link Env}.
+ * Reads use plain dot notation (`env.session`) and always reflect the
+ * latest value, even after `await` boundaries &mdash; the handle is a
+ * `Proxy` that delegates property access to the live ref.
+ *
+ * Writes are not exposed here. Mutate the Env inside an action handler
+ * via `context.actions.produce(({ model, env }) => { env.x = ... })`
+ * &mdash; the same Immer-style recipe used for the model. Mutations do
+ * **not** trigger a re-render; drive view state through the model.
+ *
+ * Prefer `app.useEnv()` from an {@link App} instance &mdash; the App
+ * factory infers the Env's shape from `app.env` and types every
+ * read/write against it. The bare `useEnv()` exists for non-App
+ * call sites and returns the loose {@link Env} record type.
+ */
+export declare function useEnv(): Env;
+/**
+ * Internal accessor for the per-Boundary Env ref &mdash; used by the
+ * Resource layer to pass a fresh snapshot to each fetcher invocation
+ * and by the action layer to write through `context.actions.produce`.
+ * Not exported from the library.
+ *
+ * @internal
+ */
+export declare function useEnvRef(): RefObject<Env>;

package/dist/boundary/components/scope/index.d.ts

@@ -1,40 +1,2 @@
-import { MulticastPayload } from '../../../types/index';
-import { ComponentType, ReactNode } from 'react';
-export { useScope, getScope } from './utils';
+export { Context, useScope, getScope } from './utils';
 export type { ScopeEntry, ScopeContext } from './types';
-/**
- * Higher-order component that opens a multicast scope keyed by the supplied
- * multicast action. Components rendered inside the wrapped tree (and any
- * descendants) participate in the scope: every dispatch of `action` reaches
- * every subscriber inside this boundary.
- *
- * Each multicast action defines its own scope — pass the same action you
- * declared with `Distribution.Multicast` to both `withScope` and
- * `actions.dispatch`.
- *
- * Multicast caches the most recent dispatched value per scope so late-mounted
- * components can read it via `context.actions.resolution()`.
- *
- * @param action - The multicast action that opens this scope.
- * @param Component - The component to wrap.
- * @returns A component that renders the original inside a fresh scope boundary.
- *
- * @example
- * ```tsx
- * export class Scope {
- *   static Mood = Action<Mood>("Mood", Distribution.Multicast);
- * }
- *
- * function Mood() {
- *   return (
- *     <>
- *       <Happy />
- *       <Sad />
- *     </>
- *   );
- * }
- *
- * export default withScope(Scope.Mood, Mood);
- * ```
- */
-export declare function withScope<P extends object, T = unknown>(action: MulticastPayload<T>, Component: ComponentType<P>): (props: P) => ReactNode;

package/dist/boundary/components/scope/types.d.ts

@@ -1,20 +1,24 @@
 import { BroadcastEmitter } from '../broadcast/utils';
-import { ActionId } from '../tasks/types';
 /**
- * Represents a single scope in the ancestor chain. The scope key is the
- * action id of the multicast action that opens the scope; each multicast
- * action defines its own scope.
+ * Runtime entry for a single multicast scope opened by an
+ * `<app.Scope().Boundary>`. The `id` uniquely identifies this scope
+ * instance; the `emitter` carries every multicast event dispatched
+ * inside the boundary, keyed internally by the action's symbol.
+ *
+ * Nested boundaries shadow outer ones via React context.
+ *
+ * @internal
  */
 export type ScopeEntry = {
-    /** The action id that opened this scope */
-    action: ActionId;
-    /** BroadcastEmitter for multicast events within this scope (caches last payload per event) */
-    emitter: BroadcastEmitter;
+    readonly id: symbol;
+    readonly emitter: BroadcastEmitter;
 };
 /**
- * The scope context is a flattened map of ancestor scopes keyed by the
- * multicast action that opened each scope. Each `withScope` merges its entry
- * with the parent's map, building up a complete lookup table for O(1)
- * retrieval. null indicates no scope ancestor.
+ * The scope context. `null` when no `<app.Scope().Boundary>` exists in
+ * the ancestor chain; otherwise the nearest entry &mdash; React context
+ * shadowing makes nested boundaries override outer ones for the
+ * subtree.
+ *
+ * @internal
  */
-export type ScopeContext = Map<ActionId, ScopeEntry> | null;
+export type ScopeContext = ScopeEntry | null;

package/dist/boundary/components/scope/utils.d.ts

@@ -1,19 +1,23 @@
 import { ScopeContext, ScopeEntry } from './types';
-import { ActionId } from '../tasks/types';
 import * as React from "react";
 /**
- * React context for the scope chain.
- * Starts as null (no scopes).
+ * React context for the nearest multicast scope. `null` at the root.
+ *
+ * @internal
  */
 export declare const Context: React.Context<ScopeContext>;
 /**
- * Hook to access the scope context from the nearest ancestor.
+ * Hook that returns the nearest multicast scope entry. `null` when
+ * the caller is not rendered inside any `<app.Scope().Boundary>`.
  *
- * @returns The scope context chain, or null if not inside any scope.
+ * @internal
  */
 export declare function useScope(): ScopeContext;
 /**
- * Looks up the scope opened by the given multicast action.
- * O(1) lookup from the flattened scope map.
+ * Pass-through accessor. Kept for the dispatch/subscribe sites that
+ * previously needed an action-keyed lookup; now the scope is a single
+ * entry (or `null`), so this returns it as-is.
+ *
+ * @internal
  */
-export declare function getScope(context: ScopeContext, action: ActionId): ScopeEntry | null;
+export declare function getScope(context: ScopeContext): ScopeEntry | null;

package/dist/boundary/components/sharing/index.d.ts

@@ -0,0 +1,43 @@
+import { PendingCall } from '../../../resource/index';
+import * as React from "react";
+/**
+ * Per-`<Boundary>` registry for `.coalesce(token)` sharing. Outer map
+ * keys on the `PendingCall.run` function identity (stable per Resource
+ * via the `build()` closure); inner map keys on
+ * `${paramsKey}|${coalesceKey(token)}`. While an entry exists every
+ * caller awaiting `.coalesce(token)` for the same Resource + params +
+ * token receives the same promise.
+ *
+ * Lifted into React context so each `<app.Boundary>` owns its own
+ * registry &mdash; two `App` instances in the same tree cannot collide
+ * on a shared token like `.coalesce("k")`.
+ *
+ * @internal
+ */
+export type Sharing = WeakMap<PendingCall["run"], Map<string, Promise<unknown>>>;
+/**
+ * React context exposing the per-Boundary sharing registry. The
+ * fallback is a fresh `WeakMap` used when `useSharing()` is read
+ * outside any `<Boundary>` &mdash; calls work but never share with any
+ * other component.
+ *
+ * @internal
+ */
+export declare const Context: React.Context<Sharing>;
+/**
+ * Wraps children with a Boundary-scoped sharing registry for
+ * `.coalesce(token)`. Rendered as part of {@link Boundary}; not
+ * exposed standalone.
+ *
+ * @internal
+ */
+export declare function SharingProvider({ children, }: {
+    children: React.ReactNode;
+}): React.ReactElement;
+/**
+ * Hook returning the per-Boundary sharing registry. Used by the
+ * `.coalesce(token)` chainable inside `useActions`.
+ *
+ * @internal
+ */
+export declare function useSharing(): Sharing;

package/dist/boundary/components/tap/index.d.ts

@@ -0,0 +1,36 @@
+import { Props } from './types';
+import * as React from "react";
+export { useTap } from './utils';
+export type { Tap, Tapped, Invocation, Failure, Mutations, Snapshot, } from './types';
+/**
+ * Internal provider that wires a {@link Tap} observer into the React
+ * context consumed by `useActions` during dispatch. Rendered by the
+ * top-level `<Boundary>` (and indirectly by `<app.Boundary>`); not
+ * exposed on the public surface &mdash; consumers should pass the
+ * callback via the `tap` prop of either boundary instead of mounting
+ * this provider directly.
+ *
+ * The supplied `tap` callback is held in a `useRef` and indirected
+ * through a stable `useMemo` wrapper. The ref is synchronised inside a
+ * `useLayoutEffect` &mdash; React's sanctioned write-after-commit
+ * window &mdash; so the provider stays compatible with Concurrent
+ * rendering, where the render function may be invoked more than once
+ * per commit and direct mutation during render would race the
+ * scheduler.
+ *
+ * Keeping the context value referentially constant for the lifetime of
+ * the boundary means callers may pass inline arrow functions without
+ * invalidating the dispatch pipeline on every render &mdash; the
+ * latest callback is read at fire time, not at provider-render time.
+ * When `tap` is `undefined`, the wrapper short-circuits via optional
+ * chaining: no allocation per event beyond the wrapper call itself.
+ *
+ * @param props.tap Observer to receive lifecycle events for every action
+ *   handler dispatched inside the boundary. See {@link Tap}.
+ * @param props.children Subtree that should observe the supplied tap.
+ * @returns Children rendered inside the tap context provider.
+ *
+ * @see {@link Tap} &mdash; the observer signature.
+ * @see {@link Tapped} &mdash; the discriminated union of event shapes.
+ */
+export declare function Tappable({ tap, children }: Props): React.ReactNode;