@assistant-ui/store 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AgentbaseAI Inc.
+
+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,295 @@
+# @assistant-ui/store
+
+Tap-based state management for assistant-ui with React Context integration.
+
+## Overview
+
+The store package provides a bridge between tap Resources and React Components via React Context. It implements a scope-based system where you can define custom scopes using TypeScript module augmentation.
+
+## Key Concepts
+
+### Scopes
+
+A **scope** defines a piece of state in your application. Each scope has:
+
+- **value**: The state type (e.g., `{ bar: string }`)
+- **source**: Where this scope comes from (`"root"` for top-level, or name of parent scope)
+- **query**: Parameters needed to access this scope (e.g., `{ type: "index", index: number }`)
+
+### Module Augmentation
+
+Define custom scopes by extending the `AssistantScopes` interface:
+
+```typescript
+import type { ScopeDefinition } from "@assistant-ui/store";
+
+declare module "@assistant-ui/store" {
+  interface AssistantScopes {
+    foo: ScopeDefinition<{ bar: string }, "root", {}>;
+  }
+}
+```
+
+## Usage
+
+### 1. Define a Scope
+
+```typescript
+// foo-scope.ts
+import { resource, tapState } from "@assistant-ui/tap";
+import { tapApi } from "@assistant-ui/store";
+
+// Define the scope type via module augmentation
+// Implement the scope definition raw (no need to import ScopeDefinition)
+declare module "@assistant-ui/store" {
+  interface AssistantScopes {
+    foo: {
+      value: {
+        getState: () => { bar: string };
+        updateBar: (newBar: string) => void;
+      };
+      source: "root";
+      query: Record<string, never>;
+    };
+  }
+}
+
+// Create the resource
+export const FooResource = resource(() => {
+  const [state, setState] = tapState<{ bar: string }>({ bar: "Hello, World!" });
+
+  const updateBar = (newBar: string) => {
+    setState({ bar: newBar });
+  };
+
+  // Use tapApi to wrap the API for stability and reactivity
+  return tapApi({
+    getState: () => state,
+    updateBar,
+  });
+});
+```
+
+### 2. Use in React Component
+
+```typescript
+import { useAssistantClient } from "@assistant-ui/store";
+import { FooResource } from "./foo-scope";
+
+function MyComponent() {
+  // Create a client with the foo scope
+  const client = useAssistantClient({
+    foo: FooResource(),
+  });
+
+  // Access the state
+  const fooState = client.foo.getState();
+  console.log(fooState.bar); // "Hello, World!"
+
+  // Call actions
+  const handleClick = () => {
+    client.foo.updateBar("New value!");
+  };
+
+  return <div onClick={handleClick}>{fooState.bar}</div>;
+}
+```
+
+### 3. Use with Provider (Optional)
+
+```typescript
+import { AssistantProvider, useAssistantClient } from "@assistant-ui/store";
+import { FooResource } from "./foo-scope";
+
+function App() {
+  const client = useAssistantClient({
+    foo: FooResource,
+  });
+
+  return (
+    <AssistantProvider client={client}>
+      <MyComponent />
+    </AssistantProvider>
+  );
+}
+
+function MyComponent() {
+  // Access client from context
+  const client = useAssistantClient();
+  const fooState = client.foo.getState();
+
+  return <div>{fooState.bar}</div>;
+}
+```
+
+### 4. Derived Scopes
+
+Create scopes that depend on other scopes:
+
+```typescript
+import { DerivedScope } from "@assistant-ui/store";
+
+function MyComponent() {
+  const client = useAssistantClient({
+    foo: FooResource,
+    message: DerivedScope({
+      source: "thread",
+      query: { type: "index", index: 0 },
+      get: () => messageApi,
+    }),
+  });
+
+  return <div>{client.message.getState().content}</div>;
+}
+```
+
+## API
+
+### `useAssistantClient()`
+
+Returns the AssistantClient from context.
+
+```typescript
+const client = useAssistantClient();
+```
+
+### `useAssistantClient(scopes)`
+
+Creates a new AssistantClient with the provided scopes, merging with any client from context.
+
+```typescript
+const client = useAssistantClient({
+  foo: FooResource,
+});
+```
+
+### `AssistantProvider`
+
+Provides an AssistantClient via React Context.
+
+```typescript
+<AssistantProvider client={client}>
+  {children}
+</AssistantProvider>
+```
+
+### `DerivedScope(config)`
+
+Creates a derived scope field that memoizes based on source and query.
+
+```typescript
+DerivedScope({
+  source: "thread",
+  query: { type: "index", index: 0 },
+  get: () => messageApi,
+});
+```
+
+## Advanced: List Management with tapLookupResources
+
+For managing lists of items, use `tapLookupResources`:
+
+```typescript
+import { tapLookupResources, tapApi } from "@assistant-ui/store";
+
+// Define item resource
+const FooItemResource = resource(
+  ({ id, initialBar }: { id: string; initialBar: string }) => {
+    const [state, setState] = tapState({ id, bar: initialBar });
+
+    return {
+      key: id,
+      state,
+      api: tapApi({
+        getState: () => state,
+        updateBar: (newBar: string) => setState({ ...state, bar: newBar }),
+      }),
+    };
+  },
+);
+
+// Define list resource
+const FooListResource = resource(() => {
+  const items = [
+    { id: "foo-1", initialBar: "First" },
+    { id: "foo-2", initialBar: "Second" },
+  ];
+
+  const foos = tapLookupResources(
+    items.map((item) => FooItemResource(item, { key: item.id })),
+  );
+
+  return tapApi({
+    getState: () => ({ foos: foos.state }),
+    // Wrap to rename "key" field to "id"
+    foo: (lookup: { index: number } | { id: string }) => {
+      return "id" in lookup
+        ? foos.api({ key: lookup.id })
+        : foos.api({ index: lookup.index });
+    },
+  }).api;
+});
+```
+
+### Provider Pattern
+
+Create providers to scope access to specific list items:
+
+```typescript
+const FooProvider = ({ index, children }) => {
+  const parentAui = useAssistantClient();
+
+  const aui = useAssistantClient({
+    foo: DerivedScope({
+      source: "fooList",
+      query: { index },
+      get: () => parentAui.fooList().foo({ index }),
+    }),
+  });
+
+  return <AssistantProvider client={aui}>{children}</AssistantProvider>;
+};
+
+// Render list
+const FooList = ({ components }) => {
+  const aui = useAssistantClient();
+  const { foos } = aui.fooList().getState();
+
+  return (
+    <div>
+      {foos.map((_, index) => (
+        <FooProvider key={index} index={index}>
+          <components.Foo />
+        </FooProvider>
+      ))}
+    </div>
+  );
+};
+```
+
+## Examples
+
+See the [store-example](../store-example) Next.js app for a complete working example including:
+
+- Basic scope definition with `tapApi`
+- List management with `tapLookupResources`
+- Provider pattern for scoped access
+- Component composition
+- Tailwind CSS styling
+
+## How It Works
+
+The store is implemented using tap resources:
+
+1. Each scope is a tap resource that manages its own state
+2. `useAssistantClient` creates a resource that composes all provided scopes
+3. The React Context provides the client to child components
+4. Scopes can be extended/overridden by calling `useAssistantClient` with new scope definitions
+
+This design allows for:
+
+- ✅ Type-safe scope definitions via module augmentation
+- ✅ Automatic cleanup of resources when components unmount
+- ✅ Composable scope hierarchy (root → derived scopes)
+- ✅ Full TypeScript inference for state and APIs
+- ✅ Zero runtime overhead for scopes that aren't used

