@assistant-ui/store 0.0.1 → 0.0.3

package/README.md

@@ -1,295 +1,92 @@
 # @assistant-ui/store
 
-Tap-based state management for assistant-ui with React Context integration.
+Tap-based state management 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
+## Quick Start
 
 ```typescript
-// foo-scope.ts
 import { resource, tapState } from "@assistant-ui/tap";
-import { tapApi } from "@assistant-ui/store";
+import { useAssistantClient, useAssistantState, AssistantProvider, type ClientOutput } from "@assistant-ui/store";
 
-// Define the scope type via module augmentation
-// Implement the scope definition raw (no need to import ScopeDefinition)
+// 1. Define client type
 declare module "@assistant-ui/store" {
-  interface AssistantScopes {
-    foo: {
-      value: {
-        getState: () => { bar: string };
-        updateBar: (newBar: string) => void;
-      };
-      source: "root";
-      query: Record<string, never>;
-    };
+  interface ClientRegistry {
+    counter: { state: { count: number }; methods: { increment: () => void } };
   }
 }
 
-// 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. Create resource
+const CounterClient = resource((): ClientOutput<"counter"> => {
+  const [state, setState] = tapState({ count: 0 });
+  return { state, methods: { increment: () => setState({ count: state.count + 1 }) } };
 });
-```
-
-### 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";
 
+// 3. Use in React
 function App() {
-  const client = useAssistantClient({
-    foo: FooResource,
-  });
-
-  return (
-    <AssistantProvider client={client}>
-      <MyComponent />
-    </AssistantProvider>
-  );
+  const aui = useAssistantClient({ counter: CounterClient() });
+  return <AssistantProvider client={aui}><Counter /></AssistantProvider>;
 }
 
