@assistant-ui/react 0.15.15 → 0.15.16

package/src/primitives/actionBar/ActionBarExportMarkdown.tsx

@@ -61,7 +61,9 @@ export const ActionBarPrimitiveExportMarkdown = forwardRef<
       ref={forwardedRef}
       disabled={disabled || !callback}
       onClick={composeEventHandlers(onClick, () => {
-        callback?.();
+        void callback?.().catch((error: unknown) => {
+          console.error("[assistant-ui] markdown export failed:", error);
+        });
       })}
     />
   );

package/src/primitives/branchPicker/BranchPickerRoot.tsx

@@ -6,7 +6,7 @@ import {
   forwardRef,
   type ComponentPropsWithoutRef,
 } from "react";
-import { MessagePrimitiveIf as If } from "../message/MessageIf";
+import { AuiIf } from "@assistant-ui/store";
 
 export namespace BranchPickerPrimitiveRoot {
   export type Element = ComponentRef<typeof Primitive.div>;
@@ -42,9 +42,11 @@ export const BranchPickerPrimitiveRoot = forwardRef<
   BranchPickerPrimitiveRoot.Props
 >(({ hideWhenSingleBranch, ...rest }, ref) => {
   return (
-    <If hasBranches={hideWhenSingleBranch ? true : undefined}>
+    <AuiIf
+      condition={(s) => !hideWhenSingleBranch || s.message.branchCount >= 2}
+    >
       <Primitive.div {...rest} ref={ref} />
-    </If>
+    </AuiIf>
   );
 });
 

package/src/primitives/composer/ComposerDictationTranscript.tsx

@@ -21,11 +21,11 @@ export namespace ComposerPrimitiveDictationTranscript {
  *
  * @example
  * ```tsx
- * <ComposerPrimitive.If dictation>
+ * <AuiIf condition={(s) => s.composer.dictation != null}>
  *   <div className="dictation-preview">
  *     <ComposerPrimitive.DictationTranscript />
  *   </div>
- * </ComposerPrimitive.If>
+ * </AuiIf>
  * ```
  */
 export const ComposerPrimitiveDictationTranscript = forwardRef<

package/src/primitives/composer/trigger/triggerSelectionResource.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it, vi } from "vitest";
+import { createTapRoot, flushTapSync, useResource } from "@assistant-ui/tap";
+import type {
+  Unstable_DirectiveFormatter,
+  Unstable_TriggerItem,
+} from "@assistant-ui/core";
+import type { AssistantClient } from "@assistant-ui/store";
+import { TriggerDetectionResource } from "./triggerDetectionResource";
+import {
+  TriggerSelectionResource,
+  type TriggerBehavior,
+} from "./triggerSelectionResource";
+
+const item: Unstable_TriggerItem = {
+  id: "file",
+  type: "file",
+  label: "file.txt",
+};
+
+const formatter: Unstable_DirectiveFormatter = {
+  serialize: () => "@file.txt",
+  parse: () => [],
+};
+
+const makeAui = (textRef: { value: string }) => {
+  const setText = vi.fn((value: string) => {
+    textRef.value = value;
+  });
+
+  return {
+    aui: {
+      composer: {
+        getState: () => ({ text: textRef.value }),
+        setText,
+      },
+    } as unknown as AssistantClient,
+    setText,
+  };
+};
+
+const render = ({
+  behavior,
+  text,
+  trigger,
+}: {
+  behavior: TriggerBehavior;
+  text: string;
+  trigger: { offset: number; query: string };
+}) => {
+  const textRef = { value: text };
+  const { aui, setText } = makeAui(textRef);
+  const setCursorPosition = vi.fn();
+  const onSelected = vi.fn();
+  const root = createTapRoot(function Root() {
+    return useResource(
+      TriggerSelectionResource({
+        behavior,
+        trigger,
+        aui,
+        triggerChar: "@",
+        setCursorPosition,
+        onSelected,
+      }),
+    );
+  });
+
+  return { root, setText, setCursorPosition, onSelected };
+};
+
+describe("TriggerSelectionResource", () => {
+  it("resynchronizes the cursor after inserting a directive", () => {
+    const { root, setText, setCursorPosition, onSelected } = render({
+      behavior: { kind: "directive", formatter },
+      text: "@file tail",
+      trigger: { offset: 0, query: "file" },
+    });
+
+    root.getValue().selectItem(item);
+
+    expect(setText).toHaveBeenCalledWith("@file.txt tail");
+    expect(setCursorPosition).toHaveBeenCalledWith("@file.txt".length + 1);
+    expect(onSelected).toHaveBeenCalledOnce();
+  });
+
+  it("resynchronizes the cursor after removing an action", () => {
+    const { root, setText, setCursorPosition } = render({
+      behavior: {
+        kind: "action",
+        formatter,
+        onExecute: vi.fn(),
+        removeOnExecute: true,
+      },
+      text: "before @file tail",
+      trigger: { offset: 7, query: "file" },
+    });
+
+    root.getValue().selectItem(item);
+
+    expect(setText).toHaveBeenCalledWith("before tail");
+    expect(setCursorPosition).toHaveBeenCalledWith(7);
+  });
+
+  it("does not rewrite composer text on a second select after insertion", () => {
+    const textRef = { value: "@fil" };
+    const { aui, setText } = makeAui(textRef);
+    const onSelected = vi.fn();
+    const root = createTapRoot(function Root() {
+      const detection = useResource(
+        TriggerDetectionResource({
+          text: textRef.value,
+          triggerChar: "@",
+        }),
+      );
+      return useResource(
+        TriggerSelectionResource({
+          behavior: { kind: "directive", formatter },
+          trigger: detection.trigger,
+          aui,
+          triggerChar: "@",
+          setCursorPosition: detection.setCursorPosition,
+          onSelected,
+        }),
+      );
+    });
+
+    flushTapSync(() => {
+      root.getValue().selectItem(item);
+    });
+    root.getValue().selectItem(item);
+
+    expect(setText).toHaveBeenCalledOnce();
+    expect(setText).toHaveBeenCalledWith("@file.txt ");
+    expect(textRef.value).toBe("@file.txt ");
+  });
+});

package/src/primitives/composer/trigger/triggerSelectionResource.ts

@@ -83,6 +83,7 @@ const useTriggerSelectionResource = ({
       aui.composer.setText(
         before + directive + (after.startsWith(" ") ? after : ` ${after}`),
       );
+      setCursorPosition(before.length + directive.length + 1);
     };
 
     if (behavior.kind === "directive") {
@@ -93,6 +94,7 @@ const useTriggerSelectionResource = ({
         aui.composer.setText(
           before + (after.startsWith(" ") ? after.slice(1) : after),
         );
+        setCursorPosition(before.length);
       } else {
         // Leave directive chip in the composer as an audit trail
         insertDirective();

package/src/primitives/thread/ThreadRoot.tsx

@@ -24,6 +24,9 @@ export namespace ThreadPrimitiveRoot {
  * This component serves as the foundational wrapper for all thread-related components.
  * It provides the basic structure and context needed for thread functionality.
  *
+ * While this component is mounted, an unhandled Escape keydown stops active speech, even if
+ * the action bar that started it is no longer mounted.
+ *
  * @example
  * ```tsx
  * <ThreadPrimitive.Root>

package/src/sandbox-host/SandboxHost.test.tsx

@@ -229,6 +229,67 @@ describe("SandboxHost", () => {
     expect(onError.mock.calls[0]![0].message).toBe("boom");
   });
 
+  it("does not report render failures after unmount", async () => {
+    let rejectRender!: (error: Error) => void;
+    renderHtmlMock.mockReturnValue(
+      new Promise((_, reject) => {
+        rejectRender = reject;
+      }),
+    );
+    const onError = vi.fn();
+
+    await act(async () => {
+      root.render(
+        <SandboxHost
+          content={{ html: "" }}
+          contentKey="k"
+          createBridge={() => ({ onMessage: vi.fn(), dispose: vi.fn() })}
+          onError={onError}
+        />,
+      );
+    });
+
+    await act(async () => {
+      root.unmount();
+    });
+    rejectRender(new Error("late failure"));
+    await flush();
+
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("contains failures thrown by onError", async () => {
+    const renderError = new Error("render failed");
+    const callbackError = new Error("error callback failed");
+    renderHtmlMock.mockRejectedValue(renderError);
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    try {
+      await act(async () => {
+        root.render(
+          <SandboxHost
+            content={{ html: "" }}
+            contentKey="k"
+            createBridge={() => ({ onMessage: vi.fn(), dispose: vi.fn() })}
+            onError={() => {
+              throw callbackError;
+            }}
+          />,
+        );
+      });
+      await flush();
+
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] SandboxHost onError callback threw an error",
+        callbackError,
+      );
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+
   it("disposes the rendered frame when bridge creation fails", async () => {
     const rendered = fakeRendered();
     renderHtmlMock.mockResolvedValue(rendered);

package/src/sandbox-host/SandboxHost.tsx

@@ -6,6 +6,7 @@ import {
   SafeContentFrame,
   type SandboxOption,
 } from "safe-content-frame";
+import { invokeCallbackSafely } from "../utils/invokeCallbackSafely";
 
 const DEFAULT_PRODUCT = "assistant-ui-sandbox";
 const DEFAULT_MAX_HEIGHT = 800;
@@ -147,10 +148,13 @@ export function SandboxHost({
         window.addEventListener("message", onMessage);
       })
       .catch((err) => {
+        if (cancelled) return;
         frame?.dispose();
         frame = null;
-        liveRef.current.onError?.(
-          err instanceof Error ? err : new Error(String(err)),
+        const error = err instanceof Error ? err : new Error(String(err));
+        invokeCallbackSafely(
+          () => liveRef.current.onError?.(error),
+          "SandboxHost onError",
         );
       });
 

package/src/unstable/useLiveCompletionAdapter.test.tsx

@@ -203,6 +203,63 @@ describe("unstable_useLiveCompletionAdapter", () => {
     ]);
   });
 
+  it("keeps cached results when only the fetcher identity changes", async () => {
+    const first = vi.fn(async () => [item("alice")]);
+    const second = vi.fn(async () => [item("bob")]);
+    const { result, rerender } = renderHook(
+      ({ fetcher }) =>
+        unstable_useLiveCompletionAdapter({
+          fetcher,
+          cacheKey: "workspace-a",
+          debounceMs: 0,
+        }),
+      { initialProps: { fetcher: first } },
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+
+    await act(async () => {
+      rerender({ fetcher: second });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(second).not.toHaveBeenCalled();
+    expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+  });
+
+  it("drops a pending result when only the cache key changes", async () => {
+    let resolveFirst!: (items: readonly Unstable_TriggerItem[]) => void;
+    const first = new Promise<readonly Unstable_TriggerItem[]>((resolve) => {
+      resolveFirst = resolve;
+    });
+    const fetcher = vi.fn(() => first);
+    const { result, rerender } = renderHook(
+      ({ cacheKey }) =>
+        unstable_useLiveCompletionAdapter({ fetcher, cacheKey, debounceMs: 0 }),
+      { initialProps: { cacheKey: "workspace-a" } },
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      rerender({ cacheKey: "workspace-b" });
+    });
+    await act(async () => {
+      resolveFirst([item("workspace-a")]);
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(result.current.adapter.search!("alice")).toEqual([]);
+  });
+
   it("allows a failed query to be retried", async () => {
     const fetcher = vi
       .fn<(query: string) => Promise<readonly Unstable_TriggerItem[]>>()

package/src/utils/invokeCallbackSafely.ts

@@ -0,0 +1,11 @@
+export const invokeCallbackSafely = (invoke: () => unknown, name: string) => {
+  const reportFailure = (error: unknown) => {
+    console.error(`[assistant-ui] ${name} callback threw an error`, error);
+  };
+
+  try {
+    void Promise.resolve(invoke()).catch(reportFailure);
+  } catch (error) {
+    reportFailure(error);
+  }
+};

package/src/utils/smooth/useSmooth.test.tsx

@@ -222,4 +222,114 @@ describe("useSmooth", () => {
     frame();
     expect(result.current.text).toBe("z");
   });
+
+  it("drains completed text when a queued frame never runs", () => {
+    vi.spyOn(globalThis, "requestAnimationFrame").mockReturnValue(1);
+    vi.spyOn(globalThis, "cancelAnimationFrame").mockImplementation(() => {});
+
+    const { result, rerender } = renderHook((state) => useSmooth(state, true), {
+      initialProps: runningState(""),
+    });
+
+    rerender(runningState("hello"));
+    rerender(textState("hello"));
+
+    expect(result.current.text).toBe("hello");
+    expect(result.current.status.type).toBe("complete");
+  });
+
+  it("keeps draining after the source settles when frames are flowing", () => {
+    const raf: FrameRequestCallback[] = [];
+    vi.spyOn(globalThis, "requestAnimationFrame").mockImplementation((cb) => {
+      raf.push(cb);
+      return raf.length;
+    });
+    vi.spyOn(globalThis, "cancelAnimationFrame").mockImplementation(() => {});
+    let now = 1000;
+    vi.spyOn(Date, "now").mockImplementation(() => now);
+
+    const frame = () => {
+      if (raf.length === 0) return;
+      const cb = raf.shift()!;
+      now += 16;
+      act(() => {
+        cb(now);
+      });
+    };
+
+    const { result, rerender } = renderHook(
+      (state) =>
+        useSmooth(state, {
+          maxCharsPerFrame: 1,
+          maxCharIntervalMs: 1,
+          drainMs: 250,
+        }),
+      { initialProps: runningState("hello") },
+    );
+
+    frame();
+    const mid = result.current.text;
+    expect(mid.length).toBeGreaterThan(0);
+    expect(mid.length).toBeLessThan("hello".length);
+    expect(result.current.status.type).toBe("running");
+
+    rerender(textState("hello"));
+    expect(result.current.text).toBe(mid);
+    expect(result.current.status.type).toBe("running");
+
+    frame();
+    expect(result.current.text.length).toBeGreaterThan(mid.length);
+
+    let guard = 0;
+    while (result.current.text !== "hello" && guard < 20) {
+      guard++;
+      frame();
+    }
+    expect(result.current.text).toBe("hello");
+    expect(result.current.status.type).toBe("complete");
+  });
+
+  it("snaps when a settled part replaces the text instead of looping the animator", () => {
+    const raf: FrameRequestCallback[] = [];
+    vi.spyOn(globalThis, "requestAnimationFrame").mockImplementation((cb) => {
+      raf.push(cb);
+      return raf.length;
+    });
+    vi.spyOn(globalThis, "cancelAnimationFrame").mockImplementation(() => {});
+    let now = 1000;
+    vi.spyOn(Date, "now").mockImplementation(() => now);
+
+    const frame = () => {
+      if (raf.length === 0) return;
+      const cb = raf.shift()!;
+      now += 16;
+      act(() => {
+        cb(now);
+      });
+    };
+
+    const { result, rerender } = renderHook(
+      (state) =>
+        useSmooth(state, {
+          maxCharsPerFrame: 1,
+          maxCharIntervalMs: 1,
+          drainMs: 250,
+        }),
+      { initialProps: runningState("hello world") },
+    );
+
+    frame();
+    expect(result.current.text.length).toBeGreaterThan(0);
+    const queued = raf.length;
+
+    rerender(textState("hi"));
+    expect(result.current.text).toBe("hi");
+    expect(result.current.status.type).toBe("complete");
+    expect(raf.length).toBeLessThanOrEqual(queued);
+
+    const after = raf.length;
+    frame();
+    expect(result.current.text).toBe("hi");
+    expect(raf.length).toBeLessThanOrEqual(after);
+  });
 });

package/src/utils/smooth/useSmooth.ts

@@ -137,6 +137,9 @@ const positiveOr = (value: number | undefined, fallback: number): number =>
  * `true` uses the default rate, and a {@link SmoothOptions} object tunes
  * the reveal. Returns the part state with `text` replaced by the revealed
  * prefix and `status` reporting `running` until the reveal catches up.
+ * If the source settles before any character has been revealed, the text
+ * is committed immediately so a missed animation frame cannot leave an
+ * empty bubble.
  *
  * The reveal auto-disables under `prefers-reduced-motion: reduce`,
  * committing the full text immediately; this takes precedence over an
@@ -229,13 +232,10 @@ export const useSmooth = (
       return;
     }
 
-    // Discontinuity: part flipped, or new text breaks continuation
-    // of the animator's current target. Either case requires
-    // resetting the cursor — without the part check, a new part
-    // whose text happens to share a prefix with the previous target
-    // would keep the stale cursor and flicker.
     const partChanged = animatorPartRef.current !== part;
     animatorPartRef.current = part;
+    // A new part whose text shares a prefix with the previous target would
+    // keep the stale cursor and flicker without this reset.
     if (partChanged || !text.startsWith(animatorRef.targetText)) {
       if (state.status.type === "running") {
         animatorRef.currentText = "";
@@ -246,13 +246,27 @@ export const useSmooth = (
         animatorRef.currentText = text;
         animatorRef.targetText = text;
         animatorRef.stop();
+        setText(text);
       }
       return;
     }
 
     animatorRef.targetText = text;
+    if (state.status.type !== "running") {
+      // No character has painted. A pending frame that never runs would
+      // leave an empty bubble after settle.
+      if (animatorRef.currentText === "") {
+        animatorRef.currentText = text;
+        animatorRef.stop();
+        setText(text);
+        return;
+      }
+      animatorRef.start();
+      return;
+    }
+
     animatorRef.start();
-  }, [animatorRef, enabled, text, state.status.type, part]);
+  }, [animatorRef, enabled, text, state.status.type, part, setText]);
 
   useEffect(() => {
     return () => {

package/dist/context/react/utils/ensureBinding.d.ts

@@ -1,5 +0,0 @@
-//#region src/context/react/utils/ensureBinding.d.ts
-declare const ensureBinding: (r: unknown) => void;
-//#endregion
-export { ensureBinding };
-//# sourceMappingURL=ensureBinding.d.ts.map

package/dist/context/react/utils/ensureBinding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ensureBinding.d.ts","names":[],"sources":["../../../../src/context/react/utils/ensureBinding.ts"],"mappings":";cAmCa,gBAAiB"}

package/dist/context/react/utils/ensureBinding.js

@@ -1,24 +0,0 @@
-//#region src/context/react/utils/ensureBinding.ts
-const debugVerifyPrototype = (runtime, prototype) => {
-	const unboundMethods = Object.getOwnPropertyNames(prototype).filter((methodStr) => {
-		const descriptor = Object.getOwnPropertyDescriptor(prototype, methodStr);
-		const isMethod = descriptor && typeof descriptor.value === "function";
-		if (!isMethod) return false;
-		const methodName = methodStr;
-		return isMethod && !methodName.startsWith("_") && methodName !== "constructor" && prototype[methodName] === runtime[methodName];
-	});
-	if (unboundMethods.length > 0) throw new Error(`The following methods are not bound: ${JSON.stringify(unboundMethods)}`);
-	const prototypePrototype = Object.getPrototypeOf(prototype);
-	if (prototypePrototype && prototypePrototype !== Object.prototype) debugVerifyPrototype(runtime, prototypePrototype);
-};
-const ensureBinding = (r) => {
-	const runtime = r;
-	if (runtime.__isBound) return;
-	runtime.__internal_bindMethods?.();
-	runtime.__isBound = true;
-	if (process.env.NODE_ENV !== "production") debugVerifyPrototype(runtime, Object.getPrototypeOf(runtime));
-};
-//#endregion
-export { ensureBinding };
-
-//# sourceMappingURL=ensureBinding.js.map

package/dist/context/react/utils/ensureBinding.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ensureBinding.js","names":["Bindable","__internal_bindMethods","__isBound","debugVerifyPrototype","runtime","Record","prototype","unboundMethods","Object","getOwnPropertyNames","filter","methodStr","descriptor","getOwnPropertyDescriptor","isMethod","value","methodName","startsWith","length","Error","JSON","stringify","prototypePrototype","getPrototypeOf","ensureBinding","r","process","env","NODE_ENV"],"sources":["../../../../src/context/react/utils/ensureBinding.ts"],"sourcesContent":["type Bindable = {\n  __internal_bindMethods?: () => void;\n  __isBound?: boolean;\n};\nconst debugVerifyPrototype = (\n  runtime: Record<string, unknown>,\n  prototype: any,\n) => {\n  const unboundMethods = Object.getOwnPropertyNames(prototype).filter(\n    (methodStr) => {\n      const descriptor = Object.getOwnPropertyDescriptor(prototype, methodStr);\n      const isMethod = descriptor && typeof descriptor.value === \"function\";\n      if (!isMethod) return false;\n\n      const methodName = methodStr as keyof typeof runtime | \"constructor\";\n      return (\n        isMethod &&\n        !methodName.startsWith(\"_\") &&\n        methodName !== \"constructor\" &&\n        prototype[methodName] === runtime[methodName]\n      );\n    },\n  );\n\n  if (unboundMethods.length > 0) {\n    throw new Error(\n      `The following methods are not bound: ${JSON.stringify(unboundMethods)}`,\n    );\n  }\n\n  const prototypePrototype = Object.getPrototypeOf(prototype);\n  if (prototypePrototype && prototypePrototype !== Object.prototype) {\n    debugVerifyPrototype(runtime, prototypePrototype);\n  }\n};\nexport const ensureBinding = (r: unknown) => {\n  const runtime = r as Bindable;\n  if (runtime.__isBound) return;\n\n  runtime.__internal_bindMethods?.();\n  runtime.__isBound = true;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    debugVerifyPrototype(runtime, Object.getPrototypeOf(runtime));\n  }\n};\n"],"mappings":";AAIA,MAAMG,wBACJC,SACAE,cACG;CACH,MAAMC,iBAAiBC,OAAOC,oBAAoBH,SAAS,CAAC,CAACI,QAC1DC,cAAc;EACb,MAAMC,aAAaJ,OAAOK,yBAAyBP,WAAWK,SAAS;EACvE,MAAMG,WAAWF,cAAc,OAAOA,WAAWG,UAAU;EAC3D,IAAI,CAACD,UAAU,OAAO;EAEtB,MAAME,aAAaL;EACnB,OACEG,YACA,CAACE,WAAWC,WAAW,GAAG,KAC1BD,eAAe,iBACfV,UAAUU,gBAAgBZ,QAAQY;CAEtC,CACF;CAEA,IAAIT,eAAeW,SAAS,GAC1B,MAAM,IAAIC,MACR,wCAAwCC,KAAKC,UAAUd,cAAc,GACvE;CAGF,MAAMe,qBAAqBd,OAAOe,eAAejB,SAAS;CAC1D,IAAIgB,sBAAsBA,uBAAuBd,OAAOF,WACtDH,qBAAqBC,SAASkB,kBAAkB;AAEpD;AACA,MAAaE,iBAAiBC,MAAe;CAC3C,MAAMrB,UAAUqB;CAChB,IAAIrB,QAAQF,WAAW;CAEvBE,QAAQH,yBAAyB;CACjCG,QAAQF,YAAY;CAEpB,IAAIwB,QAAQC,IAAIC,aAAa,cAC3BzB,qBAAqBC,SAASI,OAAOe,eAAenB,OAAO,CAAC;AAEhE"}

package/dist/context/react/utils/useRuntimeState.d.ts

@@ -1,13 +0,0 @@
-import { Unsubscribe } from "@assistant-ui/core";
-//#region src/context/react/utils/useRuntimeState.d.ts
-type SubscribableRuntime<TState> = {
-  getState: () => TState;
-  subscribe: (callback: () => void) => Unsubscribe;
-};
-declare function useRuntimeStateInternal<TState, TSelected>(runtime: SubscribableRuntime<TState>, selector?: ((state: TState) => TSelected | TState) | undefined): TSelected | TState;
-declare function useRuntimeState<TState>(runtime: SubscribableRuntime<TState>): TState;
-declare function useRuntimeState<TState, TSelected>(runtime: SubscribableRuntime<TState>, selector: (state: TState) => TSelected): TSelected;
-declare function useRuntimeState<TState, TSelected>(runtime: SubscribableRuntime<TState>, selector: ((state: TState) => TSelected) | undefined): TSelected | TState;
-//#endregion
-export { SubscribableRuntime, useRuntimeState, useRuntimeStateInternal };
-//# sourceMappingURL=useRuntimeState.d.ts.map

package/dist/context/react/utils/useRuntimeState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRuntimeState.d.ts","names":[],"sources":["../../../../src/context/react/utils/useRuntimeState.ts"],"mappings":";;KAIY,oBAAoB;EAC9B,gBAAgB;EAChB,YAAY,yBAAyB;;iBAGvB,wBAAwB,QAAQ,WAC9C,SAAS,oBAAoB,SAC7B,aAAY,OAAO,WAAW,YAAY,sBACzC,YAAY;iBAcC,gBAAgB,QAC9B,SAAS,oBAAoB,UAC5B;iBACa,gBAAgB,QAAQ,WACtC,SAAS,oBAAoB,SAC7B,WAAW,OAAO,WAAW,YAC5B;iBACa,gBAAgB,QAAQ,WACtC,SAAS,oBAAoB,SAC7B,YAAY,OAAO,WAAW,yBAC7B,YAAY"}

package/dist/context/react/utils/useRuntimeState.js

@@ -1,33 +0,0 @@
-import { ensureBinding } from "./ensureBinding.js";
-import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-import { useDebugValue, useSyncExternalStore } from "@assistant-ui/tap/react-shim";
-//#region src/context/react/utils/useRuntimeState.ts
-function useRuntimeStateInternal(runtime, t0) {
-	const $ = c(4);
-	const selector = t0 === void 0 ? identity : t0;
-	ensureBinding(runtime);
-	let t1;
-	let t2;
-	if ($[0] !== runtime || $[1] !== selector) {
-		t1 = () => selector(runtime.getState());
-		t2 = () => selector(runtime.getState());
-		$[0] = runtime;
-		$[1] = selector;
-		$[2] = t1;
-		$[3] = t2;
-	} else {
-		t1 = $[2];
-		t2 = $[3];
-	}
-	const slice = useSyncExternalStore(runtime.subscribe, t1, t2);
-	useDebugValue(slice);
-	return slice;
-}
-const identity = (arg) => arg;
-function useRuntimeState(runtime, selector) {
-	return useRuntimeStateInternal(runtime, selector);
-}
-//#endregion
-export { useRuntimeState, useRuntimeStateInternal };
-
-//# sourceMappingURL=useRuntimeState.js.map

package/dist/context/react/utils/useRuntimeState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRuntimeState.js","names":["Unsubscribe","useDebugValue","useSyncExternalStore","ensureBinding","SubscribableRuntime","getState","TState","subscribe","callback","useRuntimeStateInternal","runtime","t0","$","_c","selector","undefined","identity","t1","t2","slice","arg","T","useRuntimeState","state","TSelected"],"sources":["../../../../src/context/react/utils/useRuntimeState.ts"],"sourcesContent":["import type { Unsubscribe } from \"@assistant-ui/core\";\nimport { useDebugValue, useSyncExternalStore } from \"react\";\nimport { ensureBinding } from \"./ensureBinding\";\n\nexport type SubscribableRuntime<TState> = {\n  getState: () => TState;\n  subscribe: (callback: () => void) => Unsubscribe;\n};\n\nexport function useRuntimeStateInternal<TState, TSelected>(\n  runtime: SubscribableRuntime<TState>,\n  selector: ((state: TState) => TSelected | TState) | undefined = identity,\n): TSelected | TState {\n  // TODO move to useRuntimeState\n  ensureBinding(runtime);\n\n  const slice = useSyncExternalStore(\n    runtime.subscribe,\n    () => selector(runtime.getState()),\n    () => selector(runtime.getState()),\n  );\n  useDebugValue(slice);\n  return slice;\n}\n\nconst identity = <T>(arg: T): T => arg;\nexport function useRuntimeState<TState>(\n  runtime: SubscribableRuntime<TState>,\n): TState;\nexport function useRuntimeState<TState, TSelected>(\n  runtime: SubscribableRuntime<TState>,\n  selector: (state: TState) => TSelected,\n): TSelected;\nexport function useRuntimeState<TState, TSelected>(\n  runtime: SubscribableRuntime<TState>,\n  selector: ((state: TState) => TSelected) | undefined,\n): TSelected | TState;\nexport function useRuntimeState<TState, TSelected>(\n  runtime: SubscribableRuntime<TState>,\n  selector?: ((state: TState) => TSelected) | undefined,\n): TSelected | TState {\n  // ensure that the runtime is bound\n  // ensureBinding(runtime);\n\n  return useRuntimeStateInternal(runtime, selector);\n}\n"],"mappings":";;;;AASA,SAAOS,wBAAAC,SAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAEL,MAAAC,WAAAH,OAAAI,KAAAA,IAAAC,WAAAL;CAGAR,cAAcO,OAAO;CAAC,IAAAO;CAAA,IAAAC;CAAA,IAAAN,EAAA,OAAAF,WAAAE,EAAA,OAAAE,UAAA;EAIpBG,WAAMH,SAASJ,QAAOL,SAAU,CAAC;EACjCa,WAAMJ,SAASJ,QAAOL,SAAU,CAAC;EAACO,EAAA,KAAAF;EAAAE,EAAA,KAAAE;EAAAF,EAAA,KAAAK;EAAAL,EAAA,KAAAM;CAAA,OAAA;EAAAD,KAAAL,EAAA;EAAAM,KAAAN,EAAA;CAAA;CAHpC,MAAAO,QAAcjB,qBACZQ,QAAOH,WACPU,IACAC,EACF;CACAjB,cAAckB,KAAK;CAAC,OACbA;AAAK;AAGd,MAAMH,YAAeI,QAAcA;AAYnC,SAAOE,gBAAAZ,SAAAI,UAAA;CAAA,OAOEL,wBAAwBC,SAASI,QAAQ;AAAC"}