package/dist/AssistantContext.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import type { AssistantClient } from "./types";
+/**
+ * React Context for the AssistantClient
+ */
+export declare const AssistantContext: React.Context<AssistantClient>;
+export declare const useAssistantContextValue: () => AssistantClient;
+/**
+ * Provider component for AssistantClient
+ *
+ * @example
+ * ```typescript
+ * <AssistantProvider client={client}>
+ *   <YourApp />
+ * </AssistantProvider>
+ * ```
+ */
+export declare const AssistantProvider: ({ client, children, }: {
+    client: AssistantClient;
+    children: React.ReactNode;
+}) => React.ReactElement;
+//# sourceMappingURL=AssistantContext.d.ts.map

package/dist/AssistantContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssistantContext.d.ts","sourceRoot":"","sources":["../src/AssistantContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoC,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAA+B,MAAM,SAAS,CAAC;AAgB5E;;GAEG;AACH,eAAO,MAAM,gBAAgB,gCAe5B,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAAO,eAE3C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI,uBAG/B;IACD,MAAM,EAAE,eAAe,CAAC;IACxB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,KAAG,KAAK,CAAC,YAMT,CAAC"}

package/dist/AssistantContext.js

@@ -0,0 +1,44 @@
+// src/AssistantContext.tsx
+import { createContext, useContext } from "react";
+import { hasRegisteredScope } from "./ScopeRegistry.js";
+import { jsx } from "react/jsx-runtime";
+var NO_OP_SUBSCRIBE = () => () => {
+};
+var NO_OP_FLUSH_SYNC = () => {
+};
+var NO_OP_SCOPE_FIELD = (() => {
+  const fn = (() => {
+    throw new Error(
+      "You need to wrap this component/hook in <AssistantProvider>"
+    );
+  });
+  fn.source = null;
+  fn.query = null;
+  return fn;
+})();
+var AssistantContext = createContext(
+  new Proxy({}, {
+    get(_, prop) {
+      if (prop === "subscribe") return NO_OP_SUBSCRIBE;
+      if (prop === "flushSync") return NO_OP_FLUSH_SYNC;
+      if (hasRegisteredScope(prop))
+        return NO_OP_SCOPE_FIELD;
+      return null;
+    }
+  })
+);
+var useAssistantContextValue = () => {
+  return useContext(AssistantContext);
+};
+var AssistantProvider = ({
+  client,
+  children
+}) => {
+  return /* @__PURE__ */ jsx(AssistantContext.Provider, { value: client, children });
+};
+export {
+  AssistantContext,
+  AssistantProvider,
+  useAssistantContextValue
+};
+//# sourceMappingURL=AssistantContext.js.map