-function MyComponent() {
-  // Access client from context
-  const client = useAssistantClient();
-  const fooState = client.foo.getState();
-
-  return <div>{fooState.bar}</div>;
+function Counter() {
+  const count = useAssistantState(({ counter }) => counter.count);
+  const aui = useAssistantClient();
+  return <button onClick={() => aui.counter().increment()}>{count}</button>;
 }
 ```
 
-### 4. Derived Scopes
-
-Create scopes that depend on other scopes:
+## Concepts
 
+**Clients**: Named state containers registered via module augmentation.
 ```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>;
+declare module "@assistant-ui/store" {
+  interface ClientRegistry {
+    myClient: {
+      state: MyState;
+      methods: MyMethods;
+      meta?: { source: "parent"; query: { id: string } };
+      events?: { "myClient.updated": { id: string } };
+    };
+  }
 }
 ```
 
-## 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.
-
+**Derived Clients**: Access nested clients from parents.
 ```typescript
-const client = useAssistantClient({
-  foo: FooResource,
+useAssistantClient({
+  item: Derived({ source: "list", query: { index: 0 }, get: (aui) => aui.list().item({ index: 0 }) }),
 });
 ```
 
-### `AssistantProvider`
-
-Provides an AssistantClient via React Context.
-
+**Events**:
 ```typescript
-<AssistantProvider client={client}>
-  {children}
-</AssistantProvider>
-```
-
-### `DerivedScope(config)`
+const emit = tapAssistantEmit();
+emit("myClient.updated", { id: "123" });
 
-Creates a derived scope field that memoizes based on source and query.
-
-```typescript
-DerivedScope({
-  source: "thread",
-  query: { type: "index", index: 0 },
-  get: () => messageApi,
-});
+useAssistantEvent("myClient.updated", (p) => console.log(p.id));
 ```
 
-## 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:
+## API
 
-- ✅ 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
+| Hook/Component | Description |
+|----------------|-------------|
+| `useAssistantClient()` | Get client from context |
+| `useAssistantClient(clients)` | Create/extend client |
+| `useAssistantState(selector)` | Subscribe to state |
+| `useAssistantEvent(event, cb)` | Subscribe to events |
+| `AssistantProvider` | Provide client to tree |
+| `AssistantIf` | Conditional rendering |
+
+| Tap Utility | Description |
+|-------------|-------------|
+| `tapAssistantClientRef()` | Access client ref in resources |
+| `tapAssistantEmit()` | Emit events from resources |
+| `tapClientResource(element)` | Wrap resource for event scoping (1:1 mappings) |
+| `tapClientLookup(map, fn, deps)` | Lookup by `{index}` or `{key}` |
+| `tapClientList(config)` | Dynamic list with add/remove |
+| `attachDefaultPeers(resource, peers)` | Attach default peers |
+
+| Type | Description |
+|------|-------------|
+| `ClientOutput<K>` | Resource return type: `{ state, methods }` |
+| `ClientRegistry` | Module augmentation interface |
+| `AssistantClient` | Full client type |

package/dist/AssistantIf.d.ts

@@ -0,0 +1,10 @@
+import type { FC, PropsWithChildren } from "react";
+import type { AssistantState } from "./types/client";
+export declare namespace AssistantIf {
+    type Props = PropsWithChildren<{
+        condition: AssistantIf.Condition;
+    }>;
+    type Condition = (state: AssistantState) => boolean;
+}
+export declare const AssistantIf: FC<AssistantIf.Props>;
+//# sourceMappingURL=AssistantIf.d.ts.map

package/dist/AssistantIf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssistantIf.d.ts","sourceRoot":"","sources":["../src/AssistantIf.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,yBAAiB,WAAW,CAAC;IAC3B,KAAY,KAAK,GAAG,iBAAiB,CAAC;QAAE,SAAS,EAAE,WAAW,CAAC,SAAS,CAAA;KAAE,CAAC,CAAC;IAC5E,KAAY,SAAS,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,OAAO,CAAC;CAC5D;AAED,eAAO,MAAM,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,CAG7C,CAAC"}

package/dist/AssistantIf.js

@@ -0,0 +1,13 @@
+"use client";
+
+// src/AssistantIf.tsx
+import { useAssistantState } from "./useAssistantState.js";
+var AssistantIf = ({ children, condition }) => {
+  const result = useAssistantState(condition);
+  return result ? children : null;
+};
+AssistantIf.displayName = "AssistantIf";
+export {
+  AssistantIf
+};
+//# sourceMappingURL=AssistantIf.js.map

package/dist/AssistantIf.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/AssistantIf.tsx"],"sourcesContent":["\"use client\";\n\nimport type { FC, PropsWithChildren } from \"react\";\nimport { useAssistantState } from \"./useAssistantState\";\nimport type { AssistantState } from \"./types/client\";\n\nexport namespace AssistantIf {\n  export type Props = PropsWithChildren<{ condition: AssistantIf.Condition }>;\n  export type Condition = (state: AssistantState) => boolean;\n}\n\nexport const AssistantIf: FC<AssistantIf.Props> = ({ children, condition }) => {\n  const result = useAssistantState(condition);\n  return result ? children : null;\n};\n\nAssistantIf.displayName = \"AssistantIf\";\n"],"mappings":";;;AAGA,SAAS,yBAAyB;AAQ3B,IAAM,cAAqC,CAAC,EAAE,UAAU,UAAU,MAAM;AAC7E,QAAM,SAAS,kBAAkB,SAAS;AAC1C,SAAO,SAAS,WAAW;AAC7B;AAEA,YAAY,cAAc;","names":[]}

package/dist/Derived.d.ts

@@ -0,0 +1,34 @@
+import { ResourceElement } from "@assistant-ui/tap";
+import type { AssistantClient, ClientNames, AssistantClientAccessor, ClientMeta } from "./types/client";
+/**
+ * Creates a derived client field that references a client from a parent scope.
+ * The get callback always calls the most recent version (useEffectEvent pattern).
+ *
+ * IMPORTANT: The `get` callback must return a client that was created via
+ * `tapClientResource` (or `tapClientLookup`/`tapClientList` which use it internally).
+ * This is required for event scoping to work correctly.
+ *
+ * @example
+ * ```typescript
+ * const aui = useAssistantClient({
+ *   message: Derived({
+ *     source: "thread",
+ *     query: { index: 0 },
+ *     get: (aui) => aui.thread().message({ index: 0 }),
+ *   }),
+ * });
+ * ```
+ */
+export declare const Derived: <K extends ClientNames>(...args: undefined extends Derived.Props<K> ? [props?: Derived.Props<K>] : [props: Derived.Props<K>]) => ResourceElement<null, Derived.Props<K>>;
+export type DerivedElement<K extends ClientNames> = ResourceElement<null, Derived.Props<K>>;
+export declare namespace Derived {
+    /**
+     * Props passed to a derived client resource element.
+     */
+    type Props<K extends ClientNames> = {
+        get: (client: AssistantClient) => ReturnType<AssistantClientAccessor<K>>;
+    } & (ClientMeta<K> | {
+        getMeta: (client: AssistantClient) => ClientMeta<K>;
+    });
+}
+//# sourceMappingURL=Derived.d.ts.map

package/dist/Derived.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Derived.d.ts","sourceRoot":"","sources":["../src/Derived.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,uBAAuB,EACvB,UAAU,EACX,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,GACjB,CAAC,SAAS,WAAW,kJAGvB,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,WAAW,IAAI,eAAe,CACjE,IAAI,EACJ,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CACjB,CAAC;AAEF,yBAAiB,OAAO,CAAC;IACvB;;OAEG;IACH,KAAY,KAAK,CAAC,CAAC,SAAS,WAAW,IAAI;QACzC,GAAG,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,UAAU,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC;KAC1E,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC,CAAC;CAC/E"}

package/dist/Derived.js

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

package/dist/Derived.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Derived.ts"],"sourcesContent":["import { resource, ResourceElement } from \"@assistant-ui/tap\";\nimport type {\n  AssistantClient,\n  ClientNames,\n  AssistantClientAccessor,\n  ClientMeta,\n} from \"./types/client\";\n\n/**\n * Creates a derived client field that references a client from a parent scope.\n * The get callback always calls the most recent version (useEffectEvent pattern).\n *\n * IMPORTANT: The `get` callback must return a client that was created via\n * `tapClientResource` (or `tapClientLookup`/`tapClientList` which use it internally).\n * This is required for event scoping to work correctly.\n *\n * @example\n * ```typescript\n * const aui = useAssistantClient({\n *   message: Derived({\n *     source: \"thread\",\n *     query: { index: 0 },\n *     get: (aui) => aui.thread().message({ index: 0 }),\n *   }),\n * });\n * ```\n */\nexport const Derived = resource(\n  <K extends ClientNames>(_config: Derived.Props<K>): null => {\n    return null;\n  },\n);\n\nexport type DerivedElement<K extends ClientNames> = ResourceElement<\n  null,\n  Derived.Props<K>\n>;\n\nexport namespace Derived {\n  /**\n   * Props passed to a derived client resource element.\n   */\n  export type Props<K extends ClientNames> = {\n    get: (client: AssistantClient) => ReturnType<AssistantClientAccessor<K>>;\n  } & (ClientMeta<K> | { getMeta: (client: AssistantClient) => ClientMeta<K> });\n}\n"],"mappings":";AAAA,SAAS,gBAAiC;AA2BnC,IAAM,UAAU;AAAA,EACrB,CAAwB,YAAoC;AAC1D,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/attachDefaultPeers.d.ts

@@ -0,0 +1,56 @@
+import type { ResourceElement } from "@assistant-ui/tap";
+import type { ClientElement, ClientNames } from "./types/client";
+import type { DerivedElement } from "./Derived";
+/**
+ * Symbol used to store default peer clients on a resource.
+ */
+declare const DEFAULT_PEERS: unique symbol;
+/**
+ * Type for resources that have default peers attached.
+ */
+export type ResourceWithDefaultPeers = {
+    [DEFAULT_PEERS]?: DefaultPeers;
+};
+/**
+ * Default peers configuration - can be either root clients or derived clients.
+ */
+export type DefaultPeers = {
+    [K in ClientNames]?: ClientElement<K> | DerivedElement<K>;
+};
+/**
+ * Attaches default peer clients to a resource.
+ *
+ * Default peers are only applied if the scope doesn't exist:
+ * - Not defined in parent context
+ * - Not provided by user
+ * - Not already defined by a previous resource's default peers
+ *
+ * First definition wins - no overriding is permitted.
+ *
+ * @param resource - The resource to attach default peers to
+ * @param peers - The default peer clients to attach
+ * @throws Error if a peer key already exists in the resource's default peers
+ *
+ * @example
+ * ```typescript
+ * const ThreadListClient = resource(({ ... }) => { ... });
+ *
+ * attachDefaultPeers(ThreadListClient, {
+ *   // Derived default peers
+ *   thread: Derived({ source: "threads", query: { type: "main" }, get: ... }),
+ *   threadListItem: Derived({ ... }),
+ *   composer: Derived({ getMeta: ..., get: ... }),
+ *
+ *   // Root default peers
+ *   tools: Tools({}),
+ *   modelContext: ModelContext({}),
+ * });
+ * ```
+ */
+export declare function attachDefaultPeers<T extends (...args: any[]) => ResourceElement<any>>(resource: T, peers: DefaultPeers): void;
+/**
+ * Gets the default peers attached to a resource, if any.
+ */
+export declare function getDefaultPeers<T extends (...args: any[]) => ResourceElement<any>>(resource: T): DefaultPeers | undefined;
+export {};
+//# sourceMappingURL=attachDefaultPeers.d.ts.map

package/dist/attachDefaultPeers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachDefaultPeers.d.ts","sourceRoot":"","sources":["../src/attachDefaultPeers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD;;GAEG;AACH,QAAA,MAAM,aAAa,eAAuC,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,CAAC,aAAa,CAAC,CAAC,EAAE,YAAY,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;KACxB,CAAC,IAAI,WAAW,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,eAAe,CAAC,GAAG,CAAC,EAClD,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAaxC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,eAAe,CAAC,GAAG,CAAC,EAClD,QAAQ,EAAE,CAAC,GAAG,YAAY,GAAG,SAAS,CAEvC"}

package/dist/attachDefaultPeers.js

@@ -0,0 +1,22 @@
+// src/attachDefaultPeers.ts
+var DEFAULT_PEERS = /* @__PURE__ */ Symbol("assistant-ui.default-peers");
+function attachDefaultPeers(resource, peers) {
+  const resourceWithPeers = resource;
+  const existing = resourceWithPeers[DEFAULT_PEERS] ?? {};
+  for (const key of Object.keys(peers)) {
+    if (key in existing) {
+      throw new Error(
+        `Default peer "${key}" is already attached to this resource`
+      );
+    }
+  }
+  resourceWithPeers[DEFAULT_PEERS] = { ...existing, ...peers };
+}
+function getDefaultPeers(resource) {
+  return resource[DEFAULT_PEERS];
+}
+export {
+  attachDefaultPeers,
+  getDefaultPeers
+};
+//# sourceMappingURL=attachDefaultPeers.js.map

package/dist/attachDefaultPeers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/attachDefaultPeers.ts"],"sourcesContent":["import type { ResourceElement } from \"@assistant-ui/tap\";\nimport type { ClientElement, ClientNames } from \"./types/client\";\nimport type { DerivedElement } from \"./Derived\";\n\n/**\n * Symbol used to store default peer clients on a resource.\n */\nconst DEFAULT_PEERS = Symbol(\"assistant-ui.default-peers\");\n\n/**\n * Type for resources that have default peers attached.\n */\nexport type ResourceWithDefaultPeers = {\n  [DEFAULT_PEERS]?: DefaultPeers;\n};\n\n/**\n * Default peers configuration - can be either root clients or derived clients.\n */\nexport type DefaultPeers = {\n  [K in ClientNames]?: ClientElement<K> | DerivedElement<K>;\n};\n\n/**\n * Attaches default peer clients to a resource.\n *\n * Default peers are only applied if the scope doesn't exist:\n * - Not defined in parent context\n * - Not provided by user\n * - Not already defined by a previous resource's default peers\n *\n * First definition wins - no overriding is permitted.\n *\n * @param resource - The resource to attach default peers to\n * @param peers - The default peer clients to attach\n * @throws Error if a peer key already exists in the resource's default peers\n *\n * @example\n * ```typescript\n * const ThreadListClient = resource(({ ... }) => { ... });\n *\n * attachDefaultPeers(ThreadListClient, {\n *   // Derived default peers\n *   thread: Derived({ source: \"threads\", query: { type: \"main\" }, get: ... }),\n *   threadListItem: Derived({ ... }),\n *   composer: Derived({ getMeta: ..., get: ... }),\n *\n *   // Root default peers\n *   tools: Tools({}),\n *   modelContext: ModelContext({}),\n * });\n * ```\n */\nexport function attachDefaultPeers<\n  T extends (...args: any[]) => ResourceElement<any>,\n>(resource: T, peers: DefaultPeers): void {\n  const resourceWithPeers = resource as T & ResourceWithDefaultPeers;\n  const existing = resourceWithPeers[DEFAULT_PEERS] ?? {};\n\n  for (const key of Object.keys(peers)) {\n    if (key in existing) {\n      throw new Error(\n        `Default peer \"${key}\" is already attached to this resource`,\n      );\n    }\n  }\n\n  resourceWithPeers[DEFAULT_PEERS] = { ...existing, ...peers };\n}\n\n/**\n * Gets the default peers attached to a resource, if any.\n */\nexport function getDefaultPeers<\n  T extends (...args: any[]) => ResourceElement<any>,\n>(resource: T): DefaultPeers | undefined {\n  return (resource as T & ResourceWithDefaultPeers)[DEFAULT_PEERS];\n}\n"],"mappings":";AAOA,IAAM,gBAAgB,uBAAO,4BAA4B;AA8ClD,SAAS,mBAEd,UAAa,OAA2B;AACxC,QAAM,oBAAoB;AAC1B,QAAM,WAAW,kBAAkB,aAAa,KAAK,CAAC;AAEtD,aAAW,OAAO,OAAO,KAAK,KAAK,GAAG;AACpC,QAAI,OAAO,UAAU;AACnB,YAAM,IAAI;AAAA,QACR,iBAAiB,GAAG;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AAEA,oBAAkB,aAAa,IAAI,EAAE,GAAG,UAAU,GAAG,MAAM;AAC7D;AAKO,SAAS,gBAEd,UAAuC;AACvC,SAAQ,SAA0C,aAAa;AACjE;","names":[]}

package/dist/index.d.ts

@@ -1,18 +1,15 @@
 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";
-export { tapStoreContext } from "./StoreContext";
-export type { StoreContextValue } from "./StoreContext";
 export { useAssistantEvent } from "./useAssistantEvent";
-export { normalizeEventSelector, checkEventScope } from "./EventContext";
-export type { AssistantEvent, AssistantEventRegistry, AssistantEventScopeConfig, AssistantEventMap, AssistantEventScope, AssistantEventSelector, AssistantEventCallback, EventSource, SourceByScope, EventManager, } from "./EventContext";
+export { AssistantIf } from "./AssistantIf";
+export { AssistantProvider } from "./utils/react-assistant-context";
+export { Derived } from "./Derived";
+export { attachDefaultPeers } from "./attachDefaultPeers";
+export { tapAssistantClientRef, tapAssistantEmit, } from "./utils/tap-assistant-context";
+export { tapClientResource } from "./tapClientResource";
+export { tapClientLookup } from "./tapClientLookup";
+export { tapClientList } from "./tapClientList";
+export type { ClientRegistry, ClientOutput, AssistantClient, AssistantState, } from "./types/client";
+export type { AssistantEventName, AssistantEventCallback, AssistantEventPayload, AssistantEventSelector, AssistantEventScope, } from "./types/events";
+export type { DefaultPeers } from "./attachDefaultPeers";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +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;AAGtD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACzE,YAAY,EACV,cAAc,EACd,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,sBAAsB,EACtB,WAAW,EACX,aAAa,EACb,YAAY,GACb,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAGpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,EACL,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,YAAY,EACV,cAAc,EACd,YAAY,EACZ,eAAe,EACf,cAAc,GACf,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -1,25 +1,28 @@
 // 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";
-import { tapStoreContext } from "./StoreContext.js";
 import { useAssistantEvent } from "./useAssistantEvent.js";
-import { normalizeEventSelector, checkEventScope } from "./EventContext.js";
+import { AssistantIf } from "./AssistantIf.js";
+import { AssistantProvider } from "./utils/react-assistant-context.js";
+import { Derived } from "./Derived.js";
+import { attachDefaultPeers } from "./attachDefaultPeers.js";
+import {
+  tapAssistantClientRef,
+  tapAssistantEmit
+} from "./utils/tap-assistant-context.js";
+import { tapClientResource } from "./tapClientResource.js";
+import { tapClientLookup } from "./tapClientLookup.js";
+import { tapClientList } from "./tapClientList.js";
 export {
+  AssistantIf,
   AssistantProvider,
-  DerivedScope,
-  checkEventScope,
-  normalizeEventSelector,
-  registerAssistantScope,
-  tapApi,
-  tapLookupResources,
-  tapStoreContext,
-  tapStoreList,
+  Derived,
+  attachDefaultPeers,
+  tapAssistantClientRef,
+  tapAssistantEmit,
+  tapClientList,
+  tapClientLookup,
+  tapClientResource,
   useAssistantClient,
   useAssistantEvent,
   useAssistantState

package/dist/index.js.map

@@ -1 +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\n// Events & Store Context\nexport { tapStoreContext } from \"./StoreContext\";\nexport type { StoreContextValue } from \"./StoreContext\";\nexport { useAssistantEvent } from \"./useAssistantEvent\";\nexport { normalizeEventSelector, checkEventScope } from \"./EventContext\";\nexport type {\n  AssistantEvent,\n  AssistantEventRegistry,\n  AssistantEventScopeConfig,\n  AssistantEventMap,\n  AssistantEventScope,\n  AssistantEventSelector,\n  AssistantEventCallback,\n  EventSource,\n  SourceByScope,\n  EventManager,\n} from \"./EventContext\";\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;AAKvC,SAAS,uBAAuB;AAEhC,SAAS,yBAAyB;AAClC,SAAS,wBAAwB,uBAAuB;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// hooks\nexport { useAssistantClient } from \"./useAssistantClient\";\nexport { useAssistantState } from \"./useAssistantState\";\nexport { useAssistantEvent } from \"./useAssistantEvent\";\n\n// components\nexport { AssistantIf } from \"./AssistantIf\";\nexport { AssistantProvider } from \"./utils/react-assistant-context\";\n\n// resources\nexport { Derived } from \"./Derived\";\nexport { attachDefaultPeers } from \"./attachDefaultPeers\";\n\n// tap hooks\nexport {\n  tapAssistantClientRef,\n  tapAssistantEmit,\n} from \"./utils/tap-assistant-context\";\nexport { tapClientResource } from \"./tapClientResource\";\nexport { tapClientLookup } from \"./tapClientLookup\";\nexport { tapClientList } from \"./tapClientList\";\n\n// types\nexport type {\n  ClientRegistry,\n  ClientOutput,\n  AssistantClient,\n  AssistantState,\n} from \"./types/client\";\nexport type {\n  AssistantEventName,\n  AssistantEventCallback,\n  AssistantEventPayload,\n  AssistantEventSelector,\n  AssistantEventScope,\n} from \"./types/events\";\nexport type { DefaultPeers } from \"./attachDefaultPeers\";\n"],"mappings":";AACA,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAGlC,SAAS,mBAAmB;AAC5B,SAAS,yBAAyB;AAGlC,SAAS,eAAe;AACxB,SAAS,0BAA0B;AAGnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAClC,SAAS,uBAAuB;AAChC,SAAS,qBAAqB;","names":[]}

package/dist/tapClientList.d.ts

@@ -0,0 +1,24 @@
+import type { ContravariantResource } from "@assistant-ui/tap";
+import type { ClientMethods, ClientOutputOf } from "./types/client";
+export declare const tapClientList: <TData, TState, TMethods extends ClientMethods>(props: tapClientList.Props<TData, TState, TMethods>) => {
+    state: TState[];
+    get: (lookup: {
+        index: number;
+    } | {
+        key: string;
+    }) => TMethods;
+    add: (initialData: TData) => void;
+};
+export declare namespace tapClientList {
+    type ResourceProps<TData> = {
+        key: string;
+        getInitialData: () => TData;
+        remove: () => void;
+    };
+    type Props<TData, TState, TMethods extends ClientMethods> = {
+        initialValues: TData[];
+        getKey: (data: TData) => string;
+        resource: ContravariantResource<ClientOutputOf<TState, TMethods>, ResourceProps<TData>>;
+    };
+}
+//# sourceMappingURL=tapClientList.d.ts.map