@assistant-ui/store 0.2.0 → 0.2.1

package/dist/utils/tap-assistant-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap-assistant-context.js","sourceRoot":"","sources":["../../src/utils/tap-assistant-context.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,GAAG,EACH,mBAAmB,EACnB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAAE,cAAc,EAAoB,sCAAmC;AAa9E,MAAM,mBAAmB,GACvB,qBAAqB,CAAkC,IAAI,CAAC,CAAC;AAE/D,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAC7C,KAA+B,EAC/B,EAAiB,EACjB,EAAE;IACF,OAAO,mBAAmB,CAAC,mBAAmB,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;AAC7D,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,GAAG,EAAE;IAClC,MAAM,GAAG,GAAG,GAAG,CAAC,mBAAmB,CAAC,CAAC;IACrC,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAElE,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,EAAE;IACxC,OAAO,sBAAsB,EAAE,CAAC,SAAS,CAAC;AAC5C,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,EAAE;IACnC,MAAM,EAAE,IAAI,EAAE,GAAG,sBAAsB,EAAE,CAAC;IAC1C,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IAErC,OAAO,cAAc,CACnB,CACE,KAAa,EACb,OAAsC,EACtC,EAAE;QACF,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;IACpC,CAAC,CACF,CAAC;AACJ,CAAC,CAAC"}

package/dist/utils/tap-client-stack-context.d.ts

@@ -0,0 +1,23 @@
+import type { ClientMethods } from "../types/client.js";
+/**
+ * Symbol used to get the client index from a ClientProxy.
+ */
+export declare const SYMBOL_CLIENT_INDEX: unique symbol;
+/**
+ * Get the index of a client (its position in the client stack when created).
+ */
+export declare const getClientIndex: (client: ClientMethods) => number;
+/**
+ * The client stack - an array of clients representing the current hierarchy.
+ */
+export type ClientStack = readonly ClientMethods[];
+/**
+ * Get the current client stack inside a tap resource.
+ */
+export declare const tapClientStack: () => ClientStack;
+/**
+ * Execute a callback with a client pushed onto the stack.
+ * The stack is duplicated, not mutated.
+ */
+export declare const tapWithClientStack: <T>(client: ClientMethods, callback: () => T) => T;
+//# sourceMappingURL=tap-client-stack-context.d.ts.map

package/dist/utils/tap-client-stack-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap-client-stack-context.d.ts","sourceRoot":"","sources":["../../src/utils/tap-client-stack-context.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,2BAAwB;AAErD;;GAEG;AACH,eAAO,MAAM,mBAAmB,eAA2C,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,aAAa,KAAG,MAItD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,aAAa,EAAE,CAAC;AAInD;;GAEG;AACH,eAAO,MAAM,cAAc,QAAO,WAEjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAClC,QAAQ,aAAa,EACrB,UAAU,MAAM,CAAC,KAChB,CAOF,CAAC"}

package/dist/utils/tap-client-stack-context.js

@@ -0,0 +1,28 @@
+import { createResourceContext, tap, withContextProvider, tapMemo, } from "@assistant-ui/tap";
+/**
+ * Symbol used to get the client index from a ClientProxy.
+ */
+export const SYMBOL_CLIENT_INDEX = Symbol("assistant-ui.store.clientIndex");
+/**
+ * Get the index of a client (its position in the client stack when created).
+ */
+export const getClientIndex = (client) => {
+    return client[SYMBOL_CLIENT_INDEX];
+};
+const ClientStackContext = createResourceContext([]);
+/**
+ * Get the current client stack inside a tap resource.
+ */
+export const tapClientStack = () => {
+    return tap(ClientStackContext);
+};
+/**
+ * Execute a callback with a client pushed onto the stack.
+ * The stack is duplicated, not mutated.
+ */
+export const tapWithClientStack = (client, callback) => {
+    const currentStack = tapClientStack();
+    const newStack = tapMemo(() => [...currentStack, client], [currentStack, client]);
+    return withContextProvider(ClientStackContext, newStack, callback);
+};
+//# sourceMappingURL=tap-client-stack-context.js.map