package/dist/AssistantContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/AssistantContext.tsx"],"sourcesContent":["import React, { createContext, useContext } from \"react\";\nimport type { AssistantClient, AssistantScopes, ScopeField } from \"./types\";\nimport { hasRegisteredScope } from \"./ScopeRegistry\";\n\nconst NO_OP_SUBSCRIBE = () => () => {};\nconst NO_OP_FLUSH_SYNC = () => {};\nconst NO_OP_SCOPE_FIELD = (() => {\n  const fn = (() => {\n    throw new Error(\n      \"You need to wrap this component/hook in <AssistantProvider>\",\n    );\n  }) as ScopeField<never>;\n  fn.source = null;\n  fn.query = null;\n  return fn;\n})();\n\n/**\n * React Context for the AssistantClient\n */\nexport const AssistantContext = createContext<AssistantClient>(\n  new Proxy({} as AssistantClient, {\n    get(_, prop: string) {\n      // Allow access to subscribe and flushSync without error\n      if (prop === \"subscribe\") return NO_OP_SUBSCRIBE;\n\n      if (prop === \"flushSync\") return NO_OP_FLUSH_SYNC;\n\n      // If this is a registered scope, return a function that errors when called or accessed\n      if (hasRegisteredScope(prop as keyof AssistantScopes))\n        return NO_OP_SCOPE_FIELD;\n\n      return null;\n    },\n  }),\n);\n\nexport const useAssistantContextValue = (): AssistantClient => {\n  return useContext(AssistantContext);\n};\n\n/**\n * Provider component for AssistantClient\n *\n * @example\n * ```typescript\n * <AssistantProvider client={client}>\n *   <YourApp />\n * </AssistantProvider>\n * ```\n */\nexport const AssistantProvider = ({\n  client,\n  children,\n}: {\n  client: AssistantClient;\n  children: React.ReactNode;\n}): React.ReactElement => {\n  return (\n    <AssistantContext.Provider value={client}>\n      {children}\n    </AssistantContext.Provider>\n  );\n};\n"],"mappings":";AAAA,SAAgB,eAAe,kBAAkB;AAEjD,SAAS,0BAA0B;AAyD/B;AAvDJ,IAAM,kBAAkB,MAAM,MAAM;AAAC;AACrC,IAAM,mBAAmB,MAAM;AAAC;AAChC,IAAM,qBAAqB,MAAM;AAC/B,QAAM,MAAM,MAAM;AAChB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,KAAG,SAAS;AACZ,KAAG,QAAQ;AACX,SAAO;AACT,GAAG;AAKI,IAAM,mBAAmB;AAAA,EAC9B,IAAI,MAAM,CAAC,GAAsB;AAAA,IAC/B,IAAI,GAAG,MAAc;AAEnB,UAAI,SAAS,YAAa,QAAO;AAEjC,UAAI,SAAS,YAAa,QAAO;AAGjC,UAAI,mBAAmB,IAA6B;AAClD,eAAO;AAET,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACH;AAEO,IAAM,2BAA2B,MAAuB;AAC7D,SAAO,WAAW,gBAAgB;AACpC;AAYO,IAAM,oBAAoB,CAAC;AAAA,EAChC;AAAA,EACA;AACF,MAG0B;AACxB,SACE,oBAAC,iBAAiB,UAAjB,EAA0B,OAAO,QAC/B,UACH;AAEJ;","names":[]}

