@assistant-ui/core 0.1.13 → 0.1.15

package/src/tests/external-store-thread-list-runtime-core.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, it, vi } from "vitest";
+import { ExternalStoreThreadListRuntimeCore } from "../runtimes/external-store/external-store-thread-list-runtime-core";
+import type { ExternalStoreThreadRuntimeCore } from "../runtimes/external-store/external-store-thread-runtime-core";
+import type { ExternalStoreThreadListAdapter } from "../runtimes/external-store/external-store-adapter";
+import { ThreadListRuntimeImpl } from "../runtime/api/thread-list-runtime";
+
+const makeFactory = () =>
+  vi.fn(
+    () =>
+      ({
+        subscribe: () => () => {},
+      }) as unknown as ExternalStoreThreadRuntimeCore,
+  );
+
+const makeAdapter = (
+  overrides: Partial<ExternalStoreThreadListAdapter> = {},
+): ExternalStoreThreadListAdapter => ({ ...overrides });
+
+describe("ExternalStoreThreadListRuntimeCore - construction", () => {
+  it("assigns a resolvable fallback mainThreadId when adapter has no threadId", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter(),
+      makeFactory(),
+    );
+    expect(typeof core.mainThreadId).toBe("string");
+    expect(core.mainThreadId.length).toBeGreaterThan(0);
+    expect(core.getItemById(core.mainThreadId)).toBeDefined();
+  });
+
+  it("picks up mainThreadId from adapter.threadId on construction (regression: #2577)", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    expect(core.mainThreadId).toBe("thread-alpha");
+  });
+
+  it("exposes threadIds from adapter.threads on construction", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({
+        threadId: "thread-alpha",
+        threads: [
+          { id: "thread-alpha", status: "regular" },
+          { id: "thread-beta", status: "regular" },
+        ],
+      }),
+      makeFactory(),
+    );
+    expect(core.threadIds).toEqual(["thread-alpha", "thread-beta"]);
+    expect(core.mainThreadId).toBe("thread-alpha");
+  });
+
+  it("creates the main thread instance exactly once on construction", () => {
+    const factory = makeFactory();
+    new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+    expect(factory).toHaveBeenCalledTimes(1);
+  });
+
+  it("creates the main thread instance exactly once when adapter has no threadId", () => {
+    const factory = makeFactory();
+    new ExternalStoreThreadListRuntimeCore(makeAdapter(), factory);
+    expect(factory).toHaveBeenCalledTimes(1);
+  });
+
+  it("binds getMainThreadRuntimeCore() to the instance produced by the factory", () => {
+    const instance = {
+      subscribe: () => () => {},
+    } as unknown as ExternalStoreThreadRuntimeCore;
+    const factory = vi.fn(() => instance);
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+    expect(core.getMainThreadRuntimeCore()).toBe(instance);
+  });
+
+  it("preserves the frozen threadItems default when the adapter has no threads", () => {
+    const a = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter(),
+      makeFactory(),
+    );
+    const b = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter(),
+      makeFactory(),
+    );
+    // Two empty-adapter constructions should share the frozen DEFAULT_THREAD_DATA
+    // singleton rather than each getting a fresh `{ ... }` clone.
+    expect(a.threadItems).toBe(b.threadItems);
+  });
+});
+
+describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
+  it("updates mainThreadId when adapter.threadId changes", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    expect(core.mainThreadId).toBe("thread-beta");
+  });
+
+  it("rebuilds the main thread instance when threadId changes", () => {
+    const factory = makeFactory();
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+    const constructionCalls = factory.mock.calls.length;
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    expect(factory.mock.calls.length).toBe(constructionCalls + 1);
+  });
+
+  it("does not rebuild the main thread when only threads array changes", () => {
+    const factory = makeFactory();
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({
+        threadId: "thread-alpha",
+        threads: [{ id: "thread-alpha", status: "regular" }],
+      }),
+      factory,
+    );
+    const constructionCalls = factory.mock.calls.length;
+    core.__internal_setAdapter(
+      makeAdapter({
+        threadId: "thread-alpha",
+        threads: [
+          { id: "thread-alpha", status: "regular" },
+          { id: "thread-beta", status: "regular" },
+        ],
+      }),
+    );
+    expect(factory.mock.calls.length).toBe(constructionCalls);
+    expect(core.threadIds).toEqual(["thread-alpha", "thread-beta"]);
+  });
+
+  it("notifies subscribers on threadId change", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    const callback = vi.fn();
+    core.subscribe(callback);
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    expect(callback).toHaveBeenCalled();
+  });
+});
+
+describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl", () => {
+  // Stub to avoid constructing the full ThreadRuntimeImpl graph when we only
+  // care about ThreadListItemRuntime.getState().isMain.
+  class NoopThreadRuntime {}
+
+  const buildImpl = (adapter: ExternalStoreThreadListAdapter) => {
+    const core = new ExternalStoreThreadListRuntimeCore(adapter, makeFactory());
+    return new ThreadListRuntimeImpl(
+      core,
+      NoopThreadRuntime as unknown as Parameters<
+        typeof ThreadListRuntimeImpl
+      >[1],
+    );
+  };
+
+  it("reports isMain=true for adapter.threadId on construction (user-visible regression: #2577)", () => {
+    const impl = buildImpl({
+      threadId: "thread-alpha",
+      threads: [
+        { id: "thread-alpha", status: "regular" },
+        { id: "thread-beta", status: "regular" },
+      ],
+    });
+    expect(impl.getItemById("thread-alpha").getState().isMain).toBe(true);
+    expect(impl.getItemById("thread-beta").getState().isMain).toBe(false);
+  });
+
+  it("reflects the main thread in the aggregated ThreadListState on construction", () => {
+    const impl = buildImpl({
+      threadId: "thread-alpha",
+      threads: [
+        { id: "thread-alpha", status: "regular" },
+        { id: "thread-beta", status: "regular" },
+      ],
+    });
+    const state = impl.getState();
+    expect(state.mainThreadId).toBe("thread-alpha");
+    expect(state.threadIds).toEqual(["thread-alpha", "thread-beta"]);
+  });
+});
+
+describe("ExternalStoreThreadListRuntimeCore - switchToThread", () => {
+  it("invokes onSwitchToThread when the target differs from mainThreadId", async () => {
+    const onSwitchToThread = vi.fn(async () => {});
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha", onSwitchToThread }),
+      makeFactory(),
+    );
+    await core.switchToThread("thread-beta");
+    expect(onSwitchToThread).toHaveBeenCalledWith("thread-beta");
+  });
+
+  it("early-returns without calling onSwitchToThread when target equals initial threadId (regression: #2577)", async () => {
+    const onSwitchToThread = vi.fn(async () => {});
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha", onSwitchToThread }),
+      makeFactory(),
+    );
+    await core.switchToThread("thread-alpha");
+    expect(onSwitchToThread).not.toHaveBeenCalled();
+  });
+});

