@retronew/call-vue 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 retronew
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+# @retronew/call-vue
+
+[![npm version](https://img.shields.io/npm/v/%40retronew%2Fcall-vue.svg)](https://www.npmjs.com/package/@retronew/call-vue)
+[![npm downloads](https://img.shields.io/npm/dm/%40retronew%2Fcall-vue.svg)](https://www.npmjs.com/package/@retronew/call-vue)
+[![minzipped size](https://img.shields.io/bundlephobia/minzip/%40retronew%2Fcall-vue)](https://bundlephobia.com/package/@retronew/call-vue)
+[![License: MIT](https://img.shields.io/npm/l/%40retronew%2Fcall-vue.svg)](../../LICENSE)
+
+Call & await Vue components like async functions. A Vue 3 port of
+[`react-call`](https://github.com/desko27/react-call)'s core API
+(`createCallable`, `call`/`upsert`/`end`/`update`) built on native Vue
+reactivity — no context providers, no global store to wire up.
+
+## Why
+
+Confirmation dialogs, prompts, and toasts are usually one-off components you
+have to mount, manage `v-model`/visibility for, and thread a resolve callback
+through. `createCallable` turns the component itself into an awaitable
+function:
+
+```ts
+const confirmed = await Confirm.call({ message: 'Delete this file?' })
+if (confirmed) deleteFile()
+```
+
+No global state, no extra store — `<Confirm />` mounted once *is* the stack.
+
+## Install
+
+```bash
+pnpm add @retronew/call-vue
+```
+
+## Quick start
+
+1. Define the component. It receives your own props **plus** an injected
+   `call` prop carrying the imperative context for this instance:
+
+```vue
+<!-- Confirm.vue -->
+<script setup lang="ts">
+import type { PropsWithCall } from '@retronew/call-vue'
+
+type Props = { message: string }
+type Response = boolean
+
+defineProps<PropsWithCall<Props, Response, Record<string, never>>>()
+</script>
+
+<template>
+  <div class="dialog">
+    <p>{{ message }}</p>
+    <button @click="call.end(true)">Yes</button>
+    <button @click="call.end(false)">No</button>
+  </div>
+</template>
+```
+
+2. Wrap it with `createCallable` and mount the result once, anywhere near the
+   root of your app:
+
+```ts
+// confirm.ts
+import { createCallable } from '@retronew/call-vue'
+import ConfirmDialog from './Confirm.vue'
+
+export const Confirm = createCallable<{ message: string }, boolean>(ConfirmDialog)
+```
+
+```vue
+<!-- App.vue -->
+<script setup lang="ts">
+import { Confirm } from './confirm'
+</script>
+
+<template>
+  <Confirm />
+  <!-- rest of the app -->
+</template>
+```
+
+3. Call it like an async function, from anywhere:
+
+```ts
+import { Confirm } from './confirm'
+
+async function handleDelete() {
+  const confirmed = await Confirm.call({ message: 'Delete this file?' })
+  if (confirmed) await deleteFile()
+}
+```
+
+## API
+
+- **`Confirm.call(props)`** → `Promise<Response>` — pushes a new instance onto
+  the stack; resolves when that instance's `call.end(response)` runs.
+- **`Confirm.upsert(props)`** → `Promise<Response>` — like `call`, but reuses
+  the in-flight instance instead of stacking a new one while one is still
+  open. Ideal for a single "status" toast whose props change over time
+  (`Confirm.upsert({ text: 'Uploading… 42%' })`).
+- **`Confirm.end(response)`** / **`Confirm.end(promise, response)`** —
+  resolve every open call, or just the one identified by the promise `call()`/
+  `upsert()` returned.
+- **`Confirm.update(props)`** / **`Confirm.update(promise, props)`** —
+  shallow-merge partial props into every open call, or just one, without
+  resolving it.
+- **`call.key`**, **`call.ended`**, **`call.index`**, **`call.stackSize`**,
+  **`call.root`** — read inside the component: stable identity, whether
+  `end()` already ran (so you can key an exit transition off it), this
+  instance's position in the stack, how many are open, and whatever props
+  were passed to `<Confirm rootProp="…" />`.
+
+See the [Claude Code skill](skills/call-vue/SKILL.md) for the stacking model,
+`unmountingDelay` exit-transition pattern, and the single-`<Root>` constraint
+in depth.
+
+## Exit transitions
+
+Pass a second argument to `createCallable` to keep an ended call mounted
+for N milliseconds — long enough for a `<Transition>` to play — before it's
+actually removed from the stack:
+
+```ts
+export const Toast = createCallable<Props, Response>(ToastCard, 200 /* ms */)
+```
+
+Inside `ToastCard`, branch on `call.ended` to trigger the leave state.
+
+## Stacking
+
+Every `call()` while a previous one is still open stacks on top of it —
+`<Confirm />` renders one component instance per open call, each with its own
+`call.index`/`call.stackSize`. Nothing is queued or hidden automatically;
+that's a decision your component makes (e.g. only rendering the top of the
+stack, or rendering all of them with a depth-based transform).
+
+## Constraints
+
+- Exactly **one** `<Confirm />` may be mounted at a time. `call()`/`upsert()`
+  throw `No <Root> found!` if none is mounted yet, or
+  `Multiple instances of <Root> found!` if more than one is.
+- Unmounting `<Confirm />` resets its stack — a fresh mount always starts
+  empty.
+
+## Claude Code skill
+
+This package ships a [Claude Code skill](skills/call-vue/SKILL.md) covering
+the stack/upsert model, exit-transition timing, and the single-`<Root>`
+constraint. Claude Code doesn't auto-discover skills inside `node_modules`
+yet, so after installing, copy or symlink it into your project:
+
+```bash
+mkdir -p .claude/skills
+cp -r node_modules/@retronew/call-vue/skills/call-vue .claude/skills/call-vue
+```
+
+## Credits
+
+API design ported from [`react-call`](https://github.com/desko27/react-call)
+by [@desko27](https://github.com/desko27), reimplemented from scratch on Vue
+3 reactivity primitives (`shallowRef`, no `useSyncExternalStore` equivalent
+needed).

package/dist/index.d.mts

@@ -0,0 +1,72 @@
+import { Component, DefineComponent } from "vue";
+//#region src/createCallable/types.d.ts
+/**
+ * Properties every `call.*` context carries, regardless of stack position.
+ * Mirrors `CallItemPublicProperties` in react-call's store.
+ */
+interface CallItemPublicProperties<Response> {
+  /** Stable identity for this call within the stack; safe to use as a `:key`. */
+  key: string;
+  /** Resolve this specific call's promise and mark it `ended`. */
+  end: (response: Response) => void;
+  /**
+   * `true` once `end()` has resolved this call. The call stays mounted for
+   * `unmountingDelay` ms after this flips, so an exit transition can play.
+   */
+  ended: boolean;
+}
+/** The `call()` method returned by `createCallable`. */
+type CallFunction<Props, Response> = (props: Props) => Promise<Response>;
+/** The `upsert()` method returned by `createCallable`. */
+type UpsertFunction<Props, Response> = (props: Props) => Promise<Response>;
+/**
+ * The special `call` prop every user component receives, on top of its own
+ * `Props`. Carries per-call identity/state plus stack/root context.
+ */
+type CallContext<_Props, Response, RootProps> = CallItemPublicProperties<Response> & {
+  /** Props passed to `<Root>` (the mounted callable component), if any. */
+  root: RootProps;
+  /** This call's position in the current stack (0 = oldest). */
+  index: number;
+  /** Number of calls currently stacked (including this one). */
+  stackSize: number;
+};
+/** User props merged with the injected `call` context. */
+type PropsWithCall<Props, Response, RootProps> = Props & {
+  call: CallContext<Props, Response, RootProps>;
+};
+/**
+ * The shape `createCallable` expects: any Vue component (SFC, `defineComponent`,
+ * or functional) whose props satisfy `PropsWithCall<Props, Response, RootProps>`.
+ */
+type UserComponent<Props, Response, RootProps> = Component<PropsWithCall<Props, Response, RootProps>>;
+/**
+ * What `createCallable` returns.
+ *
+ * The callable is the Root component itself — mount it with `<Confirm />`
+ * (or `<Confirm.Root />`) and use the imperative methods (`call`, `upsert`,
+ * `end`, `update`) as properties on the very same object.
+ */
+type Callable<Props, Response, RootProps> = DefineComponent<RootProps> & {
+  /** Alias for the callable itself — `Confirm.Root === Confirm`. */
+  Root: DefineComponent<RootProps>;
+  call: CallFunction<Props, Response>;
+  upsert: UpsertFunction<Props, Response>;
+  end: ((promise: Promise<Response>, response: Response) => void) & ((response: Response) => void);
+  update: ((promise: Promise<Response>, props: Partial<Props>) => void) & ((props: Partial<Props>) => void);
+};
+//#endregion
+//#region src/createCallable/index.d.ts
+/**
+ * Turns a Vue component into a "callable": mount it once as `<Confirm />`
+ * and then `await Confirm.call(props)` from anywhere to push an instance
+ * onto its stack and get back a promise that resolves when the instance
+ * calls `call.end(response)`.
+ *
+ * This is a Vue-native port of react-call's `createCallable` — see
+ * `skills/call-vue/SKILL.md` for the full mental model (stack, upsert,
+ * mutation flow).
+ */
+declare function createCallable<Props = void, Response = void, RootProps extends Record<string, unknown> = Record<string, never>>(UserComponent: UserComponent<Props, Response, RootProps>, unmountingDelay?: number): Callable<Props, Response, RootProps>;
+//#endregion
+export { type CallContext, type CallFunction, type Callable, type PropsWithCall, type UpsertFunction, type UserComponent, createCallable };

package/dist/index.mjs

@@ -0,0 +1,170 @@
+import { defineComponent, h, onUnmounted, shallowRef } from "vue";
+//#region src/createCallable/store.ts
+/**
+* Vue-native replacement for react-call's `useSyncExternalStore`-backed
+* store: `shallowRef` already gives us a single reactive snapshot per
+* store, so there's no separate subscribe/getSnapshot machinery to hand-roll.
+*
+* `rootCount` plays the role react-call's `listeners.size` plays — it's how
+* `assertSingleRoot` in `createCallable` detects a missing or duplicated
+* `<Root>`. It's tracked here (rather than as its own `ref`) because it must
+* never trigger a re-render on its own; only stack changes should.
+*/
+function createStackStore() {
+	let nextKey = 0;
+	let upsertPromise = null;
+	let rootCount = 0;
+	const stack = shallowRef([]);
+	return {
+		stack,
+		add: (call) => {
+			stack.value = [...stack.value, {
+				...call,
+				key: String(nextKey++)
+			}];
+		},
+		set: (promise, updateFn) => {
+			stack.value = stack.value.map((call) => promise && call.promise !== promise ? call : updateFn(call));
+		},
+		remove: (promises) => {
+			stack.value = stack.value.filter((c) => !promises.has(c.promise));
+		},
+		/** Call once from a mounted `<Root>`; call the returned function on unmount. */
+		mountRoot: () => {
+			rootCount++;
+			return () => {
+				rootCount--;
+				if (rootCount === 0) {
+					nextKey = 0;
+					stack.value = [];
+					upsertPromise = null;
+				}
+			};
+		},
+		getRootCount: () => rootCount,
+		getUpsertPromise: () => upsertPromise,
+		setUpsertPromise: (p) => {
+			upsertPromise = p;
+		}
+	};
+}
+//#endregion
+//#region src/createCallable/index.ts
+/**
+* Turns a Vue component into a "callable": mount it once as `<Confirm />`
+* and then `await Confirm.call(props)` from anywhere to push an instance
+* onto its stack and get back a promise that resolves when the instance
+* calls `call.end(response)`.
+*
+* This is a Vue-native port of react-call's `createCallable` — see
+* `skills/call-vue/SKILL.md` for the full mental model (stack, upsert,
+* mutation flow).
+*/
+function createCallable(UserComponent, unmountingDelay = 0) {
+	const store = createStackStore();
+	const createEnd = (promise) => (response) => {
+		const ending = /* @__PURE__ */ new Set();
+		store.set(promise, (call) => {
+			call.resolve(response);
+			ending.add(call.promise);
+			return {
+				...call,
+				ended: true
+			};
+		});
+		globalThis.setTimeout(() => store.remove(ending), unmountingDelay);
+	};
+	const assertSingleRoot = () => {
+		const count = store.getRootCount();
+		if (!count) throw new Error("No <Root> found!");
+		if (count > 1) throw new Error("Multiple instances of <Root> found!");
+	};
+	const call = (props) => {
+		assertSingleRoot();
+		let resolve;
+		const promise = new Promise((res) => {
+			resolve = res;
+		});
+		store.add({
+			props,
+			end: createEnd(promise),
+			ended: false,
+			promise,
+			resolve
+		});
+		return promise;
+	};
+	const upsert = (props) => {
+		assertSingleRoot();
+		const existing = store.getUpsertPromise();
+		if (existing) {
+			store.set(existing, (c) => ({
+				...c,
+				props
+			}));
+			return existing;
+		}
+		let resolve;
+		const promise = new Promise((res) => {
+			resolve = res;
+		});
+		store.setUpsertPromise(promise);
+		store.add({
+			props,
+			end: (response) => {
+				store.setUpsertPromise(null);
+				createEnd(promise)(response);
+			},
+			ended: false,
+			promise,
+			resolve
+		});
+		return promise;
+	};
+	const end = (...args) => {
+		const targeted = args.length === 2;
+		const promise = targeted ? args[0] : null;
+		const response = targeted ? args[1] : args[0];
+		if (!targeted || promise === store.getUpsertPromise()) store.setUpsertPromise(null);
+		return createEnd(promise)(response);
+	};
+	const update = (...args) => {
+		const targeted = args.length === 2;
+		store.set(targeted ? args[0] : null, (c) => ({
+			...c,
+			props: {
+				...c.props,
+				...targeted ? args[1] : args[0]
+			}
+		}));
+	};
+	const Root = defineComponent({
+		name: "CallableRoot",
+		inheritAttrs: false,
+		setup(_, { attrs }) {
+			const unmountRoot = store.mountRoot();
+			onUnmounted(unmountRoot);
+			return () => store.stack.value.map((item, index, stack) => h(UserComponent, {
+				...item.props,
+				key: item.key,
+				call: {
+					key: item.key,
+					end: item.end,
+					ended: item.ended,
+					root: attrs,
+					index,
+					stackSize: stack.length
+				}
+			}));
+		}
+	});
+	return Object.assign(Root, {
+		Root,
+		call,
+		upsert,
+		end,
+		update
+	});
+}
+//#endregion
+export { createCallable };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@retronew/call-vue",
+  "version": "0.2.0",
+  "description": "Call & await Vue components like async functions — a Vue 3 port of react-call.",
+  "keywords": [
+    "async",
+    "composable",
+    "confirm",
+    "dialog",
+    "modal",
+    "vue",
+    "vue3"
+  ],
+  "homepage": "https://github.com/retronew/ui-kit#readme",
+  "bugs": {
+    "url": "https://github.com/retronew/ui-kit/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/retronew/ui-kit.git",
+    "directory": "packages/call-vue"
+  },
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "@vue/test-utils": "^2.4.11",
+    "jsdom": "^30.0.1",
+    "typescript": "^7.0.2",
+    "vite-plus": "^0.2.9",
+    "vitest": "4.1.10",
+    "vue": "^3.5.41"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "test:coverage": "vp test --coverage",
+    "check": "vp check"
+  }
+}

package/skills/call-vue/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: call-vue
+description: Reach for @retronew/call-vue (createCallable) when building UI that resolves a value back to its caller — confirmations, dialogs, form modals, toasts, notifications, context menus, pickers. Use when a Vue task involves any such "await the UI" interaction, when code imports createCallable from @retronew/call-vue, or when the user mentions call-vue, react-call, or Callables in a Vue project. If call-vue isn't a dependency yet but the problem fits, propose adding it. Covers Declare→Root→Call, call vs upsert, exit transitions, and the single-Root rule.
+---
+
+# @retronew/call-vue
+
+`createCallable()` turns a Vue component into something you can `await`: you
+call it imperatively from anywhere and it resolves with a value. This is a
+Vue-native port of [`react-call`](https://github.com/desko27/react-call)'s
+core API — same mental model, built on Vue's own reactivity (`shallowRef`)
+instead of React's `useSyncExternalStore`.
+
+## When to reach for it (and when not)
+
+**Reach for it** when a piece of UI conceptually *returns a value to its
+caller* and you want to `await` that value from async code: confirmations,
+dialogs, form modals, toasts/notifications, context menus, pickers,
+multi-step wizards.
+
+**Propose it** if `@retronew/call-vue` isn't a dependency yet but the task
+fits — then `pnpm add @retronew/call-vue`.
+
+**Don't push it** when another solution is already in place and working —
+mention it as an option, don't refactor unprompted. Skip it for purely
+presentational components that return nothing, and for full-page flows better
+served by routing.
+
+## Vocabulary (use these exact terms)
+
+- **Callable** — the value `createCallable()` returns. It is *both* a Vue
+  component (mount `<Confirm />`) *and* a namespace of methods (`call`,
+  `upsert`, `end`, `update`) attached to the same object. Don't call it a
+  "modal/dialog/component".
+- **Root** — the mounting form of the Callable: the bare `<Confirm />`
+  (`Confirm.Root === Confirm`, kept as an alias). Not a "provider/portal".
+- **Call** — one imperative invocation (`Confirm.call({...})`), resolves to a
+  **Response**.
+- **Stack** — the ordered list of active Calls a Root renders (not a
+  "queue"). Each renders as one instance of the user component.
+- **CallContext** — the `call` prop your component receives: `{ end, ended,
+  key, index, stackSize, root }`. Not a Vue "provide/inject context".
+- **Upsert** — singleton-style Call (`upsert()`).
+
+## The model: Declare → Root → Call
+
+```vue
+<!-- Confirm.vue -->
+<script setup lang="ts">
+import type { PropsWithCall } from '@retronew/call-vue'
+
+type Props = { message: string }
+type Response = boolean
+
+// `call` is the special injected prop (the CallContext)
+defineProps<PropsWithCall<Props, Response, Record<string, never>>>()
+</script>
+
+<template>
+  <div role="dialog">
+    <p>{{ message }}</p>
+    <button @click="call.end(true)">Yes</button>
+    <button @click="call.end(false)">No</button>
+  </div>
+</template>
+```
+
+```ts
+// confirm.ts — 1. Declare
+import { createCallable } from '@retronew/call-vue'
+import ConfirmDialog from './Confirm.vue'
+
+export const Confirm = createCallable<{ message: string }, boolean>(ConfirmDialog)
+```
+
+```vue
+<!-- App.vue — 2. Root: mount once, somewhere always rendered -->
+<template>
+  <Confirm />
+</template>
+```
+
+```ts
+// 3. Call & await — from anywhere
+const accepted = await Confirm.call({ message: 'Continue?' })
+```
+
+Generics are `createCallable<Props, Response, RootProps>` (all optional,
+default to `void`/`void`/`Record<string, never>`).
+
+Plain functional components work too — `createCallable` accepts anything
+matching Vue's `Component<Props>` type, including a bare
+`(props) => VNode` function, which is often less ceremony than an SFC for a
+tiny callable.
+
+## Decision guide
+
+- **`call` vs `upsert`** — `call()` opens a new Call every time (they stack).
+  `upsert()` is singleton: the first invocation creates the Call, later
+  `upsert()` calls update the same one and return the same promise. Use
+  `upsert` for toasts, progress, loading — anything that should have at most
+  one instance alive.
+- **Root props vs call props** — per-Call data goes in `call()`'s props; data
+  shared across every Call (theme, current user) goes in **RootProps**,
+  passed as ordinary attrs to `<Confirm userName="…" />` and read back via
+  `call.root` inside every mounted instance. `RootProps` arrives through
+  Vue's `$attrs` under the hood — `<Root>` declares no props of its own, so
+  it forwards whatever you hand it as-is.
+- **End / update from the caller** — `Confirm.end(promise, value)` /
+  `Confirm.update(promise, partialProps)` target one Call; omit the promise
+  argument to affect every currently active Call instead.
+
+## Hard rules (the common failures)
+
+- **One Root per Callable.** Mounting `<Confirm />` in two live places throws
+  *"Multiple instances of `<Root>` found!"* the next time `call()`/`upsert()`
+  runs. Don't mount a Callable per-route or per-feature — mount it once, high
+  in the tree (e.g. `App.vue`), same as you'd mount a single toast outlet.
+- **Mount the Root where it stays alive when you call.** If the Root sits in
+  a `v-if`-gated or route-unmounted subtree, `call()` from outside it throws
+  *"No `<Root>` found!"*. If that's happening, check whether the Root got
+  unmounted before the call, not whether `createCallable` was set up wrong.
+- **Unmounting resets the stack.** A Callable's stack is scoped to its
+  currently-mounted Root instance — remount it (e.g. via `v-if` toggling
+  off/on, or HMR) and any Calls made against the previous mount are gone;
+  there's no persistence across mounts.
+- **Exit transitions** need the unmount delay as the 2nd argument to
+  `createCallable`, then drive the leave state off `call.ended` (a boolean
+  prop, not a Vue `<Transition>` hook by itself — combine the two):
+
+  ```ts
+  export const Toast = createCallable<Props, Response>(ToastCard, 200 /* ms */)
+  ```
+
+  Inside `ToastCard`, branch on `props.call.ended` to add a leaving class or
+  swap into an exit-animation state; the instance stays mounted for 200ms
+  after `end()` so a CSS transition (or Vue `<Transition>` wrapping the
+  Callable's stack render) has time to play before removal.
+
+## Anti-patterns
+
+- Placing `<Confirm />` per-route or per-feature → multi-Root throw. One
+  mount, reused everywhere via `.call()`.
+- Reusing `call()` for singleton UI (toasts, a single progress indicator) →
+  duplicate stacked instances. Use `upsert()` instead.
+- Treating the Callable as a plain component to render with data props — the
+  props you pass to `<Confirm />` itself are **RootProps** (shared context),
+  never the per-instance data; that always goes through `.call(props)`.
+- Reaching into `call.root` for data that changes per-Call — it's constant
+  for the Root's whole lifetime (whatever `<Confirm />` was mounted with);
+  put per-Call data in the component's own props instead.
+
+## Quick reference
+
+| Method | Targeted form | Untargeted form |
+|---|---|---|
+| `call(props)` | — | opens a new Call, returns its `Promise<Response>` |
+| `upsert(props)` | — | opens or updates the pending upsert Call |
+| `end(response)` / `end(promise, response)` | resolves the one Call | resolves every open Call |
+| `update(props)` / `update(promise, props)` | merges into the one Call | merges into every open Call |
+
+`call` prop shape inside the component: `{ key, end, ended, root, index,
+stackSize }` — see the package [README](../../README.md) for the full field
+descriptions.