package/dist/DerivedScope.d.ts

@@ -0,0 +1,18 @@
+import type { ScopeDefinition, ScopeValue, DerivedScopeProps } from "./types";
+/**
+ * Creates a derived scope field that memoizes based on source and query.
+ * The get callback always calls the most recent version (useEffectEvent pattern).
+ *
+ * @example
+ * ```typescript
+ * const MessageScope = DerivedScope<MessageScopeDefinition>({
+ *   source: "thread",
+ *   query: { type: "index", index: 0 },
+ *   get: () => messageApi,
+ * });
+ * ```
+ */
+export declare const DerivedScope: <T extends ScopeDefinition>(props: DerivedScopeProps<T>, options?: {
+    key?: string | number;
+} | undefined) => import("@assistant-ui/tap").ResourceElement<ScopeValue<T>, DerivedScopeProps<T>>;
+//# sourceMappingURL=DerivedScope.d.ts.map

package/dist/DerivedScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DerivedScope.d.ts","sourceRoot":"","sources":["../src/DerivedScope.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE9E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GACtB,CAAC,SAAS,eAAe;;kGAG3B,CAAC"}

package/dist/DerivedScope.js

@@ -0,0 +1,11 @@
+// src/DerivedScope.ts
+import { resource } from "@assistant-ui/tap";
+var DerivedScope = resource(
+  (config) => {
+    return config;
+  }
+);
+export {
+  DerivedScope
+};
+//# sourceMappingURL=DerivedScope.js.map

package/dist/DerivedScope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/DerivedScope.ts"],"sourcesContent":["import { resource } from \"@assistant-ui/tap\";\nimport type { ScopeDefinition, ScopeValue, DerivedScopeProps } from \"./types\";\n\n/**\n * Creates a derived scope field that memoizes based on source and query.\n * The get callback always calls the most recent version (useEffectEvent pattern).\n *\n * @example\n * ```typescript\n * const MessageScope = DerivedScope<MessageScopeDefinition>({\n *   source: \"thread\",\n *   query: { type: \"index\", index: 0 },\n *   get: () => messageApi,\n * });\n * ```\n */\nexport const DerivedScope = resource(\n  <T extends ScopeDefinition>(config: DerivedScopeProps<T>): ScopeValue<T> => {\n    return config;\n  },\n);\n"],"mappings":";AAAA,SAAS,gBAAgB;AAgBlB,IAAM,eAAe;AAAA,EAC1B,CAA4B,WAAgD;AAC1E,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/ScopeRegistry.d.ts

