@stll/chat 0.0.1-placeholder.0 → 0.1.1

package/README.md

@@ -0,0 +1,28 @@
+# `@stll/chat`
+
+Portable React chat primitives: a rich-editor composer shell, message stream,
+model selector, and observable streaming runtime.
+
+The host owns authentication, endpoint selection, persistence, provider
+credentials, translations, and rich-message rendering. It supplies a typed
+`ChatTransport`; the package never reads environment variables or silently
+selects a provider.
+
+```tsx
+import { ChatComposer, ChatMessageStream, createChatRuntime } from "@stll/chat";
+
+const runtime = createChatRuntime({ transport });
+
+<ChatComposer
+  canSend={draft.length > 0}
+  isGenerating={runtime.getSnapshot().isStreaming}
+  labels={{ retry: "Retry", send: "Send", stop: "Stop" }}
+  onSend={sendDraft}
+>
+  <RichEditor />
+</ChatComposer>;
+```
+
+Validate every explicit provider/model selection with
+`resolveChatModelSelection`. It rejects unknown, empty, duplicate, and
+unconfigured provider/model combinations with `ChatConfigurationError`.

package/dist/composer.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from "react";
+//#region src/composer.d.ts
+type ChatComposerActionState = {
+  canSend: boolean;
+  isGenerating: boolean;
+  onRetry?: (() => void) | undefined;
+  onSend: () => void;
+  onStop?: (() => void) | undefined;
+};
+type ChatComposerActionMode = "retry" | "send" | "stop";
+declare const resolveChatComposerAction: ({ isGenerating, onRetry, onStop }: Pick<ChatComposerActionState, "isGenerating" | "onRetry" | "onStop">) => ChatComposerActionMode;
+type ChatComposerLabels = Record<ChatComposerActionMode, string>;
+declare const ChatComposerAction: ({ canSend, className, isGenerating, labels, onRetry, onSend, onStop }: ChatComposerActionState & {
+  className?: string | undefined;
+  labels: ChatComposerLabels;
+}) => import("react").JSX.Element;
+type ChatComposerProps = ChatComposerActionState & {
+  children: ReactNode;
+  className?: string | undefined;
+  labels: ChatComposerLabels;
+  leading?: ReactNode | undefined;
+  status?: ReactNode | undefined;
+};
+/**
+ * Layout-only composer shell for rich editors. `children` is deliberately a
+ * host-owned editor slot, so TipTap, ProseMirror, native inputs, and mobile
+ * editors can share send/stop/retry behavior without copying shell chrome.
+ */
+declare const ChatComposer: ({ children, className, labels, leading, status, ...action }: ChatComposerProps) => import("react").JSX.Element;
+//#endregion
+export { ChatComposer, ChatComposerAction, ChatComposerActionMode, ChatComposerActionState, ChatComposerLabels, ChatComposerProps, resolveChatComposerAction };

package/dist/composer.js