package/dist/utils/tap-client-stack-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap-client-stack-context.js","sourceRoot":"","sources":["../../src/utils/tap-client-stack-context.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,GAAG,EACH,mBAAmB,EACnB,OAAO,GACR,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,gCAAgC,CAAC,CAAC;AAE5E;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAAqB,EAAU,EAAE;IAC9D,OAAQ,MAAuD,CAC7D,mBAAmB,CACpB,CAAC;AACJ,CAAC,CAAC;AAOF,MAAM,kBAAkB,GAAG,qBAAqB,CAAc,EAAE,CAAC,CAAC;AAElE;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,GAAgB,EAAE;IAC9C,OAAO,GAAG,CAAC,kBAAkB,CAAC,CAAC;AACjC,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,MAAqB,EACrB,QAAiB,EACd,EAAE;IACL,MAAM,YAAY,GAAG,cAAc,EAAE,CAAC;IACtC,MAAM,QAAQ,GAAG,OAAO,CACtB,GAAG,EAAE,CAAC,CAAC,GAAG,YAAY,EAAE,MAAM,CAAC,EAC/B,CAAC,YAAY,EAAE,MAAM,CAAC,CACvB,CAAC;IACF,OAAO,mBAAmB,CAAC,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACrE,CAAC,CAAC"}

package/dist/wrapperResource.d.ts

@@ -0,0 +1,3 @@
+import { type ResourceElement, Resource } from "@assistant-ui/tap";
+export declare const wrapperResource: <R, P>(fn: (props: ResourceElement<P>) => R) => Resource<R, ResourceElement<P>>;
+//# sourceMappingURL=wrapperResource.d.ts.map

package/dist/wrapperResource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapperResource.d.ts","sourceRoot":"","sources":["../src/wrapperResource.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,QAAQ,EAGT,MAAM,mBAAmB,CAAC;AAE3B,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,EAClC,IAAI,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,CAAC,KACnC,QAAQ,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAOhC,CAAC"}

package/dist/wrapperResource.js

@@ -0,0 +1,11 @@
+import { resource, withKey, } from "@assistant-ui/tap";
+export const wrapperResource = (fn) => {
+    const res = resource(fn);
+    return (props) => {
+        const el = res(props);
+        if (props.key === undefined)
+            return el;
+        return withKey(props.key, el);
+    };
+};
+//# sourceMappingURL=wrapperResource.js.map

package/dist/wrapperResource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapperResource.js","sourceRoot":"","sources":["../src/wrapperResource.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,QAAQ,EACR,OAAO,GACR,MAAM,mBAAmB,CAAC;AAE3B,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,EAAoC,EACH,EAAE;IACnC,MAAM,GAAG,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC;IACzB,OAAO,CAAC,KAAyB,EAAE,EAAE;QACnC,MAAM,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;QACtB,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS;YAAE,OAAO,EAAE,CAAC;QACvC,OAAO,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/store",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Tap-based state management for @assistant-ui",
   "keywords": [
     "state-management",
@@ -28,11 +28,10 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.1.0",
-    "@assistant-ui/tap": "^0.5.0",
     "use-effect-event": "^2.0.3"
   },
   "peerDependencies": {
+    "@assistant-ui/tap": "^0.5.1",
     "@types/react": "*",
     "react": "^18 || ^19"
   },
@@ -43,11 +42,12 @@
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.2",
-    "@types/react": "^19.2.13",
+    "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "jsdom": "^28.0.0",
+    "jsdom": "^28.1.0",
     "vitest": "^4.0.18",
     "react": "^19.2.4",