@@ -0,0 +1,41 @@
+import type { AssistantScopes } from "./types";
+import type { ResourceElement } from "@assistant-ui/tap";
+type ScopeRegistryEntry<K extends keyof AssistantScopes> = {
+    name: K;
+    defaultInitialize: ResourceElement<AssistantScopes[K]["value"]> | {
+        error: string;
+    };
+};
+/**
+ * Register a default scope implementation.
+ * This allows scopes to have default values when not explicitly provided.
+ *
+ * @example With a resource:
+ * ```typescript
+ * registerAssistantScope({
+ *   name: "myScope",
+ *   defaultInitialize: MyResource(),
+ * });
+ * ```
+ *
+ * @example With an error:
+ * ```typescript
+ * registerAssistantScope({
+ *   name: "myScope",
+ *   defaultInitialize: { error: "MyScope is not configured" },
+ * });
+ * ```
+ */
+export declare function registerAssistantScope<K extends keyof AssistantScopes>(config: ScopeRegistryEntry<K>): void;
+/**
+ * Get the default initializer for a scope, if registered.
+ */
+export declare function getDefaultScopeInitializer<K extends keyof AssistantScopes>(name: K): (ResourceElement<AssistantScopes[K]["value"]> | {
+    error: string;
+}) | undefined;
+/**
+ * Get all registered scope names.
+ */
+export declare function hasRegisteredScope(name: keyof AssistantScopes): boolean;
+export {};
+//# sourceMappingURL=ScopeRegistry.d.ts.map

package/dist/ScopeRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScopeRegistry.d.ts","sourceRoot":"","sources":["../src/ScopeRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,KAAK,kBAAkB,CAAC,CAAC,SAAS,MAAM,eAAe,IAAI;IACzD,IAAI,EAAE,CAAC,CAAC;IACR,iBAAiB,EACb,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAC5C;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACvB,CAAC;AAOF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,eAAe,EACpE,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC5B,IAAI,CAEN;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,MAAM,eAAe,EACxE,IAAI,EAAE,CAAC,GAEL,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAClE,SAAS,CAEZ;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,eAAe,GAAG,OAAO,CAEvE"}

package/dist/ScopeRegistry.js

@@ -0,0 +1,17 @@
+// src/ScopeRegistry.ts
+var scopeRegistry = /* @__PURE__ */ new Map();
+function registerAssistantScope(config) {
+  scopeRegistry.set(config.name, config.defaultInitialize);
+}
+function getDefaultScopeInitializer(name) {
+  return scopeRegistry.get(name);
+}
+function hasRegisteredScope(name) {
+  return scopeRegistry.has(name);
+}
+export {
+  getDefaultScopeInitializer,
+  hasRegisteredScope,
+  registerAssistantScope
+};
+//# sourceMappingURL=ScopeRegistry.js.map

package/dist/ScopeRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ScopeRegistry.ts"],"sourcesContent":["import type { AssistantScopes } from \"./types\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\n\ntype ScopeRegistryEntry<K extends keyof AssistantScopes> = {\n  name: K;\n  defaultInitialize:\n    | ResourceElement<AssistantScopes[K][\"value\"]>\n    | { error: string };\n};\n\nconst scopeRegistry = new Map<\n  keyof AssistantScopes,\n  ResourceElement<any> | { error: string }\n>();\n\n/**\n * Register a default scope implementation.\n * This allows scopes to have default values when not explicitly provided.\n *\n * @example With a resource:\n * ```typescript\n * registerAssistantScope({\n *   name: \"myScope\",\n *   defaultInitialize: MyResource(),\n * });\n * ```\n *\n * @example With an error:\n * ```typescript\n * registerAssistantScope({\n *   name: \"myScope\",\n *   defaultInitialize: { error: \"MyScope is not configured\" },\n * });\n * ```\n */\nexport function registerAssistantScope<K extends keyof AssistantScopes>(\n  config: ScopeRegistryEntry<K>,\n): void {\n  scopeRegistry.set(config.name, config.defaultInitialize);\n}\n\n/**\n * Get the default initializer for a scope, if registered.\n */\nexport function getDefaultScopeInitializer<K extends keyof AssistantScopes>(\n  name: K,\n):\n  | (ResourceElement<AssistantScopes[K][\"value\"]> | { error: string })\n  | undefined {\n  return scopeRegistry.get(name);\n}\n\n/**\n * Get all registered scope names.\n */\nexport function hasRegisteredScope(name: keyof AssistantScopes): boolean {\n  return scopeRegistry.has(name);\n}\n"],"mappings":";AAUA,IAAM,gBAAgB,oBAAI,IAGxB;AAsBK,SAAS,uBACd,QACM;AACN,gBAAc,IAAI,OAAO,MAAM,OAAO,iBAAiB;AACzD;AAKO,SAAS,2BACd,MAGY;AACZ,SAAO,cAAc,IAAI,IAAI;AAC/B;AAKO,SAAS,mBAAmB,MAAsC;AACvE,SAAO,cAAc,IAAI,IAAI;AAC/B;","names":[]}

