better-supabase 0.8.0 → 0.10.0

package/dist/client-Fi8CoJcs.d.ts

@@ -0,0 +1,263 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, f as Result, t as AsyncResult, w as ErrorMapper } from "./result-Cj3yWhjH.js";
+import { a as AnyModels, i as AnyFunctions, z as TableKey } from "./types-BO8lVTun.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "./standard-C3_AAF3g.js";
+import { t as BlockTransport } from "./block-transport-NbUJygA7.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "./block-hooks-C_WaodoA.js";
+import { n as ExtraFields, r as FieldsOf } from "./block-fields-5UA84ZUg.js";
+import { i as EventSink, t as CloudEvent } from "./cloud-event-bwsBwVNG.js";
+import { t as BetterSupabase } from "./define-DXTC706J.js";
+import { p as SubscriptionStatus } from "./topic-Dgs-eSYQ.js";
+import { n as TopicPort } from "./watch-topic-D-rpUg5n.js";
+import { i as ListDefinition } from "./list-query-DWJIiVz_.js";
+import { n as Controller, t as AuthPort } from "./controller-CCb9tHw_.js";
+//#region src/blocks/comments/comments.d.ts
+interface CommentsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  /**
+   * A Standard Schema for the comment's extra columns
+   * (`blocks.comments.options.extraColumns`), keyed by database name. It
+   * types and parses them on reads, and validates them on `create` and
+   * `edit`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Comments<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. Default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /**
+   * The user ids a comment mentions when the call passes no `mentions`,
+   * such as the mention nodes of a rich-text `document`. Default
+   * `mentionsIn(body)`.
+   */
+  readonly mentionsOf?: (comment: {
+    readonly body: string;
+    readonly document: unknown;
+  }) => readonly string[];
+}
+/** A comment. `F` types the extra columns the `fields` schema describes. */
+interface Comment<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** `undefined` once the author's account is deleted. */
+  readonly authorId: string | undefined;
+  /** Empty for a deleted comment. */
+  readonly body: string;
+  /** The rich-text document an editor wrote, next to `body` as its plain text. */
+  readonly document: unknown;
+  readonly mentions: readonly string[];
+  readonly parentId: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly editedAt: Temporal.Instant | undefined;
+  readonly deletedAt: Temporal.Instant | undefined;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+interface NewComment<F extends object = Record<never, never>> {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly body: string;
+  /** A rich-text document (any JSON); keep `body` as its plain text. */
+  readonly document?: unknown;
+  /** User ids; default `mentionsOf`, or the ids `mentionsIn(body)` finds. */
+  readonly mentions?: readonly string[];
+  /** A reply: the parent must be on the same subject. */
+  readonly parentId?: string;
+  /** The extra columns to set, keyed by database name. */
+  readonly fields?: Partial<F>;
+}
+interface CommentEdit<F extends object = Record<never, never>> {
+  readonly body: string;
+  /** A new document; `null` removes it, and leaving it out keeps the current one. */
+  readonly document?: unknown;
+  /** Default `mentionsOf`, or the ids `mentionsIn(body)` finds. */
+  readonly mentions?: readonly string[];
+  /** The extra columns to set, keyed by database name; others keep their value. */
+  readonly fields?: Partial<F>;
+}
+/**
+ * Where a timeline entry comes from: `event` for an `activity_entries` row
+ * that `activitySink()` wrote, `audit` for an audit log entry on the
+ * subject's row (with the `audit` and `subjects` modules), `delivery` for a
+ * notification delivery about the subject (with `notifications`) and `run`
+ * for a workflow run on it (with `workflows`).
+ */
+type ActivitySource = "event" | "audit" | "delivery" | "run";
+interface ActivityEntry {
+  /** An `activity_entries` id, or the audit entry's, delivery's or run's id. */
+  readonly id: string;
+  readonly source: ActivitySource;
+  readonly organizationId: string;
+  readonly type: string;
+  readonly actorId: string | undefined;
+  readonly subjectType: string | undefined;
+  readonly subjectId: string | undefined;
+  readonly summary: string | undefined;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly occurredAt: Temporal.Instant;
+}
+interface ActivityHistoryOptions extends CursorPageOptions<Temporal.Instant> {
+  /** Entries before this instant, for paging back. */
+  readonly cursor?: Temporal.Instant;
+  /** Default 50, at most 500. */
+  readonly limit?: number;
+  /** The kinds of entry to return; all of them when left out. */
+  readonly sources?: readonly ActivitySource[];
+}
+interface ListCommentsOptions extends CursorPageOptions<Temporal.Instant> {
+  /** Comments created after this instant, for polling a thread. */
+  readonly cursor?: Temporal.Instant;
+  /**
+   * The id of the last comment you have, next to `cursor`, so comments
+   * created in the same instant as it aren't skipped.
+   */
+  readonly cursorId?: string;
+  /** Default 100, at most 500. */
+  readonly limit?: number;
+  /** Comments to skip, for page-number paging. */
+  readonly offset?: number;
+}
+/** `F` is the extra fields `options.fields` describes. */
+interface Comments<F extends object = Record<never, never>> {
+  create(comment: NewComment<F>): AsyncResult<Comment<F>>;
+  /** Only the author edits; `not_found` when the caller can't see it. */
+  edit(id: string, edit: CommentEdit<F>): AsyncResult<Comment<F>>;
+  /** Soft-deletes (the author, or a member with `comments.moderate`). */
+  remove(id: string): AsyncResult<boolean>;
+  /** A subject's thread, oldest first, deleted comments as placeholders. */
+  list(organizationId: string, subjectType: string, subjectId: string, options?: ListCommentsOptions): AsyncResult<readonly Comment<F>[]>;
+  /**
+   * How many comments each subject has that the caller can read, deleted
+   * ones left out, such as for a counter on each row of a list. Subjects
+   * without comments are 0.
+   */
+  counts(organizationId: string, subjectType: string, subjectIds: readonly string[]): AsyncResult<Readonly<Record<string, number>>>;
+  /**
+   * Copies a subject's thread to another subject in the tenant, keeping
+   * authors, times and replies; returns how many comments it copied. Needs a
+   * service-role transport.
+   */
+  copy(organizationId: string, from: {
+    readonly type: string;
+    readonly id: string;
+  }, to: {
+    readonly type: string;
+    readonly id: string;
+  }): AsyncResult<number>;
+  /**
+   * The activity feed of a tenant, newest first, or one subject's timeline
+   * with `subject`. Members with `activity.read` see it. With the `subjects`
+   * module, an entry on a registered subject type needs `can_subject` read,
+   * and a subject's timeline also lists its audit log entries
+   * (`source: "audit"`) when `audit` is installed with its read policy, the
+   * deliveries of notifications about it (`source: "delivery"`, for members
+   * who also hold `notifications.send`) and its workflow runs
+   * (`source: "run"`, as the runs' read policy allows).
+   */
+  history(organizationId: string, subject?: {
+    readonly type: string;
+    readonly id: string;
+  }, options?: ActivityHistoryOptions): AsyncResult<readonly ActivityEntry[]>;
+}
+/**
+ * The user ids mentioned in a body written as `@[Ada](<user id>)`, the
+ * markup mention inputs produce, in order and without repeats.
+ */
+declare function mentionsIn(body: string): readonly string[];
+/** Comments over the `comments` module's functions, as the caller. */
+declare function createComments<S extends StandardSchemaV1 | undefined = undefined>(options: CommentsOptions<S>): Comments<FieldsOf<S>>;
+/** What an activity entry says about an event; `null` skips the event. */
+interface ActivityDescription {
+  readonly summary?: string;
+  readonly actorId?: string;
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+interface ActivitySinkOptions {
+  /** A service-role transport: `record_activity()` is granted to `service_role` only. */
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  /** The outbox `typePrefix`, stripped from the stored type. Default `dev.better-supabase`. */
+  readonly typePrefix?: string;
+  /** Types to keep, exact or ending in `.*`. Default every event with a tenant. */
+  readonly types?: readonly string[];
+  /** Summarizes an event, or returns `null` to skip it. */
+  readonly describe?: (event: CloudEvent, type: string) => ActivityDescription | null | undefined;
+}
+/**
+ * An outbox sink that writes events into the activity feed:
+ * `outbox.relay('activity', activitySink({ transport }))`. Events without a
+ * tenant (`partitionkey`) are skipped, and a replayed event writes nothing.
+ */
+declare function activitySink(options: ActivitySinkOptions): EventSink;
+type ActivitySort = "newest" | "oldest";
+type ActivityFacet = "type" | "actor" | "subjectType" | "subjectId";
+/**
+ * A cursor-paged list over `activity_entries` (generate types for the
+ * `better_supabase` schema to get it in your models), newest first,
+ * filtered by type, actor and subject. Members with `activity.read` see
+ * their tenants' entries, less those on a registered subject that
+ * `can_subject` doesn't let them read (with the `subjects` module). It
+ * reads the table, so it lists no audit entries; `history()` does.
+ */
+declare function activityListQuery<M extends AnyModels, D, Fn extends AnyFunctions, E, T extends TableKey<M>>(betterSupabase: BetterSupabase<M, D, Fn, E>, table: T, options?: {
+  readonly pageSize?: number;
+  readonly maxPageSize?: number;
+}): ListDefinition<M, T, E, ActivitySort, ActivityFacet>;
+//#endregion
+//#region src/blocks/comments/client.d.ts
+interface CommentsControllerOptions {
+  readonly client: Pick<Comments, "list" | "create" | "edit" | "remove">;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The organization; the thread waits without one. */
+  readonly organizationId: string | null;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /**
+   * A private topic that hears of new comments on the subject, such as a
+   * `realtime-tables` topic on the comments table. Each message loads the
+   * thread again. Default `null`: the thread loads again after its own
+   * writes only.
+   */
+  readonly topic?: string | null;
+  /** The most comments to load, default 100, at most 500. */
+  readonly limit?: number;
+}
+interface CommentsSnapshot {
+  /** The thread, oldest first, deleted comments as placeholders; `undefined` until the first load. */
+  readonly comments: readonly Comment[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+/** A reply, a rich-text document or explicit mentions for `add`. */
+type CommentDraft = Pick<NewComment, "document" | "mentions" | "parentId">;
+interface CommentsActions {
+  /** Posts a comment on the subject; a failure is also kept in `error`. */
+  readonly add: (body: string, draft?: CommentDraft) => Promise<Result<Comment>>;
+  /** Edits one of the caller's comments. */
+  readonly edit: (id: string, edit: CommentEdit) => Promise<Result<Comment>>;
+  /** Soft-deletes a comment: it stays in the thread as a placeholder. */
+  readonly remove: (id: string) => Promise<Result<boolean>>;
+  readonly refresh: () => Promise<void>;
+}
+type CommentsController = Controller<CommentsSnapshot, CommentsActions>;
+/**
+ * One subject's comment thread for the signed-in user: loads it, keeps it
+ * current after `add`, `edit` and `remove`, and loads it again for each
+ * message on `topic`.
+ */
+declare function createCommentsController(options: CommentsControllerOptions): CommentsController;
+//#endregion
+export { mentionsIn as C, createComments as S, CommentsOptions as _, CommentsSnapshot as a, activityListQuery as b, ActivityEntry as c, ActivitySinkOptions as d, ActivitySort as f, Comments as g, CommentEdit as h, CommentsControllerOptions as i, ActivityFacet as l, Comment as m, CommentsActions as n, createCommentsController as o, ActivitySource as p, CommentsController as r, ActivityDescription as s, CommentDraft as t, ActivityHistoryOptions as u, ListCommentsOptions as v, activitySink as x, NewComment as y };

package/dist/client-LVa6yC9u.d.ts

@@ -0,0 +1,107 @@
+import { b as DbError } from "./result-Cj3yWhjH.js";
+import { O as AiShareLink, a as AiChatInput, c as AiChatPatch, d as AiChatShare, h as AiModel, i as AiChat, k as AiStoredMessage, l as AiChatQuery, u as AiChatRecord } from "./ai-chat-al8b3spK.js";
+import { p as SubscriptionStatus } from "./topic-Dgs-eSYQ.js";
+import { n as TopicPort } from "./watch-topic-D-rpUg5n.js";
+import { n as Controller, t as AuthPort } from "./controller-CCb9tHw_.js";
+//#region src/blocks/ai-chat/client.d.ts
+interface Ports {
+  readonly topic: TopicPort;
+}
+interface AiChatsControllerOptions {
+  readonly client: Pick<AiChat, "chats">;
+  readonly auth: AuthPort;
+  readonly ports: Ports;
+  /** The list's filters and page size. */
+  readonly query?: Omit<AiChatQuery, "cursor">;
+  /** The prefix of the list topic (`blockConfig["ai-chat"].options.listTopic` from `blocks.generated.ts`); `null` loads once. */
+  readonly topic?: string | null;
+}
+interface AiChatsSnapshot {
+  /** `undefined` until the first load. */
+  readonly items: readonly AiChatRecord[] | undefined;
+  /** Whether `loadMore` has another page. */
+  readonly hasMore: boolean;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AiChatsActions {
+  readonly loadMore: () => Promise<void>;
+  readonly refresh: () => Promise<void>;
+  readonly create: (input?: AiChatInput) => Promise<AiChatRecord | undefined>;
+  readonly update: (chatId: string, patch: AiChatPatch) => Promise<AiChatRecord | undefined>;
+  readonly remove: (chatId: string) => Promise<void>;
+}
+type AiChatsController = Controller<AiChatsSnapshot, AiChatsActions>;
+/**
+ * The signed-in user's chats in a tenant, newest first, loaded again when
+ * any of their chats changes. Pages loaded with `loadMore` load again too.
+ */
+declare function createAiChatsController(options: AiChatsControllerOptions): AiChatsController;
+interface AiChatTreeControllerOptions {
+  readonly client: {
+    readonly messages: Pick<AiChat["messages"], "path" | "switchBranch" | "siblings">;
+  };
+  readonly ports: Ports;
+  /** `null` or `undefined` waits. */
+  readonly chatId: string | null | undefined;
+  /** The prefix of the chat topic (`blockConfig["ai-chat"].options.topic` from `blocks.generated.ts`); `null` loads once. */
+  readonly topic?: string | null;
+}
+interface AiChatTreeSnapshot {
+  /** The active branch, root first; `undefined` until the first load. */
+  readonly path: readonly AiStoredMessage[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AiChatTreeActions {
+  readonly refresh: () => Promise<void>;
+  /** Shows the branch through `messageId`. */
+  readonly switchBranch: (messageId: string) => Promise<void>;
+  /** Shows the sibling `offset` places from `messageId` (`-1` older, `1` newer). */
+  readonly step: (messageId: string, offset: number) => Promise<void>;
+}
+type AiChatTreeController = Controller<AiChatTreeSnapshot, AiChatTreeActions>;
+/**
+ * One chat's active branch, loaded again when a message is saved or the
+ * branch changes, in this tab or another.
+ */
+declare function createAiChatTreeController(options: AiChatTreeControllerOptions): AiChatTreeController;
+interface AiModelsControllerOptions {
+  readonly client: {
+    readonly models: Pick<AiChat["models"], "allowed">;
+  };
+  readonly organizationId?: string | null;
+}
+interface AiModelsSnapshot {
+  /** `undefined` until loaded. */
+  readonly models: readonly AiModel[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface AiModelsActions {
+  readonly refresh: () => Promise<void>;
+}
+type AiModelsController = Controller<AiModelsSnapshot, AiModelsActions>;
+/** The models the tenant's plans allow, for a model picker. */
+declare function createAiModelsController(options: AiModelsControllerOptions): AiModelsController;
+interface AiShareControllerOptions {
+  readonly client: {
+    readonly shares: Pick<AiChat["shares"], "list" | "create" | "revoke">;
+  };
+  /** `null` or `undefined` waits. */
+  readonly chatId: string | null | undefined;
+}
+interface AiShareSnapshot {
+  /** The chat's share links, newest first; `undefined` until loaded. */
+  readonly shares: readonly AiChatShare[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface AiShareActions {
+  /** Makes a link to the active branch, or to `leafId`; the token is in the result only. */
+  readonly create: (leafId?: string) => Promise<AiShareLink | undefined>;
+  readonly revoke: (shareId: string) => Promise<void>;
+}
+type AiShareController = Controller<AiShareSnapshot, AiShareActions>;
+/** Share links for one chat the user owns. */
+declare function createAiShareController(options: AiShareControllerOptions): AiShareController;
+//#endregion
+export { createAiChatTreeController as _, AiChatsActions as a, createAiShareController as b, AiChatsSnapshot as c, AiModelsControllerOptions as d, AiModelsSnapshot as f, AiShareSnapshot as g, AiShareControllerOptions as h, AiChatTreeSnapshot as i, AiModelsActions as l, AiShareController as m, AiChatTreeController as n, AiChatsController as o, AiShareActions as p, AiChatTreeControllerOptions as r, AiChatsControllerOptions as s, AiChatTreeActions as t, AiModelsController as u, createAiChatsController as v, createAiModelsController as y };

package/dist/client-WXJwUhr1.d.ts

@@ -0,0 +1,162 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-Cj3yWhjH.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "./block-hooks-C_WaodoA.js";
+import { i as KeyboardPort } from "./ports-Dcnuo3HT.js";
+import { n as Controller } from "./controller-CCb9tHw_.js";
+//#region src/blocks/search/search.d.ts
+interface SearchOptions extends Pick<BlockOptions, "transport" | "service" | "schema" | "mappers"> {
+  /** `withBlockHooks` hooks around the methods. */
+  readonly hooks?: BlockHooks<Search>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** One match, with the title and URL from `config.subjects`. */
+interface SearchHit {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  /** A fragment of the body around the match, without markup. */
+  readonly snippet: string | null;
+  readonly score: number;
+}
+interface SearchQuery {
+  /** Subject types to search. Default: every type with a `search` entry. */
+  readonly types?: readonly string[];
+  /** One tenant. Default: every tenant the caller can read. */
+  readonly organizationId?: string | null;
+  /** At most 100. Default 20. */
+  readonly limit?: number;
+  /**
+   * The query's embedding, when the index keeps embeddings
+   * (`blocks.search.options.dimensions` and `vector-search`): the
+   * results fuse full-text and nearest-neighbour ranks.
+   */
+  readonly embedding?: readonly number[] | null;
+}
+/** A subject the caller opened or starred (the share-links per-user state). */
+interface SearchUserItem {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  readonly openedAt: Temporal.Instant | undefined;
+  readonly starredAt: Temporal.Instant | undefined;
+}
+interface SearchListOptions {
+  /** At most 100. Default 10. */
+  readonly limit?: number;
+  readonly types?: readonly string[];
+}
+/** A document whose text has no embedding yet. */
+interface PendingEmbedding {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** Pass it back to `setEmbedding`, which skips text that changed since. */
+  readonly contentHash: string;
+  /** The title and body to embed. */
+  readonly text: string;
+}
+/** Embeds texts in order, one vector per text: an AI SDK `embedMany` call. */
+type Embedder = (texts: readonly string[]) => Promise<readonly (readonly number[])[]>;
+interface Search {
+  /**
+   * Searches as the caller: `websearch_to_tsquery` syntax (`"exact phrase"`,
+   * `-word`, `or`), prefixes for typeahead and trigram matches for typos.
+   * Rows the caller can't read, and trashed rows, are left out.
+   */
+  search(q: string, query?: SearchQuery): AsyncResult<readonly SearchHit[]>;
+  /** The caller's recently opened subjects, newest first. */
+  recents(options?: SearchListOptions): AsyncResult<readonly SearchUserItem[]>;
+  /** The caller's starred subjects, newest first. */
+  favorites(options?: SearchListOptions): AsyncResult<readonly SearchUserItem[]>;
+  /** Records that the caller opened a subject, for `recents`. */
+  touch(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Stars or unstars a subject for the caller, for `favorites`. */
+  star(subjectType: string, subjectId: string, starred?: boolean): AsyncResult<boolean>;
+  /** Reads one row into the index again. Service only. */
+  refresh(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Drops one subject from the index. Service only. */
+  remove(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Indexes every row of one type, or of all of them. Service only. */
+  reindex(subjectType?: string): AsyncResult<number>;
+  /** Documents without an embedding, oldest first. Service only. */
+  pendingEmbeddings(limit?: number): AsyncResult<readonly PendingEmbedding[]>;
+  /** Stores an embedding unless the text changed. Service only. */
+  setEmbedding(document: Pick<PendingEmbedding, "subjectType" | "subjectId" | "contentHash">, embedding: readonly number[]): AsyncResult<boolean>;
+  /**
+   * Embeds up to `limit` pending documents with `embed` and stores them.
+   * Run it from a job or cron. Service only. Resolves to the number stored.
+   */
+  embedPending(embed: Embedder, limit?: number): AsyncResult<number>;
+}
+/**
+ * The `search` SQL module as typed calls. Build it with the caller's
+ * transport for `search`, `recents` and `favorites`, and pass `service` for
+ * the index maintenance methods.
+ */
+declare function createSearch(options: SearchOptions): Search;
+//#endregion
+//#region src/blocks/search/groups.d.ts
+/** A row of the dialog: a match, a recent or a favorite. */
+interface CommandSearchItem {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  readonly snippet?: string | null;
+}
+/** One heading of the dialog: `favorites`, `recents`, or a subject type. */
+interface CommandSearchGroup {
+  readonly key: string;
+  readonly items: readonly CommandSearchItem[];
+}
+/** Groups matches by subject type, in the order the best match of each appears. */
+declare function groupHits(hits: readonly SearchHit[]): readonly CommandSearchGroup[];
+//#endregion
+//#region src/blocks/search/client.d.ts
+interface CommandSearchOptions {
+  readonly client: Pick<Search, "search" | "recents" | "favorites" | "touch" | "star">;
+  /** Toggles the dialog on Cmd+K and Ctrl+K. Without it there is no shortcut. */
+  readonly keyboard?: KeyboardPort;
+  /** One tenant. Default: every tenant the caller can read. */
+  readonly organizationId?: string | null;
+  readonly types?: readonly string[];
+  /** Results per query. Default 20. */
+  readonly limit?: number;
+  /** Recents and favorites shown before the user types. Default 5. */
+  readonly listLimit?: number;
+  /** Milliseconds between the last keystroke and the query. Default 150. */
+  readonly debounceMs?: number;
+}
+interface CommandSearchSnapshot {
+  readonly open: boolean;
+  readonly query: string;
+  /** Favorites and recents for an empty query, otherwise the matches by subject type. */
+  readonly groups: readonly CommandSearchGroup[];
+  readonly results: readonly SearchHit[];
+  readonly recents: readonly SearchUserItem[];
+  readonly favorites: readonly SearchUserItem[];
+  /** True while a query newer than `results` is running. */
+  readonly loading: boolean;
+  readonly error: DbError | undefined;
+}
+interface CommandSearchActions {
+  readonly setOpen: (open: boolean) => void;
+  readonly setQuery: (query: string) => void;
+  /** Records the item as opened (for recents) and closes the dialog. */
+  readonly select: (item: CommandSearchItem) => Promise<void>;
+  readonly star: (item: CommandSearchItem, starred?: boolean) => Promise<void>;
+}
+type CommandSearchController = Controller<CommandSearchSnapshot, CommandSearchActions>;
+/**
+ * State for a Cmd+K dialog over the `search` module: a debounced query that
+ * ignores stale responses, favorites and recents for an empty query, and
+ * `select` that records the open.
+ */
+declare function createCommandSearchController(options: CommandSearchOptions): CommandSearchController;
+//#endregion
+export { createSearch as _, createCommandSearchController as a, groupHits as c, Search as d, SearchHit as f, SearchUserItem as g, SearchQuery as h, CommandSearchSnapshot as i, Embedder as l, SearchOptions as m, CommandSearchController as n, CommandSearchGroup as o, SearchListOptions as p, CommandSearchOptions as r, CommandSearchItem as s, CommandSearchActions as t, PendingEmbedding as u };