@@ -0,0 +1,78 @@
+import { ArrowUpIcon, RotateCcwIcon, SquareIcon } from "lucide-react";
+import { Button } from "@stll/ui/button";
+import { cn } from "@stll/ui/utils";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/composer.tsx
+const resolveChatComposerAction = ({ isGenerating, onRetry, onStop }) => {
+	if (isGenerating && onStop !== void 0) return "stop";
+	if (!isGenerating && onRetry !== void 0) return "retry";
+	return "send";
+};
+const ChatComposerAction = ({ canSend, className, isGenerating, labels, onRetry, onSend, onStop }) => {
+	const mode = resolveChatComposerAction({
+		isGenerating,
+		onRetry,
+		onStop
+	});
+	const disabled = mode === "send" && !canSend;
+	const onClick = () => {
+		switch (mode) {
+			case "send":
+				onSend();
+				return;
+			case "stop":
+				onStop?.();
+				return;
+			case "retry":
+				onRetry?.();
+				return;
+		}
+	};
+	return /* @__PURE__ */ jsxs(Button, {
+		"aria-label": labels[mode],
+		className: cn("bg-foreground text-background hover:bg-foreground/90 size-7 shrink-0 rounded-full", className),
+		disabled,
+		onClick,
+		size: "icon-sm",
+		tooltip: false,
+		type: "button",
+		children: [
+			mode === "send" && /* @__PURE__ */ jsx(ArrowUpIcon, {
+				"aria-hidden": "true",
+				className: "size-3.5"
+			}),
+			mode === "stop" && /* @__PURE__ */ jsx(SquareIcon, {
+				"aria-hidden": "true",
+				className: "size-3.5"
+			}),
+			mode === "retry" && /* @__PURE__ */ jsx(RotateCcwIcon, {
+				"aria-hidden": "true",
+				className: "size-3.5"
+			})
+		]
+	});
+};
+/**
+* Layout-only composer shell for rich editors. `children` is deliberately a
+* host-owned editor slot, so TipTap, ProseMirror, native inputs, and mobile
+* editors can share send/stop/retry behavior without copying shell chrome.
+*/
+const ChatComposer = ({ children, className, labels, leading, status, ...action }) => /* @__PURE__ */ jsxs("section", {
+	className: cn("flex flex-col gap-1.5", className),
+	children: [/* @__PURE__ */ jsxs("div", {
+		className: "border-input bg-background flex min-w-0 items-end gap-2 rounded-xl border p-2",
+		children: [
+			leading,
+			/* @__PURE__ */ jsx("div", {
+				className: "min-w-0 flex-1",
+				children
+			}),
+			/* @__PURE__ */ jsx(ChatComposerAction, {
+				...action,
+				labels
+			})
+		]
+	}), status]
+});
+//#endregion
+export { ChatComposer, ChatComposerAction, resolveChatComposerAction };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { ChatComposer, ChatComposerAction, ChatComposerActionMode, ChatComposerActionState, ChatComposerLabels, ChatComposerProps, resolveChatComposerAction } from "./composer.js";
+import { ChatConfigurationError, ChatMessage, ChatModelOption, ChatModelSelection, ChatProviderConfiguration, ChatRuntime, ChatRuntimeSnapshot, ChatStreamError, ChatStreamEvent, ChatTransport, createChatRuntime, resolveChatModelSelection } from "./runtime.js";
+import { ChatModelSelector, ChatModelSelectorProps, compactModelDisplayName, groupReasoningEfforts, modelSelectionLabel } from "./model-selector.js";
+import { ChatMessageStream, ChatMessageStreamProps } from "./stream.js";
+export { ChatComposer, ChatComposerAction, type ChatComposerActionMode, type ChatComposerActionState, type ChatComposerLabels, type ChatComposerProps, ChatConfigurationError, type ChatMessage, ChatMessageStream, type ChatMessageStreamProps, type ChatModelOption, type ChatModelSelection, ChatModelSelector, type ChatModelSelectorProps, type ChatProviderConfiguration, type ChatRuntime, type ChatRuntimeSnapshot, ChatStreamError, type ChatStreamEvent, type ChatTransport, compactModelDisplayName, createChatRuntime, groupReasoningEfforts, modelSelectionLabel, resolveChatComposerAction, resolveChatModelSelection };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { ChatComposer, ChatComposerAction, resolveChatComposerAction } from "./composer.js";
+import { ChatConfigurationError, ChatStreamError, createChatRuntime, resolveChatModelSelection } from "./runtime.js";
+import { ChatModelSelector, compactModelDisplayName, groupReasoningEfforts, modelSelectionLabel } from "./model-selector.js";
+import { ChatMessageStream } from "./stream.js";
+export { ChatComposer, ChatComposerAction, ChatConfigurationError, ChatMessageStream, ChatModelSelector, ChatStreamError, compactModelDisplayName, createChatRuntime, groupReasoningEfforts, modelSelectionLabel, resolveChatComposerAction, resolveChatModelSelection };

package/dist/model-selector.d.ts

