basalt-ui 1.41.0 → 2.0.1

package/dist/agent/adapter.js

@@ -1,482 +0,0 @@
-import { useEffect, useSyncExternalStore } from "react";
-import { mintThreadId } from "./id.js";
-function createAdapterThreadsStore(adapter, opts) {
-  const revalidateOnFocus = opts?.revalidateOnFocus ?? false;
-  const EMPTY = [];
-  const SERVER_SNAPSHOT = {
-    threads: EMPTY,
-    activeId: null,
-    hydrated: false,
-    error: void 0
-  };
-  let base = EMPTY;
-  let baseSeq = 0;
-  let activeId = null;
-  let hydrated = false;
-  let error;
-  let errorToken = 0;
-  let errorFromWrite = false;
-  const pending = [];
-  let snapshot = SERVER_SNAPSHOT;
-  const listeners = /* @__PURE__ */ new Set();
-  function recompute() {
-    let threads = base;
-    let active = activeId;
-    for (const patch of pending) {
-      threads = patch.apply(threads);
-      if (patch.applyActive !== void 0) active = patch.applyActive(active);
-    }
-    snapshot = { threads, activeId: active, hydrated, error };
-    for (const listener of listeners) listener();
-  }
-  function memoizeApply(apply) {
-    let lastIn;
-    let lastOut;
-    return (threads) => {
-      if (lastOut !== void 0 && threads === lastIn) return lastOut;
-      lastIn = threads;
-      lastOut = apply(threads);
-      return lastOut;
-    };
-  }
-  function subscribe(listener) {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  }
-  function getSnapshot() {
-    return snapshot;
-  }
-  function getServerSnapshot() {
-    return SERVER_SNAPSHOT;
-  }
-  let loadController = null;
-  let loadSeq = 0;
-  let queuedSeq = null;
-  function prune() {
-    const kept = [];
-    for (const patch of pending) {
-      if (patch.confirmSeq !== null && patch.confirmSeq <= baseSeq) {
-        if (patch.applyActive !== void 0) activeId = patch.applyActive(activeId);
-        continue;
-      }
-      kept.push(patch);
-    }
-    if (kept.length !== pending.length) pending.splice(0, pending.length, ...kept);
-  }
-  function startLoad(seq) {
-    const controller = new AbortController();
-    loadController = controller;
-    void (async () => {
-      try {
-        const next = await adapter.listThreads(controller.signal);
-        if (loadController !== controller) return;
-        base = [...next];
-        baseSeq = seq;
-        hydrated = true;
-        if (!errorFromWrite) error = void 0;
-        prune();
-        recompute();
-      } catch (cause) {
-        if (controller.signal.aborted || loadController !== controller) return;
-        error = cause;
-        errorToken += 1;
-        errorFromWrite = false;
-        recompute();
-      } finally {
-        if (loadController === controller) {
-          loadController = null;
-          if (queuedSeq !== null) {
-            const next = queuedSeq;
-            queuedSeq = null;
-            startLoad(next);
-          }
-        }
-      }
-    })();
-  }
-  function revalidate() {
-    if (loadController !== null) {
-      queuedSeq ??= ++loadSeq;
-      return queuedSeq;
-    }
-    const seq = ++loadSeq;
-    startLoad(seq);
-    return seq;
-  }
-  function forceRevalidate() {
-    loadController?.abort();
-    queuedSeq = null;
-    const seq = ++loadSeq;
-    startLoad(seq);
-    return seq;
-  }
-  const chains = /* @__PURE__ */ new Map();
-  const failedCreateIds = /* @__PURE__ */ new Set();
-  function enqueue(threadIds, task) {
-    const ids = [...new Set(threadIds)];
-    const prior = ids.map((id) => chains.get(id)).filter((p) => p !== void 0);
-    const after = prior.length === 0 ? Promise.resolve() : Promise.all(prior).then(() => void 0);
-    const run = after.then(task);
-    for (const id of ids) chains.set(id, run);
-    void run.finally(() => {
-      for (const id of ids) if (chains.get(id) === run) chains.delete(id);
-    });
-  }
-  function drop(patch) {
-    const index = pending.indexOf(patch);
-    if (index !== -1) pending.splice(index, 1);
-  }
-  function mutate(i) {
-    const patch = {
-      apply: memoizeApply(i.apply),
-      ...i.applyActive !== void 0 ? { applyActive: i.applyActive } : {},
-      confirmSeq: null
-    };
-    pending.push(patch);
-    const tokenAtIssue = errorToken;
-    recompute();
-    enqueue(i.threadIds, async () => {
-      const [soleThreadId] = i.threadIds;
-      if (!i.isCreate && i.threadIds.length === 1 && soleThreadId !== void 0 && failedCreateIds.has(soleThreadId)) {
-        drop(patch);
-        recompute();
-        return;
-      }
-      try {
-        await i.commit();
-      } catch (cause) {
-        if (i.isCreate) for (const threadId of i.threadIds) failedCreateIds.add(threadId);
-        drop(patch);
-        error = cause;
-        errorToken += 1;
-        errorFromWrite = true;
-        recompute();
-        revalidate();
-        return;
-      }
-      if (errorFromWrite && errorToken === tokenAtIssue) {
-        error = void 0;
-        errorFromWrite = false;
-        recompute();
-      }
-      patch.confirmSeq = revalidate();
-    });
-  }
-  function patchThread(id, update) {
-    return (threads) => threads.map((thread) => thread.id === id ? update(thread) : thread);
-  }
-  let mounted = 0;
-  function onFocus() {
-    forceRevalidate();
-  }
-  function retain() {
-    mounted += 1;
-    if (mounted !== 1) return;
-    revalidate();
-    if (revalidateOnFocus && typeof window !== "undefined") {
-      window.addEventListener("focus", onFocus);
-    }
-  }
-  function release() {
-    mounted -= 1;
-    if (mounted !== 0) return;
-    loadController?.abort();
-    loadController = null;
-    queuedSeq = null;
-    if (revalidateOnFocus && typeof window !== "undefined") {
-      window.removeEventListener("focus", onFocus);
-    }
-  }
-  function select(id) {
-    activeId = id;
-    recompute();
-  }
-  function create(createOpts) {
-    const id = mintThreadId();
-    const now = Date.now();
-    const thread = {
-      id,
-      messages: [],
-      outcome: null,
-      status: "pending",
-      read: false,
-      createdAt: now,
-      updatedAt: now,
-      ...createOpts?.meta !== void 0 ? { meta: createOpts.meta } : {}
-    };
-    mutate({
-      threadIds: [id],
-      apply: (threads) => threads.some((t) => t.id === id) ? [...threads] : [thread, ...threads],
-      isCreate: true,
-      commit: () => adapter.createThread({
-        id,
-        ...createOpts?.meta !== void 0 ? { meta: createOpts.meta } : {}
-      })
-    });
-    return id;
-  }
-  function appendMessage(id, message2) {
-    const now = Date.now();
-    mutate({
-      threadIds: [id],
-      apply: patchThread(
-        id,
-        (thread) => thread.messages.some((m) => m.id === message2.id) ? thread : { ...thread, messages: [...thread.messages, message2], updatedAt: now }
-      ),
-      commit: () => adapter.appendMessage({ threadId: id, message: message2 })
-    });
-  }
-  function setOutcome(id, outcome) {
-    const now = Date.now();
-    mutate({
-      threadIds: [id],
-      apply: patchThread(id, (thread) => ({ ...thread, outcome, updatedAt: now })),
-      commit: () => adapter.setOutcome({ threadId: id, outcome })
-    });
-  }
-  function setStatus(id, status) {
-    const now = Date.now();
-    mutate({
-      threadIds: [id],
-      apply: patchThread(id, (thread) => ({ ...thread, status, updatedAt: now })),
-      commit: () => adapter.setStatus({ threadId: id, status })
-    });
-  }
-  function setResumeToken(id, token) {
-    const now = Date.now();
-    mutate({
-      threadIds: [id],
-      apply: patchThread(id, (thread) => {
-        const { resumeToken: _resumeToken, ...rest } = thread;
-        return {
-          ...rest,
-          ...token !== void 0 ? { resumeToken: token } : {},
-          updatedAt: now
-        };
-      }),
-      commit: () => adapter.setResumeToken({ threadId: id, token })
-    });
-  }
-  function markRead(id) {
-    mutate({
-      threadIds: [id],
-      // Identity-preserving when the server already agrees — markRead does not bump updatedAt.
-      apply: patchThread(id, (thread) => thread.read ? thread : { ...thread, read: true }),
-      commit: () => adapter.markRead(id)
-    });
-  }
-  function remove(id) {
-    mutate({
-      threadIds: [id],
-      apply: (threads) => threads.filter((thread) => thread.id !== id),
-      // Inside the patch, so a rejected delete restores the SELECTION along with the row. Written
-      // as a conditional clear rather than a flat `null` so a `select()` issued while the delete
-      // is in flight survives the patch being re-applied on top of it.
-      applyActive: (active) => active === id ? null : active,
-      commit: () => adapter.removeThread(id)
-    });
-  }
-  function clear() {
-    const ids = snapshot.threads.map((thread) => thread.id);
-    const clearedIds = new Set(ids);
-    mutate({
-      threadIds: ids,
-      apply: () => [],
-      // Same idiom as remove(): only null a selection pointing at one of the threads THIS clear
-      // captured, so a select() issued while the clear is in flight — e.g. into a thread created
-      // concurrently by create() — survives the patch being re-applied on top of it.
-      applyActive: (active) => active !== null && clearedIds.has(active) ? null : active,
-      commit: async () => {
-        const results = await Promise.allSettled(ids.map((id) => adapter.removeThread(id)));
-        const failures = results.filter((r) => r.status === "rejected");
-        if (failures.length === 0) return;
-        throw new AggregateError(
-          failures.map((f) => f.reason),
-          `removeThread rejected for ${failures.length} of ${ids.length} threads`
-        );
-      }
-    });
-  }
-  return function useAdapterThreadsStore() {
-    const current = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    useEffect(() => {
-      retain();
-      return () => {
-        release();
-      };
-    }, []);
-    return {
-      threads: current.threads,
-      activeId: current.activeId,
-      hydrated: current.hydrated,
-      error: current.error,
-      select,
-      create,
-      appendMessage,
-      setOutcome,
-      setStatus,
-      setResumeToken,
-      markRead,
-      remove,
-      clear
-    };
-  };
-}
-function assert(condition, message2) {
-  if (!condition) throw new Error(`ThreadsStoreAdapter contract: ${message2}`);
-}
-function message(id) {
-  return { id, role: "user", parts: [], createdAt: Date.now() };
-}
-function threadsStoreAdapterContract(makeAdapter) {
-  function define(name, run) {
-    return {
-      name,
-      run: async () => {
-        await run(await makeAdapter());
-      }
-    };
-  }
-  async function loadOrThrow(adapter, id) {
-    const thread = await adapter.loadThread(id);
-    assert(thread !== null, `loadThread('${id}') returned null for a thread that was created`);
-    return thread;
-  }
-  return [
-    define("createThread then listThreads returns the thread with empty defaults", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      const threads = await a.listThreads();
-      const found = threads.filter((t) => t.id === id);
-      assert(found.length === 1, `listThreads returned ${found.length} threads for one create`);
-      const thread = found[0];
-      assert(thread !== void 0, "listThreads entry was undefined");
-      assert(thread.messages.length === 0, "a new thread must start with no messages");
-      assert(thread.outcome === null, "a new thread's outcome must be null");
-      assert(thread.status === "pending", `a new thread's status must be 'pending'`);
-      assert(thread.read === false, "a new thread must be unread");
-      assert(typeof thread.createdAt === "number", "createdAt must be a number");
-      assert(typeof thread.updatedAt === "number", "updatedAt must be a number");
-    }),
-    define("createThread persists meta", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id, meta: { source: "contract" } });
-      const thread = await loadOrThrow(a, id);
-      assert(thread.meta?.["source"] === "contract", "meta did not round-trip");
-    }),
-    define("loadThread returns null for an unknown id", async (a) => {
-      const thread = await a.loadThread(mintThreadId());
-      assert(thread === null, "loadThread must return null (not throw, not undefined) when absent");
-    }),
-    define("appendMessage is idempotent on message.id", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      const msg = message("contract-msg-1");
-      await a.appendMessage({ threadId: id, message: msg });
-      await a.appendMessage({ threadId: id, message: msg });
-      const thread = await loadOrThrow(a, id);
-      assert(
-        thread.messages.length === 1,
-        `appending the same message.id twice produced ${thread.messages.length} rows \u2014 the id is the only idempotency key`
-      );
-      assert(thread.messages[0]?.id === "contract-msg-1", "the retained message has the wrong id");
-    }),
-    define("appendMessage preserves order for distinct ids", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      await a.appendMessage({ threadId: id, message: message("contract-msg-1") });
-      await a.appendMessage({ threadId: id, message: message("contract-msg-2") });
-      const thread = await loadOrThrow(a, id);
-      assert(
-        thread.messages.map((m) => m.id).join(",") === "contract-msg-1,contract-msg-2",
-        "messages must read back oldest-first in append order"
-      );
-    }),
-    define("setStatus round-trips", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      await a.setStatus({ threadId: id, status: "streaming" });
-      assert((await loadOrThrow(a, id)).status === "streaming", "status did not become 'streaming'");
-      await a.setStatus({ threadId: id, status: "error" });
-      assert((await loadOrThrow(a, id)).status === "error", "status did not become 'error'");
-    }),
-    define("setOutcome round-trips", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      const outcome = { title: "Title", summary: "Summary", status: "done" };
-      await a.setOutcome({ threadId: id, outcome });
-      const thread = await loadOrThrow(a, id);
-      assert(thread.outcome?.title === "Title", "outcome.title did not round-trip");
-      assert(thread.outcome?.summary === "Summary", "outcome.summary did not round-trip");
-      assert(thread.outcome?.status === "done", "outcome.status did not round-trip");
-    }),
-    define("setResumeToken round-trips and clears with undefined", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      await a.setResumeToken({ threadId: id, token: "tok-1" });
-      assert((await loadOrThrow(a, id)).resumeToken === "tok-1", "resumeToken did not round-trip");
-      await a.setResumeToken({ threadId: id, token: void 0 });
-      assert(
-        (await loadOrThrow(a, id)).resumeToken === void 0,
-        "setResumeToken(undefined) must CLEAR the token"
-      );
-    }),
-    define("markRead marks the thread read", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      assert((await loadOrThrow(a, id)).read === false, "a new thread must start unread");
-      await a.markRead(id);
-      assert((await loadOrThrow(a, id)).read === true, "markRead did not set read");
-    }),
-    define("listThreads reflects a write that has already resolved", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      await a.appendMessage({ threadId: id, message: message("contract-msg-raw") });
-      await a.setStatus({ threadId: id, status: "streaming" });
-      const found = (await a.listThreads()).find((t) => t.id === id);
-      assert(found !== void 0, "listThreads omitted a thread created before the call");
-      assert(
-        found.status === "streaming",
-        "listThreads returned a STALE status \u2014 a list started after a write resolves must reflect it"
-      );
-      assert(
-        found.messages.length === 1,
-        `listThreads returned a STALE message list (${found.messages.length} rows) \u2014 a list started after a write resolves must reflect it`
-      );
-    }),
-    define(
-      "dependent writes issued straight after createThread resolves are honoured",
-      async (a) => {
-        const id = mintThreadId();
-        await a.createThread({ id });
-        await a.markRead(id);
-        await a.appendMessage({ threadId: id, message: message("contract-msg-dep") });
-        await a.setStatus({ threadId: id, status: "streaming" });
-        const thread = await loadOrThrow(a, id);
-        assert(thread.read === true, "markRead did not apply to a just-created thread");
-        assert(
-          thread.messages.length === 1,
-          `appendMessage did not apply to a just-created thread (${thread.messages.length} rows)`
-        );
-        assert(thread.status === "streaming", "setStatus did not apply to a just-created thread");
-      }
-    ),
-    define("removeThread removes the thread", async (a) => {
-      const id = mintThreadId();
-      await a.createThread({ id });
-      await a.removeThread(id);
-      assert(await a.loadThread(id).then((t) => t === null), "loadThread must be null after remove");
-      const threads = await a.listThreads();
-      assert(!threads.some((t) => t.id === id), "listThreads still contains the removed thread");
-    }),
-    define("removeThread of an unknown id does not throw", async (a) => {
-      await a.removeThread(mintThreadId());
-    })
-  ];
-}
-export {
-  createAdapterThreadsStore,
-  threadsStoreAdapterContract
-};