+    "@assistant-ui/tap": "0.5.1",
     "@assistant-ui/x-buildutils": "0.0.1"
   },
   "publishConfig": {

package/src/AuiIf.ts

@@ -2,7 +2,7 @@
 
 import type { FC, PropsWithChildren } from "react";
 import { useAuiState } from "./useAuiState";
-import type { AssistantState } from "@assistant-ui/core/store";
+import type { AssistantState } from "./types/client";
 
 export namespace AuiIf {
   export type Props = PropsWithChildren<{ condition: AuiIf.Condition }>;

package/src/Derived.ts

@@ -0,0 +1,46 @@
+import { resource, 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 = useAui({
+ *   message: Derived({
+ *     source: "thread",
+ *     query: { index: 0 },
+ *     get: (aui) => aui.thread().message({ index: 0 }),
+ *   }),
+ * });
+ * ```
+ */
+export const Derived = resource(
+  <K extends ClientNames>(_config: Derived.Props<K>): null => {
+    return null;
+  },
+);
+
+export type DerivedElement<K extends ClientNames> = ResourceElement<
+  null,
+  Derived.Props<K>
+>;
+
+export namespace Derived {
+  /**
+   * Props passed to a derived client resource element.
+   */
+  export type Props<K extends ClientNames> = {
+    get: (client: AssistantClient) => ReturnType<AssistantClientAccessor<K>>;
+  } & (ClientMeta<K> | { getMeta: (client: AssistantClient) => ClientMeta<K> });
+}

package/src/__tests__/hooks.test.tsx

@@ -6,7 +6,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { AuiProvider } from "../utils/react-assistant-context";
 import { useAuiState } from "../useAuiState";
 import { useAuiEvent } from "../useAuiEvent";
-import { PROXIED_ASSISTANT_STATE_SYMBOL } from "@assistant-ui/core/store/internal";
+import { PROXIED_ASSISTANT_STATE_SYMBOL } from "../utils/proxied-assistant-state";
 
 afterEach(() => {
   vi.restoreAllMocks();

package/src/attachTransformScopes.ts

@@ -0,0 +1,38 @@
+import type { ResourceElement } from "@assistant-ui/tap";
+import type {
+  AssistantClient,
+  ClientElement,
+  ClientNames,
+} from "./types/client";
+import type { DerivedElement } from "./Derived";
+
+const TRANSFORM_SCOPES = Symbol("assistant-ui.transform-scopes");
+
+export type ScopesConfig = {
+  [K in ClientNames]?: ClientElement<K> | DerivedElement<K>;
+};
+
+type TransformScopesFn = (
+  scopes: ScopesConfig,
+  parent: AssistantClient,
+) => ScopesConfig;
+
+type ResourceWithTransformScopes = {
+  [TRANSFORM_SCOPES]?: TransformScopesFn;
+};
+
+export function attachTransformScopes<
+  T extends (...args: any[]) => ResourceElement<any>,
+>(resource: T, transform: TransformScopesFn): void {
+  const r = resource as T & ResourceWithTransformScopes;
+  if (r[TRANSFORM_SCOPES]) {
+    throw new Error("transformScopes is already attached to this resource");
+  }
+  r[TRANSFORM_SCOPES] = transform;
+}
+
+export function getTransformScopes<
+  T extends (...args: any[]) => ResourceElement<any>,
+>(resource: T): TransformScopesFn | undefined {
+  return (resource as T & ResourceWithTransformScopes)[TRANSFORM_SCOPES];
+}

package/src/index.ts

@@ -1,30 +1,46 @@
-// Backwards-compatible ScopeRegistry augmentation target + forwarding to core
-export type { ScopeRegistry } from "./scope-registry";
-import "./scope-registry-forward";
+// hooks
+export { useAui } from "./useAui";
+export { useAuiState } from "./useAuiState";
+export { useAuiEvent } from "./useAuiEvent";
+
+// components
+export { AuiIf } from "./AuiIf";
+export { AuiProvider } from "./utils/react-assistant-context";
 
-// Re-export framework-agnostic infrastructure from core
+// resources
+export { Derived } from "./Derived";
+export { attachTransformScopes } from "./attachTransformScopes";
+export type { ScopesConfig } from "./attachTransformScopes";
+
+// tap hooks
 export {
-  Derived,
-  attachTransformScopes,
-  type ScopesConfig,
   tapAssistantClientRef,
   tapAssistantEmit,
-  tapClientResource,
-  tapClientLookup,
-  tapClientList,
-  type ClientOutput,
-  type AssistantClient,
-  type AssistantState,
+} from "./utils/tap-assistant-context";
+export { tapClientResource } from "./tapClientResource";
+export { tapClientLookup } from "./tapClientLookup";
+export { tapClientList } from "./tapClientList";
+
+// types
+export type {
+  ScopeRegistry,
+  ClientOutput,
+  ClientMethods,
+  ClientSchema,
+  ClientNames,
+  ClientEvents,
+  ClientMeta,
+  ClientElement,
+  Unsubscribe,
+  AssistantClientAccessor,
+  AssistantClient,
+  AssistantState,
+} from "./types/client";
+export {
+  normalizeEventSelector,
   type AssistantEventName,
   type AssistantEventCallback,
   type AssistantEventPayload,
   type AssistantEventSelector,
   type AssistantEventScope,
-} from "@assistant-ui/core/store";
-
-// React-specific (stay in store)
-export { useAui } from "./useAui";
-export { useAuiState } from "./useAuiState";
-export { useAuiEvent } from "./useAuiEvent";
-export { AuiIf } from "./AuiIf";
-export { AuiProvider } from "./utils/react-assistant-context";
+} from "./types/events";

package/src/tapClientList.ts

@@ -0,0 +1,121 @@
+import { tapConst, tapState, withKey } from "@assistant-ui/tap";
+import type { ContravariantResource } from "@assistant-ui/tap";
+import { tapClientLookup } from "./tapClientLookup";
+import type { ClientMethods } from "./types/client";
+
+type InferClientState<TMethods> = TMethods extends {
+  getState: () => infer S;
+}
+  ? S
+  : unknown;
+
+type DataHandle<TData> = { data: TData | undefined; hasData: boolean };
+
+const createProps = <TData>(
+  key: string,
+  data: DataHandle<TData>,
+  remove: () => void,
+): tapClientList.ResourceProps<TData> => {
+  return {
+    key,
+    getInitialData: () => {
+      if (!data.hasData) {
+        throw new Error(
+          "getInitialData may only be called during initial render",
+        );
+      }
+      return data.data!;
+    },
+    remove,
+  };
+};
+
+export const tapClientList = <TData, TMethods extends ClientMethods>(
+  props: tapClientList.Props<TData, TMethods>,
+): {
+  state: InferClientState<TMethods>[];
+  get: (lookup: { index: number } | { key: string }) => TMethods;
+  add: (initialData: TData) => void;
+} => {
+  const { initialValues, getKey, resource: Resource } = props;
+
+  type Props = tapClientList.ResourceProps<TData>;
+
+  const initialDataHandles: DataHandle<TData>[] = tapConst(() => [], []);
+
+  const [items, setItems] = tapState<Record<string, Props>>(() => {
+    const entries: [string, Props][] = [];
+    for (const data of initialValues) {
+      const key = getKey(data);
+      const handle = { data, hasData: true };
+      entries.push([
+        key,
+        createProps(key, handle, () => {
+          setItems((items) => {
+            const newItems = { ...items };
+            delete newItems[key];
+            return newItems;
+          });
+        }),
+      ]);
+      initialDataHandles.push(handle);
+    }
+    return Object.fromEntries(entries);
+  });
+
+  const lookup = tapClientLookup<TMethods>(
+    () =>
+      Object.values(items).map((props) => withKey(props.key, Resource(props))),
+    [items, Resource],
+  );
+
+  initialDataHandles.forEach((handle) => {
+    handle.data = undefined;
+    handle.hasData = false;
+  });
+
+  const add = (data: TData) => {
+    const key = getKey(data);
+    setItems((items) => {
+      if (key in items) {
+        throw new Error(
+          `Tried to add item with a key ${key} that already exists`,
+        );
+      }
+
+      const handle = { data, hasData: true };
+      initialDataHandles.push(handle);
+
+      return {
+        ...items,
+        [key]: createProps(key, handle, () => {
+          setItems((items) => {
+            const newItems = { ...items };
+            delete newItems[key];
+            return newItems;
+          });
+        }),
+      };
+    });
+  };
+
+  return {
+    state: lookup.state,
+    get: lookup.get,
+    add,
+  };
+};
+
+export namespace tapClientList {
+  export type ResourceProps<TData> = {
+    key: string;
+    getInitialData: () => TData;
+    remove: () => void;
+  };
+
+  export type Props<TData, TMethods extends ClientMethods> = {
+    initialValues: TData[];
+    getKey: (data: TData) => string;
+    resource: ContravariantResource<TMethods, ResourceProps<TData>>;
+  };
+}

package/src/tapClientLookup.ts

@@ -0,0 +1,79 @@
+import {
+  tapMemo,
+  tapResource,
+  tapResources,
+  type ResourceElement,
+} from "@assistant-ui/tap";
+import type { ClientMethods } from "./types/client";
+import { ClientResource } from "./tapClientResource";
+import { wrapperResource } from "./wrapperResource";
+
+type InferClientState<TMethods> = TMethods extends {
+  getState: () => infer S;
+}
+  ? S
+  : unknown;
+
+const ClientResourceWithKey = wrapperResource(
+  <TMethods extends ClientMethods>(el: ResourceElement<TMethods>) => {
+    if (el.key === undefined) {
+      throw new Error("tapClientResource: Element has no key");
+    }
+    return tapResource(ClientResource(el)) as {
+      methods: TMethods;
+      state: InferClientState<TMethods>;
+      key: string | number;
+    };
+  },
+);
+
+export function tapClientLookup<TMethods extends ClientMethods>(
+  getElements: () => readonly ResourceElement<TMethods>[],
+  getElementsDeps: readonly unknown[],
+): {
+  state: InferClientState<TMethods>[];
+  get: (lookup: { index: number } | { key: string }) => TMethods;
+} {
+  const resources = tapResources(
+    () => getElements().map((el) => ClientResourceWithKey(el)),
+    // biome-ignore lint/correctness/useExhaustiveDependencies: getElementsDeps is passed through from caller
+    getElementsDeps,
+  );
+
+  const keys = tapMemo(() => Object.keys(resources), [resources]);
+
+  // For arrays, track element key -> index mapping
+  const keyToIndex = tapMemo(() => {
+    return resources.reduce(
+      (acc, resource, index) => {
+        acc[resource.key] = index;
+        return acc;
+      },
+      {} as Record<string, number>,
+    );
+  }, [resources]);
+
+  const state = tapMemo(() => {
+    return resources.map((r) => r.state);
+  }, [resources]);
+
+  return {
+    state,
+    get: (lookup: { index: number } | { key: string }) => {
+      if ("index" in lookup) {
+        if (lookup.index < 0 || lookup.index >= keys.length) {
+          throw new Error(
+            `tapClientLookup: Index ${lookup.index} out of bounds (length: ${keys.length})`,
+          );
+        }
+        return resources[lookup.index]!.methods;
+      }
+
+      const index = keyToIndex[lookup.key];
+      if (index === undefined) {
+        throw new Error(`tapClientLookup: Key "${lookup.key}" not found`);
+      }
+      return resources[index]!.methods;
+    },
+  };
+}