package/dist/asStore.d.ts

@@ -0,0 +1,20 @@
+import { ResourceElement } from "@assistant-ui/tap";
+import { Unsubscribe } from "./types";
+export interface Store<TState> {
+    /**
+     * Get the current state of the store.
+     */
+    getState(): TState;
+    /**
+     * Subscribe to the store.
+     */
+    subscribe(listener: () => void): Unsubscribe;
+    /**
+     * Synchronously flush all the updates to the store.
+     */
+    flushSync(): void;
+}
+export declare const asStore: <TState, TProps>(props: ResourceElement<TState, TProps>, options?: {
+    key?: string | number;
+} | undefined) => ResourceElement<Store<TState>, ResourceElement<TState, TProps>>;
+//# sourceMappingURL=asStore.d.ts.map

package/dist/asStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asStore.d.ts","sourceRoot":"","sources":["../src/asStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EAGhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,MAAM,WAAW,KAAK,CAAC,MAAM;IAC3B;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,WAAW,CAAC;IAE7C;;OAEG;IACH,SAAS,IAAI,IAAI,CAAC;CACnB;AAED,eAAO,MAAM,OAAO,GACjB,MAAM,EAAE,MAAM;;iFAYhB,CAAC"}

package/dist/asStore.js

@@ -0,0 +1,23 @@
+// src/asStore.ts
+import {
+  tapMemo,
+  tapEffect,
+  resource,
+  createResource
+} from "@assistant-ui/tap";
+var asStore = resource(
+  (element) => {
+    const resource2 = tapMemo(
+      () => createResource(element, true),
+      [element.type]
+    );
+    tapEffect(() => {
+      resource2.updateInput(element.props);
+    });
+    return resource2;
+  }
+);
+export {
+  asStore
+};
+//# sourceMappingURL=asStore.js.map