package/dist/agent/use-agent-stream.d.ts

@@ -1,35 +0,0 @@
-import type { PartLike } from './merge.js';
-import type { AgentPart } from './parts.js';
-import type { AgentTransport } from './transport.js';
-/** The lifecycle state of the current stream. */
-export type StreamStatus = 'idle' | 'streaming' | 'done' | 'error';
-export type UseAgentStreamReturn<TPart, TInput> = {
-    /** Accumulated parts from the current (or last completed) stream. */
-    readonly parts: TPart[];
-    /** Current lifecycle status. */
-    readonly status: StreamStatus;
-    /** The error thrown during the last failed stream, or undefined. */
-    readonly error: unknown;
-    /**
-     * Start a new stream for the given input. Resets parts and status, aborts any in-flight stream,
-     * and accumulates new parts as they arrive.
-     */
-    readonly send: (input: TInput) => Promise<void>;
-    /** Abort the in-flight stream (no-op when idle or done). */
-    readonly stop: () => void;
-    /** Re-run the last input. No-op if no input has been sent yet. */
-    readonly regenerate: () => Promise<void>;
-};
-/**
- * Manages a single streaming agent turn over an injected {@link AgentTransport}.
- *
- * @example
- * const { parts, status, send, stop } = useAgentStream({ transport: myTransport })
- * await send('What is the capital of France?')
- * // parts accumulates as the stream arrives
- * // status: 'idle' → 'streaming' → 'done' (or 'error')
- */
-export declare function useAgentStream<TPart extends PartLike = AgentPart, TInput = string>({ transport, }: {
-    transport: AgentTransport<TPart, TInput>;
-}): UseAgentStreamReturn<TPart, TInput>;
-//# sourceMappingURL=use-agent-stream.d.ts.map