package/src/tests/get-thread-state-isRunning.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import { getThreadState } from "../runtime/api/thread-runtime";
+import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type { ThreadMessage } from "../types/message";
+import type { ThreadListItemState } from "../runtime/api/thread-list-item-runtime";
+
+const listItem = { id: "t1" } as unknown as ThreadListItemState;
+
+const baseRuntime = (
+  overrides: Partial<ThreadRuntimeCore>,
+): ThreadRuntimeCore =>
+  ({
+    messages: [],
+    isDisabled: false,
+    isLoading: false,
+    capabilities: {} as any,
+    state: null,
+    suggestions: [],
+    extras: undefined,
+    speech: undefined,
+    voice: undefined,
+    ...overrides,
+  }) as unknown as ThreadRuntimeCore;
+
+const userMessage: ThreadMessage = {
+  id: "u1",
+  role: "user",
+  content: [],
+  createdAt: new Date(),
+  attachments: [],
+  metadata: { custom: {} },
+} as unknown as ThreadMessage;
+
+const completeAssistant: ThreadMessage = {
+  id: "a1",
+  role: "assistant",
+  content: [],
+  createdAt: new Date(),
+  status: { type: "complete", reason: "stop" },
+  metadata: { unstable_state: null, custom: {}, steps: [] },
+} as unknown as ThreadMessage;
+
+const runningAssistant: ThreadMessage = {
+  ...completeAssistant,
+  id: "a2",
+  status: { type: "running" },
+} as unknown as ThreadMessage;
+
+describe("getThreadState.isRunning", () => {
+  it("falls back to last-message heuristic when runtime.isRunning is undefined", () => {
+    expect(
+      getThreadState(baseRuntime({ messages: [runningAssistant] }), listItem)
+        .isRunning,
+    ).toBe(true);
+
+    expect(
+      getThreadState(baseRuntime({ messages: [completeAssistant] }), listItem)
+        .isRunning,
+    ).toBe(false);
+
+    expect(
+      getThreadState(baseRuntime({ messages: [userMessage] }), listItem)
+        .isRunning,
+    ).toBe(false);
+  });
+
+  it("prefers explicit runtime.isRunning=true even when last message is complete", () => {
+    expect(
+      getThreadState(
+        baseRuntime({ isRunning: true, messages: [completeAssistant] }),
+        listItem,
+      ).isRunning,
+    ).toBe(true);
+  });
+
+  it("prefers explicit runtime.isRunning=true when last message is a user message", () => {
+    expect(
+      getThreadState(
+        baseRuntime({ isRunning: true, messages: [userMessage] }),
+        listItem,
+      ).isRunning,
+    ).toBe(true);
+  });
+
+  it("prefers explicit runtime.isRunning=false even when last message is running", () => {
+    expect(
+      getThreadState(
+        baseRuntime({ isRunning: false, messages: [runningAssistant] }),
+        listItem,
+      ).isRunning,
+    ).toBe(false);
+  });
+});