package/dist/asStore.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asStore.ts"],"sourcesContent":["import {\n  tapMemo,\n  tapEffect,\n  ResourceElement,\n  resource,\n  createResource,\n} from \"@assistant-ui/tap\";\nimport { Unsubscribe } from \"./types\";\n\nexport interface Store<TState> {\n  /**\n   * Get the current state of the store.\n   */\n  getState(): TState;\n\n  /**\n   * Subscribe to the store.\n   */\n  subscribe(listener: () => void): Unsubscribe;\n\n  /**\n   * Synchronously flush all the updates to the store.\n   */\n  flushSync(): void;\n}\n\nexport const asStore = resource(\n  <TState, TProps>(element: ResourceElement<TState, TProps>): Store<TState> => {\n    const resource = tapMemo(\n      () => createResource(element, true),\n      [element.type],\n    );\n\n    tapEffect(() => {\n      resource.updateInput(element.props);\n    });\n\n    return resource;\n  },\n);\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,OACK;AAoBA,IAAM,UAAU;AAAA,EACrB,CAAiB,YAA4D;AAC3E,UAAMA,YAAW;AAAA,MACf,MAAM,eAAe,SAAS,IAAI;AAAA,MAClC,CAAC,QAAQ,IAAI;AAAA,IACf;AAEA,cAAU,MAAM;AACd,MAAAA,UAAS,YAAY,QAAQ,KAAK;AAAA,IACpC,CAAC;AAED,WAAOA;AAAA,EACT;AACF;","names":["resource"]}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { useAssistantClient } from "./useAssistantClient";
+export { useAssistantState } from "./useAssistantState";
+export { AssistantProvider } from "./AssistantContext";
+export type { AssistantScopes, AssistantClient, AssistantState } from "./types";
+export { DerivedScope } from "./DerivedScope";
+export type { ApiObject } from "./tapApi";
+export { tapApi } from "./tapApi";
+export { tapLookupResources } from "./tapLookupResources";
+export { tapStoreList } from "./tapStoreList";
+export type { TapStoreListConfig } from "./tapStoreList";
+export { registerAssistantScope } from "./ScopeRegistry";
+export type { AssistantScopeRegistry } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+// src/index.ts
+import { useAssistantClient } from "./useAssistantClient.js";
+import { useAssistantState } from "./useAssistantState.js";
+import { AssistantProvider } from "./AssistantContext.js";
+import { DerivedScope } from "./DerivedScope.js";
+import { tapApi } from "./tapApi.js";
+import { tapLookupResources } from "./tapLookupResources.js";
+import { tapStoreList } from "./tapStoreList.js";
+import { registerAssistantScope } from "./ScopeRegistry.js";
+export {
+  AssistantProvider,
+  DerivedScope,
+  registerAssistantScope,
+  tapApi,
+  tapLookupResources,
+  tapStoreList,
+  useAssistantClient,
+  useAssistantState
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { useAssistantClient } from \"./useAssistantClient\";\nexport { useAssistantState } from \"./useAssistantState\";\nexport { AssistantProvider } from \"./AssistantContext\";\nexport type { AssistantScopes, AssistantClient, AssistantState } from \"./types\";\nexport { DerivedScope } from \"./DerivedScope\";\nexport type { ApiObject } from \"./tapApi\";\nexport { tapApi } from \"./tapApi\";\nexport { tapLookupResources } from \"./tapLookupResources\";\nexport { tapStoreList } from \"./tapStoreList\";\nexport type { TapStoreListConfig } from \"./tapStoreList\";\nexport { registerAssistantScope } from \"./ScopeRegistry\";\n\nexport type { AssistantScopeRegistry } from \"./types\";\n"],"mappings":";AAAA,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAElC,SAAS,oBAAoB;AAE7B,SAAS,cAAc;AACvB,SAAS,0BAA0B;AACnC,SAAS,oBAAoB;AAE7B,SAAS,8BAA8B;","names":[]}

package/dist/tapApi.d.ts

@@ -0,0 +1,36 @@
+/**
+ * API object type
+ */
+export interface ApiObject {
+    [key: string]: ((...args: any[]) => any) | ApiObject;
+}
+/**
+ * Wraps an API object to make it stable across renders while keeping getState reactive.
+ * This is the recommended pattern for scope resources.
+ *
+ * @example
+ * ```typescript
+ * export const FooResource = resource(() => {
+ *   const [state, setState] = tapState({ bar: "Hello" });
+ *
+ *   const updateBar = (newBar: string) => {
+ *     setState({ bar: newBar });
+ *   };
+ *
+ *   return tapApi({
+ *     getState: () => state,
+ *     updateBar,
+ *   });
+ * });
+ * ```
+ */
+export declare const tapApi: <TApi extends ApiObject & {
+    getState: () => any;
+}>(api: TApi, options?: {
+    key?: string | undefined;
+}) => {
+    key: string | undefined;
+    state: any;
+    api: TApi;
+};
+//# sourceMappingURL=tapApi.d.ts.map

package/dist/tapApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tapApi.d.ts","sourceRoot":"","sources":["../src/tapApi.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,GAAG,SAAS,CAAC;CACtD;AAmCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,IAAI,SAAS,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,GAAG,CAAA;CAAE,EACrE,KAAK,IAAI,EACT,UAAU;IACR,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;;;;CAwBF,CAAC"}