package/dist/agent/use-agent-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-agent-stream.d.ts","sourceRoot":"","sources":["../../src/agent/use-agent-stream.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAIjD,iDAAiD;AACjD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,OAAO,CAAA;AAIlE,MAAM,MAAM,oBAAoB,CAAC,KAAK,EAAE,MAAM,IAAI;IAChD,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;IACvB,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/C,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAA;IACzB,kEAAkE;IAClE,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC,CAAA;AAID;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,QAAQ,GAAG,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAClF,SAAS,GACV,EAAE;IACD,SAAS,EAAE,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CACzC,GAAG,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,CA6EtC"}

package/dist/agent/use-agent-stream.js

@@ -1,59 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { mintThreadId, withPartIds } from "./id.js";
-import { isStartPart } from "./parts.js";
-import { mergePart } from "./merge.js";
-function useAgentStream({
-  transport
-}) {
-  const [parts, setParts] = useState([]);
-  const [status, setStatus] = useState("idle");
-  const [error, setError] = useState(void 0);
-  const controllerRef = useRef(null);
-  const lastInputRef = useRef(void 0);
-  useEffect(
-    () => () => {
-      controllerRef.current?.abort();
-    },
-    []
-  );
-  const send = useCallback(
-    async (input) => {
-      controllerRef.current?.abort();
-      const controller = new AbortController();
-      controllerRef.current = controller;
-      lastInputRef.current = input;
-      setParts([]);
-      setError(void 0);
-      setStatus("streaming");
-      const runId = mintThreadId();
-      try {
-        for await (const part of withPartIds(runId, transport.stream(input, controller.signal))) {
-          if (controllerRef.current !== controller) return;
-          if (controller.signal.aborted) break;
-          if (isStartPart(part)) continue;
-          setParts((prev) => mergePart(prev, part));
-        }
-        if (controllerRef.current === controller && !controller.signal.aborted) setStatus("done");
-      } catch (err) {
-        if (err instanceof Error && err.name === "AbortError") return;
-        if (controllerRef.current !== controller) return;
-        if (controller.signal.aborted) return;
-        setError(err);
-        setStatus("error");
-      }
-    },
-    [transport]
-  );
-  const stop = useCallback(() => {
-    controllerRef.current?.abort();
-    setStatus("done");
-  }, []);
-  const regenerate = useCallback(async () => {
-    if (lastInputRef.current === void 0) return;
-    await send(lastInputRef.current);
-  }, [send]);
-  return { parts, status, error, send, stop, regenerate };
-}
-export {
-  useAgentStream
-};