package/src/tests/remote-thread-list-isLoading.test.ts

@@ -6,6 +6,7 @@ import {
   type THREAD_MAPPING_ID,
   createThreadMappingId,
 } from "../runtimes/remote-thread-list/remote-thread-state";
+import { deferred } from "./remote-thread-list-test-helpers";
 
 /**
  * Tests for the isLoading lifecycle of RemoteThreadListThreadListRuntimeCore.
@@ -70,16 +71,6 @@ const applyListResult = (
   };
 };
 
-function deferred<T>() {
-  let resolve!: (v: T) => void;
-  let reject!: (e: unknown) => void;
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}
-
 describe("RemoteThreadList isLoading lifecycle", () => {
   it("starts as true before any loading begins", () => {
     const state = new OptimisticState<RemoteThreadState>(INITIAL_STATE);
@@ -93,6 +84,7 @@ describe("RemoteThreadList isLoading lifecycle", () => {
     state.optimisticUpdate({
       execute: () => d.promise,
       loading: (s) => ({ ...s, isLoading: true }),
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -106,6 +98,7 @@ describe("RemoteThreadList isLoading lifecycle", () => {
     const promise = state.optimisticUpdate({
       execute: () => d.promise,
       loading: (s) => ({ ...s, isLoading: true }),
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -122,6 +115,7 @@ describe("RemoteThreadList isLoading lifecycle", () => {
     const promise = state.optimisticUpdate({
       execute: () => d.promise,
       loading: (s) => ({ ...s, isLoading: true }),
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -146,6 +140,7 @@ describe("RemoteThreadList isLoading lifecycle", () => {
     const promise = state.optimisticUpdate({
       execute: () => d.promise,
       loading: (s) => ({ ...s, isLoading: true }),
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -169,6 +164,7 @@ describe("RemoteThreadList isLoading error path", () => {
       .optimisticUpdate({
         execute: () => d.promise,
         loading: (s) => ({ ...s, isLoading: true }),
+        // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
         then: applyListResult,
       })
       .catch(() => {

package/src/tests/remote-thread-list-test-helpers.ts

@@ -0,0 +1,70 @@
+import { vi } from "vitest";
+import { RemoteThreadListThreadListRuntimeCore } from "../react/runtimes/RemoteThreadListThreadListRuntimeCore";
+import type { RemoteThreadListAdapter } from "../runtimes/remote-thread-list/types";
+import type { ModelContextProvider } from "../model-context/types";
+
+export function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+export const contextProvider: ModelContextProvider = {
+  getModelContext: () => ({}),
+  subscribe: () => () => {},
+};
+
+export function makeAdapter(
+  overrides: Partial<RemoteThreadListAdapter> = {},
+): RemoteThreadListAdapter {
+  return {
+    list: vi.fn(async () => ({ threads: [] })),
+    initialize: vi.fn(async (threadId: string) => ({
+      remoteId: threadId,
+      externalId: threadId,
+    })),
+    rename: vi.fn(async () => {}),
+    archive: vi.fn(async () => {}),
+    unarchive: vi.fn(async () => {}),
+    delete: vi.fn(async () => {}),
+    generateTitle: vi.fn(
+      async () =>
+        new ReadableStream({
+          start(c) {
+            c.close();
+          },
+        }) as never,
+    ),
+    fetch: vi.fn(async (id: string) => ({
+      status: "regular" as const,
+      remoteId: id,
+      externalId: id,
+      title: "Test",
+    })),
+    ...overrides,
+  };
+}
+
+export function createCore(
+  adapter: RemoteThreadListAdapter,
+  threadId?: string,
+): RemoteThreadListThreadListRuntimeCore {
+  const core = new RemoteThreadListThreadListRuntimeCore(
+    { adapter, runtimeHook: () => ({}) as never, threadId },
+    contextProvider,
+  );
+  // `startThreadRuntime` blocks until a React component attaches a runtime;
+  // stub it so non-React unit tests don't hang.
+  (
+    core as unknown as {
+      _hookManager: {
+        startThreadRuntime: (id: string) => Promise<unknown>;
+      };
+    }
+  )._hookManager.startThreadRuntime = async () => ({});
+  return core;
+}

package/src/tests/thread-list-runtime-getLoadThreadsPromise.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { ThreadListRuntimeImpl } from "../runtime/api/thread-list-runtime";
 import type { ThreadListRuntimeCore } from "../runtime/interfaces/thread-list-runtime-core";
 import { EMPTY_THREAD_CORE } from "../runtimes/remote-thread-list/empty-thread-core";
@@ -73,3 +73,19 @@ describe("ThreadListRuntime.getLoadThreadsPromise", () => {
     expect(resolved).toBe(true);
   });
 });
+
+describe("ThreadListRuntime.reload", () => {
+  it("resolves to undefined when core omits reload", async () => {
+    const runtime = new ThreadListRuntimeImpl(createMockCore());
+    await expect(runtime.reload()).resolves.toBeUndefined();
+  });
+
+  it("delegates to core.reload when implemented", async () => {
+    const reload = vi.fn<() => Promise<void>>(() => Promise.resolve());
+    const core = { ...createMockCore(), reload };
+    const runtime = new ThreadListRuntimeImpl(core);
+
+    await runtime.reload();
+    expect(reload).toHaveBeenCalledTimes(1);
+  });
+});

package/src/types/directive.ts

@@ -0,0 +1,19 @@
+import type { Unstable_TriggerItem } from "./trigger";
+
+/** Parsed segment from directive text: either literal text or a resolved directive. */
+export type Unstable_DirectiveSegment =
+  | { readonly kind: "text"; readonly text: string }
+  | {
+      readonly kind: "mention";
+      readonly type: string;
+      readonly label: string;
+      readonly id: string;
+    };
+
+/** Configurable formatter for directive serialization and parsing. */
+export type Unstable_DirectiveFormatter = {
+  /** Serialize a trigger item to directive text. */
+  serialize(item: Unstable_TriggerItem): string;
+  /** Parse text into alternating text and directive segments. */
+  parse(text: string): readonly Unstable_DirectiveSegment[];
+};