@@ -0,0 +1,32 @@
+import { ChatModelOption, ChatModelSelection } from "./runtime.js";
+import { ReasoningEffort } from "@stll/ai-catalog";
+//#region src/model-selector.d.ts
+declare const compactModelDisplayName: (displayName: string) => string;
+declare const groupReasoningEfforts: (efforts: readonly ReasoningEffort[]) => {
+  extended: ReasoningEffort[];
+  standard: ReasoningEffort[];
+};
+declare const modelSelectionLabel: ({ defaultEffortLabel, displayName, formatSelectionLabel, providerDefaultEffort, reasoningEffort, translateEffort }: {
+  defaultEffortLabel: string;
+  displayName: string;
+  formatSelectionLabel: (values: {
+    effort: string;
+    model: string;
+  }) => string;
+  providerDefaultEffort: ReasoningEffort | null;
+  reasoningEffort: ReasoningEffort | null;
+  translateEffort: (effort: ReasoningEffort) => string;
+}) => string;
+type ChatModelSelectorProps = {
+  autoLabel: string;
+  disabled?: boolean | undefined;
+  label: string;
+  onSelectionChange: (selection: ChatModelSelection) => void;
+  options: readonly ChatModelOption[];
+  selection: ChatModelSelection;
+};
+/** Native, accessible model control. Provider configuration is validated by
+ * `resolveChatModelSelection` before a host accepts the new selection. */
+declare const ChatModelSelector: ({ autoLabel, disabled, label, onSelectionChange, options, selection }: ChatModelSelectorProps) => import("react").JSX.Element;
+//#endregion
+export { ChatModelSelector, ChatModelSelectorProps, compactModelDisplayName, groupReasoningEfforts, modelSelectionLabel };

package/dist/model-selector.js

@@ -0,0 +1,77 @@
+import { ChatConfigurationError } from "./runtime.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/model-selector.tsx
+const CLAUDE_FAMILY_PREFIX = /^Claude\s+/u;
+const compactModelDisplayName = (displayName) => displayName.replace(CLAUDE_FAMILY_PREFIX, "");
+const effortSection = {
+	none: "standard",
+	minimal: "standard",
+	low: "standard",
+	medium: "standard",
+	high: "standard",
+	xhigh: "extended",
+	max: "extended"
+};
+const groupReasoningEfforts = (efforts) => {
+	const standard = [];
+	const extended = [];
+	for (const effort of efforts) {
+		if (effortSection[effort] === "extended") {
+			extended.push(effort);
+			continue;
+		}
+		standard.push(effort);
+	}
+	return {
+		extended,
+		standard
+	};
+};
+const modelSelectionLabel = ({ defaultEffortLabel, displayName, formatSelectionLabel, providerDefaultEffort, reasoningEffort, translateEffort }) => {
+	const effectiveEffort = reasoningEffort ?? providerDefaultEffort;
+	return formatSelectionLabel({
+		effort: effectiveEffort === null ? defaultEffortLabel : translateEffort(effectiveEffort),
+		model: compactModelDisplayName(displayName)
+	});
+};
+const toValue = ({ modelId, provider }) => modelId === null || provider === null ? "" : `${provider}:${modelId}`;
+const parseSelection = (value, options) => {
+	if (value.length === 0) return {
+		modelId: null,
+		provider: null,
+		reasoningEffort: null
+	};
+	const option = options.find((candidate) => `${candidate.provider}:${candidate.modelId}` === value);
+	if (option === void 0) throw new ChatConfigurationError({
+		code: "unconfigured-model",
+		message: `Selected AI model is not available: ${value}.`,
+		modelId: value
+	});
+	return {
+		modelId: option.modelId,
+		provider: option.provider,
+		reasoningEffort: null
+	};
+};
+/** Native, accessible model control. Provider configuration is validated by
+* `resolveChatModelSelection` before a host accepts the new selection. */
+const ChatModelSelector = ({ autoLabel, disabled = false, label, onSelectionChange, options, selection }) => {
+	const onChange = ({ currentTarget }) => {
+		onSelectionChange(parseSelection(currentTarget.value, options));
+	};
+	return /* @__PURE__ */ jsxs("select", {
+		"aria-label": label,
+		disabled,
+		onChange,
+		value: toValue(selection),
+		children: [/* @__PURE__ */ jsx("option", {
+			value: "",
+			children: autoLabel
+		}), options.map((option) => /* @__PURE__ */ jsx("option", {
+			value: `${option.provider}:${option.modelId}`,
+			children: option.displayName
+		}, `${option.provider}:${option.modelId}`))]
+	});
+};
+//#endregion
+export { ChatModelSelector, compactModelDisplayName, groupReasoningEfforts, modelSelectionLabel };