package/dist/agent-chat/composer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"composer.d.ts","sourceRoot":"","sources":["../../src/agent-chat/composer.tsx"],"names":[],"mappings":"AAuCA,OAAO,KAAK,EAAE,cAAc,EAAkB,GAAG,EAAiB,SAAS,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAG/F,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAmJnE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,SAAS,kBAAkB,EAAE,CAAA;CACpD,CAAA;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3C,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;CAC3B,CAAA;AAWD;qDACqD;AACrD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAA;AAEvD,MAAM,MAAM,aAAa,GAAG,WAAW,GACrC,eAAe,CAAC,YAAY,CAAC,GAAG;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAA;IAClC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,yCAAyC;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B,oDAAoD;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B,yCAAyC;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B,iFAAiF;IACjF,QAAQ,CAAC,yBAAyB,CAAC,EAAE,OAAO,CAAA;IAC5C,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAA;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,CAAA;IAChC,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,CAAA;IACjC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACpD;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,kBAAkB,EAAE,KAAK,IAAI,CAAA;IAC5E,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,mBAAmB,CAAC,KAAK,IAAI,CAAA;IACvE;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,sFAAsF;IACtF,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAC1B,CAAA;AAsBH;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,QAAQ,EACR,WAAW,EACX,SAAS,EACT,OAAW,EACX,QAAgB,EAChB,SAAiB,EACjB,yBAAiC,EACjC,MAAM,EACN,WAAW,EACX,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,SAAS,EACT,KAAK,EACL,UAAU,GACX,EAAE,aAAa,GAAG,GAAG,CAAC,OAAO,CA6P7B"}