package/src/types/index.ts

@@ -40,11 +40,9 @@ export type { Unsubscribe } from "./unsubscribe";
 export type { QuoteInfo } from "./quote";
 
 export type {
-  Unstable_MentionItem,
-  Unstable_MentionCategory,
   Unstable_DirectiveSegment,
   Unstable_DirectiveFormatter,
-} from "./mention";
+} from "./directive";
 
 export type {
   Unstable_TriggerItem,

package/src/types/message.ts

@@ -4,10 +4,6 @@ import type {
 } from "assistant-stream/utils";
 import type { CompleteAttachment } from "./attachment";
 
-// =============================================================================
-// Message Parts
-// =============================================================================
-
 export type TextMessagePart = {
   readonly type: "text";
   readonly text: string;
@@ -90,10 +86,6 @@ export type ThreadAssistantMessagePart =
   | ImageMessagePart
   | DataMessagePart;
 
-// =============================================================================
-// Message Status
-// =============================================================================
-
 export type MessagePartStatus =
   | {
       readonly type: "running";
@@ -143,10 +135,6 @@ export type MessageStatus =
       readonly error?: ReadonlyJSONValue;
     };
 
-// =============================================================================
-// Thread Messages
-// =============================================================================
-
 export type MessageTiming = {
   readonly streamStartTime: number;
   readonly firstTokenTime?: number;

package/src/types/trigger.ts

@@ -1,24 +1,16 @@
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
 
-// =============================================================================
-// Trigger Item (generic item for any trigger-based popover: @mention, /command)
-// =============================================================================
-
+/** A selectable item displayed inside a trigger popover (e.g. mention, slash command). */
 export type Unstable_TriggerItem = {
   readonly id: string;
   readonly type: string;
   readonly label: string;
-  readonly icon?: string | undefined;
   readonly description?: string | undefined;
   readonly metadata?: ReadonlyJSONObject | undefined;
 };
 
-// =============================================================================
-// Trigger Category (for hierarchical navigation in trigger popovers)
-// =============================================================================
-
+/** A grouping of trigger items shown in a trigger popover. */
 export type Unstable_TriggerCategory = {
   readonly id: string;
   readonly label: string;
-  readonly icon?: string | undefined;
 };

package/src/utils/json/is-json.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   ReadonlyJSONArray,
   ReadonlyJSONObject,
   ReadonlyJSONValue,

package/dist/adapters/mention.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mention.d.ts","sourceRoot":"","sources":["../../src/adapters/mention.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,2BAA2B,EAC5B,4BAAyB;AAC1B,OAAO,KAAK,EAAE,uBAAuB,EAAE,qBAAkB;AAMzD,MAAM,MAAM,uBAAuB,GAAG,uBAAuB,CAAC;AAQ9D;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,EAAE,2BAmChD,CAAC"}

package/dist/adapters/mention.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mention.js","sourceRoot":"","sources":["../../src/adapters/mention.ts"],"names":[],"mappings":"AAaA,gFAAgF;AAChF,8BAA8B;AAC9B,gFAAgF;AAEhF,MAAM,YAAY,GAAG,6CAA6C,CAAC;AAEnE;;;;GAIG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAgC;IAC7E,SAAS,CAAC,IAA0B;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAChE,OAAO,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,KAAK,EAAE,CAAC;IAChD,CAAC;IAED,KAAK,CAAC,IAAY;QAChB,MAAM,QAAQ,GAAgC,EAAE,CAAC;QACjD,IAAI,SAAS,GAAG,CAAC,CAAC;QAElB,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC;QAC3B,IAAI,KAA6B,CAAC;QAClC,OAAO,CAAC,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAClD,IAAI,KAAK,CAAC,KAAK,GAAG,SAAS,EAAE,CAAC;gBAC5B,QAAQ,CAAC,IAAI,CAAC;oBACZ,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC;iBACzC,CAAC,CAAC;YACL,CAAC;YACD,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;YACxB,QAAQ,CAAC,IAAI,CAAC;gBACZ,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,KAAK,CAAC,CAAC,CAAE;gBACf,KAAK;gBACL,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK;aACtB,CAAC,CAAC;YACH,SAAS,GAAG,YAAY,CAAC,SAAS,CAAC;QACrC,CAAC;QAED,IAAI,SAAS,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAC/D,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/types/mention.d.ts

@@ -1,21 +0,0 @@
-import type { Unstable_TriggerItem, Unstable_TriggerCategory } from "./trigger.js";
-export type Unstable_MentionItem = Unstable_TriggerItem;
-export type Unstable_MentionCategory = Unstable_TriggerCategory;
-/** Parsed segment from directive text */
-export type Unstable_DirectiveSegment = {
-    readonly kind: "text";
-    readonly text: string;
-} | {
-    readonly kind: "mention";
-    readonly type: string;
-    readonly label: string;
-    readonly id: string;
-};
-/** Configurable formatter for mention directive serialization/parsing */
-export type Unstable_DirectiveFormatter = {
-    /** Serialize a mention item to directive text */
-    serialize(item: Unstable_MentionItem): string;
-    /** Parse text into alternating text and mention segments */
-    parse(text: string): readonly Unstable_DirectiveSegment[];
-};
-//# sourceMappingURL=mention.d.ts.map

package/dist/types/mention.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mention.d.ts","sourceRoot":"","sources":["../../src/types/mention.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,qBAAkB;AAMhF,MAAM,MAAM,oBAAoB,GAAG,oBAAoB,CAAC;AAMxD,MAAM,MAAM,wBAAwB,GAAG,wBAAwB,CAAC;AAMhE,yCAAyC;AACzC,MAAM,MAAM,yBAAyB,GACjC;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,CAAC;AAMN,yEAAyE;AACzE,MAAM,MAAM,2BAA2B,GAAG;IACxC,iDAAiD;IACjD,SAAS,CAAC,IAAI,EAAE,oBAAoB,GAAG,MAAM,CAAC;IAC9C,4DAA4D;IAC5D,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,yBAAyB,EAAE,CAAC;CAC3D,CAAC"}

package/dist/types/mention.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=mention.js.map

package/dist/types/mention.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mention.js","sourceRoot":"","sources":["../../src/types/mention.ts"],"names":[],"mappings":""}

package/src/types/mention.ts

@@ -1,39 +0,0 @@
-import type { Unstable_TriggerItem, Unstable_TriggerCategory } from "./trigger";
-
-// =============================================================================
-// Mention Item — alias of the generic TriggerItem for backward compatibility
-// =============================================================================
-
-export type Unstable_MentionItem = Unstable_TriggerItem;
-
-// =============================================================================
-// Mention Category — alias of the generic TriggerCategory
-// =============================================================================
-
-export type Unstable_MentionCategory = Unstable_TriggerCategory;
-
-// =============================================================================
-// Directive Segment (parsed representation of mention directives in text)
-// =============================================================================
-
-/** Parsed segment from directive text */
-export type Unstable_DirectiveSegment =
-  | { readonly kind: "text"; readonly text: string }
-  | {
-      readonly kind: "mention";
-      readonly type: string;
-      readonly label: string;
-      readonly id: string;
-    };
-
-// =============================================================================
-// Directive Formatter (configurable serialization/parsing for mentions)
-// =============================================================================
-
-/** Configurable formatter for mention directive serialization/parsing */
-export type Unstable_DirectiveFormatter = {
-  /** Serialize a mention item to directive text */
-  serialize(item: Unstable_MentionItem): string;
-  /** Parse text into alternating text and mention segments */
-  parse(text: string): readonly Unstable_DirectiveSegment[];
-};