package/dist/runtime.d.ts

@@ -0,0 +1,78 @@
+import { AIProvider, ReasoningEffort } from "@stll/ai-catalog";
+//#region src/runtime.d.ts
+type ChatModelOption = {
+  defaultReasoningEffort: ReasoningEffort | null;
+  displayName: string;
+  modelId: string;
+  provider: AIProvider;
+  reasoningEfforts: readonly ReasoningEffort[] | null;
+};
+type ChatModelSelection = {
+  modelId: string | null;
+  provider: AIProvider | null;
+  reasoningEffort: ReasoningEffort | null;
+};
+type ChatProviderConfiguration = {
+  modelIds: readonly string[];
+  provider: AIProvider;
+};
+declare const ChatConfigurationError_base: import("better-result").TaggedErrorClass<"ChatConfigurationError">;
+declare class ChatConfigurationError extends ChatConfigurationError_base<{
+  code: "duplicate-model" | "empty-model-id" | "empty-provider" | "unknown-provider" | "unconfigured-model";
+  message: string;
+  modelId?: string | undefined;
+  provider?: string | undefined;
+}> {}
+declare const ChatStreamError_base: import("better-result").TaggedErrorClass<"ChatStreamError">;
+declare class ChatStreamError extends ChatStreamError_base<{
+  cause: unknown;
+  message: string;
+}> {}
+/**
+ * Validate provider configuration at the shell boundary. A missing or unknown
+ * provider/model is an explicit typed error: the runtime never guesses a
+ * provider or silently routes a request somewhere else.
+ */
+declare const resolveChatModelSelection: ({ providers, selection }: {
+  providers: readonly ChatProviderConfiguration[];
+  selection: ChatModelSelection;
+}) => ChatModelSelection;
+type ChatMessage<Metadata = undefined> = {
+  content: string;
+  id: string;
+  metadata: Metadata;
+  role: "assistant" | "system" | "user";
+};
+type ChatStreamEvent<Metadata = undefined> = {
+  message: ChatMessage<Metadata>;
+  type: "message";
+} | {
+  message: ChatMessage<Metadata>;
+  type: "replace-message";
+};
+type ChatTransport<Metadata = undefined> = (input: {
+  messages: readonly ChatMessage<Metadata>[];
+  signal: AbortSignal;
+}) => AsyncIterable<ChatStreamEvent<Metadata>>;
+type ChatRuntimeSnapshot<Metadata = undefined> = {
+  error: ChatStreamError | undefined;
+  isStreaming: boolean;
+  messages: readonly ChatMessage<Metadata>[];
+};
+type ChatRuntime<Metadata = undefined> = {
+  getSnapshot: () => ChatRuntimeSnapshot<Metadata>;
+  send: (message: ChatMessage<Metadata>) => Promise<void>;
+  stop: () => void;
+  subscribe: (listener: () => void) => () => void;
+};
+/**
+ * A framework-neutral stream runtime. Hosts own authentication, endpoint
+ * selection, persistence, and provider credentials through `transport`; this
+ * primitive owns the observable stream lifecycle and makes failures explicit.
+ */
+declare const createChatRuntime: <Metadata = undefined>({ initialMessages, transport }: {
+  initialMessages?: readonly ChatMessage<Metadata>[];
+  transport: ChatTransport<Metadata>;
+}) => ChatRuntime<Metadata>;
+//#endregion
+export { ChatConfigurationError, ChatMessage, ChatModelOption, ChatModelSelection, ChatProviderConfiguration, ChatRuntime, ChatRuntimeSnapshot, ChatStreamError, ChatStreamEvent, ChatTransport, createChatRuntime, resolveChatModelSelection };

package/dist/runtime.js