package/dist/agent-chat/index.d.ts

@@ -1,31 +0,0 @@
-/**
- * Mantine-styled thread-chat components over the headless `basalt-ui/agent` layer, capped by the
- * flagship `ThreadWorkspace` composite.
- *
- * This module is Mantine-coupled by design and ships its own `basalt-ui/agent-chat` subpath
- * (also re-exported from the root entry, unchanged for existing consumers) — unlike
- * `basalt-ui/agent`, which stays headless so it can be styled by any consumer.
- *
- * @example
- * import { ThreadWorkspace } from 'basalt-ui/agent-chat'
- * import { createThreadsStore, edenTransport, heuristicOutcome } from 'basalt-ui/agent'
- */
-export { ThreadWorkspace } from './thread-workspace.js';
-export type { ThreadWorkspaceProps } from './thread-workspace.js';
-export { ThreadFeed } from './thread-feed.js';
-export type { ThreadFeedProps } from './thread-feed.js';
-export { ThreadFeedRow } from './thread-feed-row.js';
-export type { ThreadFeedRowProps } from './thread-feed-row.js';
-export type { MessageAffordances } from './message-affordances.js';
-export type { RowHeightProps, VirtualizeOptions, VirtualizeProps } from './virtualize.js';
-export { ThreadOutcomeCard } from './thread-outcome-card.js';
-export type { ThreadOutcomeCardProps } from './thread-outcome-card.js';
-export { ThreadDetailPanel } from './thread-detail-panel.js';
-export type { ThreadDetailPanelProps } from './thread-detail-panel.js';
-export { Composer } from './composer.js';
-export type { ComposerAttachment, ComposerHandle, ComposerProps, ComposerSubmit } from './composer.js';
-export { threadPartRenderers, ThreadTranscript } from './thread-message.js';
-export type { ThreadTranscriptProps } from './thread-message.js';
-export { ToolChip } from './tool-chip.js';
-export type { ToolChipProps } from './tool-chip.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/agent-chat/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-chat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAG9D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAS3D,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC/D,YAAY,EAAE,cAAc,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAGtF,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGnG,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxE,YAAY,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AAG7D,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}

package/dist/agent-chat/index.js

@@ -1,19 +0,0 @@
-import { ThreadWorkspace } from "./thread-workspace.js";
-import { ThreadFeed } from "./thread-feed.js";
-import { ThreadFeedRow } from "./thread-feed-row.js";
-import { ThreadOutcomeCard } from "./thread-outcome-card.js";
-import { ThreadDetailPanel } from "./thread-detail-panel.js";
-import { Composer } from "./composer.js";
-import { threadPartRenderers, ThreadTranscript } from "./thread-message.js";
-import { ToolChip } from "./tool-chip.js";
-export {
-  Composer,
-  ThreadDetailPanel,
-  ThreadFeed,
-  ThreadFeedRow,
-  ThreadOutcomeCard,
-  ThreadTranscript,
-  ThreadWorkspace,
-  ToolChip,
-  threadPartRenderers
-};

package/dist/agent-chat/message-affordances.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"message-affordances.d.ts","sourceRoot":"","sources":["../../src/agent-chat/message-affordances.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE3D,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM,CAAA;IACrD;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;IACvB;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IACnD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,cAAc,CAAC,CAAA;KAAE,KAAK,SAAS,CAAA;CACzF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,IAAI,CAAC,kBAAkB,EAAE,WAAW,GAAG,MAAM,CAAC,CAGxF,CAAA"}