@@ -0,0 +1,144 @@
+import { TaggedError } from "better-result";
+import { AI_PROVIDERS } from "@stll/ai-catalog";
+//#region src/runtime.ts
+var ChatConfigurationError = class extends TaggedError("ChatConfigurationError") {};
+var ChatStreamError = class extends TaggedError("ChatStreamError") {};
+const providerSet = new Set(AI_PROVIDERS);
+const modelKey = (provider, modelId) => `${provider}:${modelId}`;
+/**
+* Validate provider configuration at the shell boundary. A missing or unknown
+* provider/model is an explicit typed error: the runtime never guesses a
+* provider or silently routes a request somewhere else.
+*/
+const resolveChatModelSelection = ({ providers, selection }) => {
+	const configuredModels = /* @__PURE__ */ new Set();
+	for (const provider of providers) {
+		if (!providerSet.has(provider.provider)) throw new ChatConfigurationError({
+			code: "unknown-provider",
+			message: `Unknown AI provider: ${provider.provider}.`,
+			provider: provider.provider
+		});
+		if (provider.modelIds.length === 0) throw new ChatConfigurationError({
+			code: "empty-provider",
+			message: `AI provider ${provider.provider} has no configured models.`,
+			provider: provider.provider
+		});
+		for (const modelId of provider.modelIds) {
+			if (modelId.trim().length === 0) throw new ChatConfigurationError({
+				code: "empty-model-id",
+				message: `AI provider ${provider.provider} has an empty model ID.`,
+				provider: provider.provider
+			});
+			const key = modelKey(provider.provider, modelId);
+			if (configuredModels.has(key)) throw new ChatConfigurationError({
+				code: "duplicate-model",
+				message: `AI model ${modelId} is configured more than once for ${provider.provider}.`,
+				modelId,
+				provider: provider.provider
+			});
+			configuredModels.add(key);
+		}
+	}
+	if (selection.modelId === null || selection.provider === null) {
+		if (selection.modelId === null && selection.provider === null) return selection;
+		throw new ChatConfigurationError({
+			code: "unconfigured-model",
+			message: "A model selection must include both provider and model ID.",
+			modelId: selection.modelId ?? void 0,
+			provider: selection.provider ?? void 0
+		});
+	}
+	if (!configuredModels.has(modelKey(selection.provider, selection.modelId))) throw new ChatConfigurationError({
+		code: "unconfigured-model",
+		message: `AI model ${selection.modelId} is not configured for ${selection.provider}.`,
+		modelId: selection.modelId,
+		provider: selection.provider
+	});
+	return selection;
+};
+const toStreamError = (error) => error instanceof ChatStreamError ? error : new ChatStreamError({
+	cause: error,
+	message: error instanceof Error ? error.message : "Chat stream failed."
+});
+/**
+* A framework-neutral stream runtime. Hosts own authentication, endpoint
+* selection, persistence, and provider credentials through `transport`; this
+* primitive owns the observable stream lifecycle and makes failures explicit.
+*/
+const createChatRuntime = ({ initialMessages = [], transport }) => {
+	const listeners = /* @__PURE__ */ new Set();
+	let abortController;
+	let snapshot = {
+		error: void 0,
+		isStreaming: false,
+		messages: initialMessages
+	};
+	const emit = () => {
+		for (const listener of listeners) listener();
+	};
+	const update = (next) => {
+		snapshot = next;
+		emit();
+	};
+	return {
+		getSnapshot: () => snapshot,
+		send: async (message) => {
+			if (snapshot.isStreaming) throw new ChatStreamError({
+				cause: void 0,
+				message: "A chat stream is already active."
+			});
+			const controller = new AbortController();
+			abortController = controller;
+			update({
+				error: void 0,
+				isStreaming: true,
+				messages: [...snapshot.messages, message]
+			});
+			try {
+				for await (const event of transport({
+					messages: snapshot.messages,
+					signal: controller.signal
+				})) {
+					if (abortController !== controller) return;
+					const messages = event.type === "message" ? [...snapshot.messages, event.message] : snapshot.messages.map((candidate) => candidate.id === event.message.id ? event.message : candidate);
+					update({
+						error: void 0,
+						isStreaming: true,
+						messages
+					});
+				}
+				if (abortController === controller) {
+					abortController = void 0;
+					update({
+						...snapshot,
+						isStreaming: false
+					});
+				}
+			} catch (error) {
+				if (abortController !== controller) return;
+				abortController = void 0;
+				update({
+					error: toStreamError(error),
+					isStreaming: false,
+					messages: snapshot.messages
+				});
+			}
+		},
+		stop: () => {
+			abortController?.abort();
+			abortController = void 0;
+			if (snapshot.isStreaming) update({
+				...snapshot,
+				isStreaming: false
+			});
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+};
+//#endregion
+export { ChatConfigurationError, ChatStreamError, createChatRuntime, resolveChatModelSelection };

package/dist/stream.d.ts

@@ -0,0 +1,14 @@
+import { ChatMessage } from "./runtime.js";
+import { ReactElement } from "react";
+//#region src/stream.d.ts
+type ChatMessageStreamProps<Metadata> = {
+  className?: string | undefined;
+  empty?: ReactElement | undefined;
+  messages: readonly ChatMessage<Metadata>[];
+  renderMessage: (message: ChatMessage<Metadata>) => ReactElement;
+};
+/** A semantic transcript container; hosts supply their own rich markdown,
+ * citation, tool-call, and attachment renderers through `renderMessage`. */
+declare const ChatMessageStream: <Metadata>({ className, empty, messages, renderMessage }: ChatMessageStreamProps<Metadata>) => ReactElement | null;
+//#endregion
+export { ChatMessageStream, ChatMessageStreamProps };

package/dist/stream.js

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+//#region src/stream.tsx
+/** A semantic transcript container; hosts supply their own rich markdown,
+* citation, tool-call, and attachment renderers through `renderMessage`. */
+const ChatMessageStream = ({ className, empty, messages, renderMessage }) => {
+	if (messages.length === 0) return empty ?? null;
+	return /* @__PURE__ */ jsx("ol", {
+		className,
+		children: messages.map((message) => /* @__PURE__ */ jsx("li", { children: renderMessage(message) }, message.id))
+	});
+};
+//#endregion
+export { ChatMessageStream };

package/package.json

@@ -1,6 +1,87 @@
 {
   "name": "@stll/chat",
-  "version": "0.0.1-placeholder.0",
-  "description": "Placeholder to bootstrap npm trusted publishing. Real releases are published from stella/stella via GitHub Actions.",
-  "license": "Apache-2.0"
+  "version": "0.1.1",
+  "description": "Typed React chat composer, message stream, model selector, and transport runtime primitives.",
+  "keywords": [
+    "ai",
+    "chat",
+    "react",
+    "streaming"
+  ],
+  "homepage": "https://github.com/stella/stella/tree/main/packages/chat",
+  "bugs": {
+    "url": "https://github.com/stella/stella/issues"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stella/stella.git",
+    "directory": "packages/chat"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./composer": {
+      "types": "./dist/composer.d.ts",
+      "import": "./dist/composer.js"
+    },
+    "./model-selector": {
+      "types": "./dist/model-selector.d.ts",
+      "import": "./dist/model-selector.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./stream": {
+      "types": "./dist/stream.d.ts",
+      "import": "./dist/stream.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "git clean -xdf dist .cache .turbo node_modules",
+    "build": "tsdown",
+    "pack:dry-run": "bun pm pack --dry-run",
+    "test": "bun test src",
+    "typecheck": "bun ../../packages/scripts/src/tsc-native.ts --noEmit",
+    "lint": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --report-unused-disable-directives-severity=error --deny-warnings --type-aware packages/chat",
+    "lint:fix": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --type-aware --fix packages/chat",
+    "format": "oxfmt .",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "@stll/ai-catalog": "^0.1.4",
+    "@stll/ui": "^0.12.0",
+    "better-result": "3.0.0",
+    "lucide-react": "1.30.0"
+  },
+  "devDependencies": {
+    "@stll/typescript-config": "0.0.0",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "bun-types": "1.4.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "tailwindcss": "4.3.3",
+    "tsdown": "0.22.14"
+  },
+  "peerDependencies": {
+    "@base-ui/react": "^1.7.0",
+    "react": ">=19",
+    "react-dom": ">=19",
+    "tailwindcss": "^4.3.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
 }