package/dist/agent-chat/relative-time.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"relative-time.d.ts","sourceRoot":"","sources":["../../src/agent-chat/relative-time.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAgBH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAc5D"}

package/dist/agent-chat/thread-detail-panel.d.ts

@@ -1,28 +0,0 @@
-import type { JSX } from 'react';
-import type { AgentPart, AgentThread, StreamStatus } from '../agent/index.js';
-import type { BasaltProps } from '../common/props.js';
-export type ThreadDetailPanelProps = BasaltProps & {
-    /** The open thread, or null when nothing is selected (renders an empty-state hint). */
-    readonly thread: AgentThread | null;
-    /** The live (in-flight) assistant turn's parts for this thread, if a run is streaming. */
-    readonly liveParts?: AgentPart[];
-    /** The live run's status — gates the composer and shows the Stop action while streaming. */
-    readonly runStatus?: StreamStatus;
-    readonly onSend: (text: string) => void;
-    readonly onStop: () => void;
-    readonly onClose: () => void;
-    /**
-     * Replay the last user input on this thread. When provided, a "Retry" action appears in the
-     * failed-run alert; omit it to render the alert without a retry affordance.
-     */
-    readonly onRetry?: () => void;
-};
-/**
- * The detail pane for one open thread: header (title + close), transcript body in an
- * auto-scrolling container, and a footer composer (with a Stop action while streaming).
- *
- * @example
- * <ThreadDetailPanel thread={thread} runStatus={runStatus} onSend={send} onStop={stop} onClose={close} />
- */
-export declare function ThreadDetailPanel({ thread, liveParts, runStatus, onSend, onStop, onClose, onRetry, className, style, }: ThreadDetailPanelProps): JSX.Element;
-//# sourceMappingURL=thread-detail-panel.d.ts.map