@arbidocs/blocks 0.3.185 → 0.4.1

package/dist/components/editorial/index.d.ts

@@ -0,0 +1,12 @@
+export { Eyebrow, type EyebrowProps } from './Eyebrow';
+export { EditorialHeading, type EditorialHeadingProps } from './EditorialHeading';
+export { EditorialHero, type EditorialHeroProps, type EditorialHeroTestIds, type EditorialSurface, } from './EditorialHero';
+export { EditorialSection, EditorialProse, type EditorialSectionProps, type EditorialProseProps, } from './EditorialSection';
+export { PanelGrid, type PanelGridProps, type PanelItem } from './PanelGrid';
+export { DefinitionList, CheckList, TagList, type DefinitionListProps, type DefinitionItem, type CheckListProps, type TagListProps, } from './lists';
+export { PullQuote, type PullQuoteProps } from './PullQuote';
+export { ArticleList, type ArticleListProps, type ArticleItem } from './ArticleList';
+export { ProfileCard, type ProfileCardProps } from './ProfileCard';
+export { ProofStrip, CtaBand, type ProofStripProps, type CtaBandProps } from './Bands';
+export { Reveal, type RevealProps } from './Reveal';
+export { type EditorialTone } from './tone';

package/dist/components/editorial/lists.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+export interface DefinitionItem {
+    term: ReactNode;
+    description: ReactNode;
+    /** A leading icon; without one the `dot` marker is used when `marker="dot"`. */
+    icon?: ReactNode;
+    testId?: string;
+}
+export interface DefinitionListProps {
+    items: DefinitionItem[];
+    /**
+     * `rows`: each entry is a lifted row with a marker. `ruled`: a spec sheet, term and description
+     * side by side between hairlines.
+     */
+    layout?: 'rows' | 'ruled';
+    /** Marker of an entry with no `icon` in the `rows` layout. */
+    marker?: 'dot' | 'none';
+    className?: string;
+    testId?: string;
+}
+/** Term and description pairs (`<dl>`): feature rows, a spec sheet, a definition list. */
+export declare function DefinitionList({ items, layout, marker, className, testId, }: DefinitionListProps): import("react").JSX.Element;
+export interface CheckListProps {
+    items: ReactNode[];
+    /** Two columns from `sm` up. */
+    columns?: 1 | 2;
+    /** Replaces the check mark. */
+    icon?: ReactNode;
+    className?: string;
+    testId?: string;
+}
+/** A list of points, each with a ringed check mark. */
+export declare function CheckList({ items, columns, icon, className, testId }: CheckListProps): import("react").JSX.Element;
+export interface TagListProps {
+    items: string[];
+    /** Accessible name of the list. */
+    label?: string;
+    className?: string;
+    testId?: string;
+}
+/** Small bordered chips: sectors, focus areas, topics. */
+export declare function TagList({ items, label, className, testId }: TagListProps): import("react").JSX.Element | null;

package/dist/components/editorial/tone.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Editorial parts read their colours from the theme tokens only. `inverse` flips the page
+ * tokens (`bg-foreground text-background`) for dark bands on a light theme; on a theme that is
+ * already dark, leave `default` and let the host tokens do the work.
+ */
+export type EditorialTone = 'default' | 'inverse';
+export interface EditorialToneClasses {
+    /** Body text colour of the band. */
+    text: string;
+    /** Secondary copy (lede, descriptions). */
+    muted: string;
+    /** Tertiary copy (meta lines, small print). */
+    subtle: string;
+    /** Accent text (links, kickers, markers). */
+    accent: string;
+    /** Hairline between rows and around bands. */
+    hairline: string;
+    /** A lifted surface (panel, row, chip). */
+    panel: string;
+    /** Hover state of an interactive panel. */
+    panelHover: string;
+    /** Small bordered chip. */
+    chip: string;
+    /** Icon tile. */
+    tile: string;
+}
+export declare const EditorialToneContext: import("react").Context<EditorialTone>;
+/** The tone of the enclosing band, unless a part overrides it. */
+export declare function useEditorialTone(override?: EditorialTone): EditorialToneClasses & {
+    tone: EditorialTone;
+};
+/** `01`, `02`, ... for a numbered label; strings pass through. */
+export declare function formatIndex(index: number | string): string;

package/dist/components/tones.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The ONE status/tone vocabulary of the blocks. `StatusPill`, `ToneBadge`, `Dot` and the plan,
+ * connection and tag chips all read these maps, so a tone looks the same wherever it appears and
+ * a new tone is added in one place. Every pair is a token pair checked by
+ * `tokens.contrast.test.ts` (`--{hue}-text` on `--{hue}-bg`).
+ */
+/** Semantic tones, mapped to the token palette (`--{hue}-bg|text|border`, `--ai-*`). */
+export type Tone = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'accent' | 'ai';
+/** Background + text of a tinted chip. */
+export declare const TONE_SURFACE: Record<Tone, string>;
+/** Border of a tinted chip (the AI tint has none). */
+export declare const TONE_BORDER: Record<Tone, string>;
+/** Solid fill of a status dot. */
+export declare const TONE_DOT: Record<Tone, string>;

package/dist/connect/index.cjs

@@ -0,0 +1,65 @@
+"use client";
+'use strict';
+
+var chunkG3G7LZPM_cjs = require('../chunk-G3G7LZPM.cjs');
+var react = require('react');
+var reactQuery = require('@tanstack/react-query');
+var react$1 = require('@arbidocs/react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function ConnectionBoundWebSocket({ children }) {
+  const { status } = chunkG3G7LZPM_cjs.useConnection();
+  return /* @__PURE__ */ jsxRuntime.jsx(react$1.ArbiWebSocketProvider, { enabled: status === "authenticated", children });
+}
+function ArbiAppProvider({
+  config,
+  children
+}) {
+  const [queryClient] = react.useState(
+    () => new reactQuery.QueryClient({
+      defaultOptions: { queries: { staleTime: 3e4, retry: 1, refetchOnWindowFocus: false } }
+    })
+  );
+  const providerUrl = config.apiUrl || config.demoApiUrl || "https://demo.arbi.local";
+  return /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsxRuntime.jsx(react$1.ArbiProvider, { url: providerUrl, children: /* @__PURE__ */ jsxRuntime.jsx(chunkG3G7LZPM_cjs.ConnectionProvider, { config, children: /* @__PURE__ */ jsxRuntime.jsx(ConnectionBoundWebSocket, { children }) }) }) });
+}
+
+Object.defineProperty(exports, "ConnectionProvider", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.ConnectionProvider; }
+});
+Object.defineProperty(exports, "isAuthenticated", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.isAuthenticated; }
+});
+Object.defineProperty(exports, "redlineStats", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.redlineStats; }
+});
+Object.defineProperty(exports, "textToArtifact", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.textToArtifact; }
+});
+Object.defineProperty(exports, "toRedlineMarkdown", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.toRedlineMarkdown; }
+});
+Object.defineProperty(exports, "useConnectedAiTask", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.useConnectedAiTask; }
+});
+Object.defineProperty(exports, "useConnection", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.useConnection; }
+});
+Object.defineProperty(exports, "useSemanticSearch", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.useSemanticSearch; }
+});
+Object.defineProperty(exports, "useWorkspaceDocs", {
+  enumerable: true,
+  get: function () { return chunkG3G7LZPM_cjs.useWorkspaceDocs; }
+});
+exports.ArbiAppProvider = ArbiAppProvider;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/connect/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/connection/ArbiAppProvider.tsx"],"names":["useConnection","jsx","ArbiWebSocketProvider","useState","QueryClient","QueryClientProvider","ArbiProvider","ConnectionProvider"],"mappings":";;;;;;;;AAqBA,SAAS,wBAAA,CAAyB,EAAE,QAAA,EAAS,EAA4B;AACvE,EAAA,MAAM,EAAE,MAAA,EAAO,GAAIA,+BAAA,EAAc;AACjC,EAAA,uBACEC,cAAA,CAACC,6BAAA,EAAA,EAAsB,OAAA,EAAS,MAAA,KAAW,iBAAkB,QAAA,EAAS,CAAA;AAE1E;AAEO,SAAS,eAAA,CAAgB;AAAA,EAC9B,MAAA;AAAA,EACA;AACF,CAAA,EAGG;AACD,EAAA,MAAM,CAAC,WAAW,CAAA,GAAIC,cAAA;AAAA,IACpB,MACE,IAAIC,sBAAA,CAAY;AAAA,MACd,cAAA,EAAgB,EAAE,OAAA,EAAS,EAAE,SAAA,EAAW,KAAQ,KAAA,EAAO,CAAA,EAAG,oBAAA,EAAsB,KAAA,EAAM;AAAE,KACzF;AAAA,GACL;AAEA,EAAA,MAAM,WAAA,GAAc,MAAA,CAAO,MAAA,IAAU,MAAA,CAAO,UAAA,IAAc,yBAAA;AAE1D,EAAA,sCACGC,8BAAA,EAAA,EAAoB,MAAA,EAAQ,WAAA,EAC3B,QAAA,kBAAAJ,cAAA,CAACK,wBAAa,GAAA,EAAK,WAAA,EACjB,QAAA,kBAAAL,cAAA,CAACM,oCAAA,EAAA,EAAmB,QAClB,QAAA,kBAAAN,cAAA,CAAC,wBAAA,EAAA,EAA0B,QAAA,EAAS,CAAA,EACtC,GACF,CAAA,EACF,CAAA;AAEJ","file":"index.cjs","sourcesContent":["/**\n * Composition root for a host app on the ARBI React SDK.\n *\n *   QueryClientProvider  → react-query cache shared with the SDK\n *     ArbiProvider       → the SDK's Arbi instance (no network until login)\n *       ConnectionProvider → demo/live auth + workspace layer\n *\n * With no live `apiUrl`, ArbiProvider is still mounted (cheap, inert) against\n * `demoApiUrl` and the app runs entirely in seeded demo mode.\n */\nimport { useState, type ReactNode } from 'react'\nimport { QueryClient, QueryClientProvider } from '@tanstack/react-query'\nimport { ArbiProvider, ArbiWebSocketProvider } from '@arbidocs/react'\nimport { ConnectionProvider, useConnection } from './ConnectionProvider'\nimport type { ArbiConnectionConfig } from './types'\n\n/**\n * Opens the shared SDK WebSocket once the app is live-authenticated (demo /\n * logged-out sessions have no backend, so they stay disconnected). Lives inside\n * ConnectionProvider so it can read the live status.\n */\nfunction ConnectionBoundWebSocket({ children }: { children: ReactNode }) {\n  const { status } = useConnection()\n  return (\n    <ArbiWebSocketProvider enabled={status === 'authenticated'}>{children}</ArbiWebSocketProvider>\n  )\n}\n\nexport function ArbiAppProvider({\n  config,\n  children,\n}: {\n  config: ArbiConnectionConfig\n  children: ReactNode\n}) {\n  const [queryClient] = useState(\n    () =>\n      new QueryClient({\n        defaultOptions: { queries: { staleTime: 30_000, retry: 1, refetchOnWindowFocus: false } },\n      })\n  )\n\n  const providerUrl = config.apiUrl || config.demoApiUrl || 'https://demo.arbi.local'\n\n  return (\n    <QueryClientProvider client={queryClient}>\n      <ArbiProvider url={providerUrl}>\n        <ConnectionProvider config={config}>\n          <ConnectionBoundWebSocket>{children}</ConnectionBoundWebSocket>\n        </ConnectionProvider>\n      </ArbiProvider>\n    </QueryClientProvider>\n  )\n}\n"]}

package/dist/connect/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @arbidocs/blocks/connect: the demo/live connection layer (auth, workspace selection, agent
+ * hooks, React Query + ARBI provider). Kept off the root barrel because it needs React Query.
+ */
+export { type ArbiMode, type ConnectionStatus, type ArbiUser, type AssistantStep, type AssistantCitation, type AssistantMessage, type ArbiConnectionConfig, } from '../connection/types';
+export { ConnectionProvider, useConnection, isAuthenticated, } from '../connection/ConnectionProvider';
+export { ArbiAppProvider } from '../connection/ArbiAppProvider';
+export { useConnectedAiTask, useWorkspaceDocs, useSemanticSearch, toRedlineMarkdown, redlineStats, textToArtifact, type AiTaskStatus, type AiRunOptions, type SearchChunk, type ArtifactEvent, } from '../connection/ai';

package/dist/connect/index.js

@@ -0,0 +1,28 @@
+"use client";
+import { ConnectionProvider, useConnection } from '../chunk-YBXCZEWS.js';
+export { ConnectionProvider, isAuthenticated, redlineStats, textToArtifact, toRedlineMarkdown, useConnectedAiTask, useConnection, useSemanticSearch, useWorkspaceDocs } from '../chunk-YBXCZEWS.js';
+import { useState } from 'react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { ArbiProvider, ArbiWebSocketProvider } from '@arbidocs/react';
+import { jsx } from 'react/jsx-runtime';
+
+function ConnectionBoundWebSocket({ children }) {
+  const { status } = useConnection();
+  return /* @__PURE__ */ jsx(ArbiWebSocketProvider, { enabled: status === "authenticated", children });
+}
+function ArbiAppProvider({
+  config,
+  children
+}) {
+  const [queryClient] = useState(
+    () => new QueryClient({
+      defaultOptions: { queries: { staleTime: 3e4, retry: 1, refetchOnWindowFocus: false } }
+    })
+  );
+  const providerUrl = config.apiUrl || config.demoApiUrl || "https://demo.arbi.local";
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(ArbiProvider, { url: providerUrl, children: /* @__PURE__ */ jsx(ConnectionProvider, { config, children: /* @__PURE__ */ jsx(ConnectionBoundWebSocket, { children }) }) }) });
+}
+
+export { ArbiAppProvider };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/connect/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/connection/ArbiAppProvider.tsx"],"names":[],"mappings":";;;;;;;AAqBA,SAAS,wBAAA,CAAyB,EAAE,QAAA,EAAS,EAA4B;AACvE,EAAA,MAAM,EAAE,MAAA,EAAO,GAAI,aAAA,EAAc;AACjC,EAAA,uBACE,GAAA,CAAC,qBAAA,EAAA,EAAsB,OAAA,EAAS,MAAA,KAAW,iBAAkB,QAAA,EAAS,CAAA;AAE1E;AAEO,SAAS,eAAA,CAAgB;AAAA,EAC9B,MAAA;AAAA,EACA;AACF,CAAA,EAGG;AACD,EAAA,MAAM,CAAC,WAAW,CAAA,GAAI,QAAA;AAAA,IACpB,MACE,IAAI,WAAA,CAAY;AAAA,MACd,cAAA,EAAgB,EAAE,OAAA,EAAS,EAAE,SAAA,EAAW,KAAQ,KAAA,EAAO,CAAA,EAAG,oBAAA,EAAsB,KAAA,EAAM;AAAE,KACzF;AAAA,GACL;AAEA,EAAA,MAAM,WAAA,GAAc,MAAA,CAAO,MAAA,IAAU,MAAA,CAAO,UAAA,IAAc,yBAAA;AAE1D,EAAA,2BACG,mBAAA,EAAA,EAAoB,MAAA,EAAQ,WAAA,EAC3B,QAAA,kBAAA,GAAA,CAAC,gBAAa,GAAA,EAAK,WAAA,EACjB,QAAA,kBAAA,GAAA,CAAC,kBAAA,EAAA,EAAmB,QAClB,QAAA,kBAAA,GAAA,CAAC,wBAAA,EAAA,EAA0B,QAAA,EAAS,CAAA,EACtC,GACF,CAAA,EACF,CAAA;AAEJ","file":"index.js","sourcesContent":["/**\n * Composition root for a host app on the ARBI React SDK.\n *\n *   QueryClientProvider  → react-query cache shared with the SDK\n *     ArbiProvider       → the SDK's Arbi instance (no network until login)\n *       ConnectionProvider → demo/live auth + workspace layer\n *\n * With no live `apiUrl`, ArbiProvider is still mounted (cheap, inert) against\n * `demoApiUrl` and the app runs entirely in seeded demo mode.\n */\nimport { useState, type ReactNode } from 'react'\nimport { QueryClient, QueryClientProvider } from '@tanstack/react-query'\nimport { ArbiProvider, ArbiWebSocketProvider } from '@arbidocs/react'\nimport { ConnectionProvider, useConnection } from './ConnectionProvider'\nimport type { ArbiConnectionConfig } from './types'\n\n/**\n * Opens the shared SDK WebSocket once the app is live-authenticated (demo /\n * logged-out sessions have no backend, so they stay disconnected). Lives inside\n * ConnectionProvider so it can read the live status.\n */\nfunction ConnectionBoundWebSocket({ children }: { children: ReactNode }) {\n  const { status } = useConnection()\n  return (\n    <ArbiWebSocketProvider enabled={status === 'authenticated'}>{children}</ArbiWebSocketProvider>\n  )\n}\n\nexport function ArbiAppProvider({\n  config,\n  children,\n}: {\n  config: ArbiConnectionConfig\n  children: ReactNode\n}) {\n  const [queryClient] = useState(\n    () =>\n      new QueryClient({\n        defaultOptions: { queries: { staleTime: 30_000, retry: 1, refetchOnWindowFocus: false } },\n      })\n  )\n\n  const providerUrl = config.apiUrl || config.demoApiUrl || 'https://demo.arbi.local'\n\n  return (\n    <QueryClientProvider client={queryClient}>\n      <ArbiProvider url={providerUrl}>\n        <ConnectionProvider config={config}>\n          <ConnectionBoundWebSocket>{children}</ConnectionBoundWebSocket>\n        </ConnectionProvider>\n      </ArbiProvider>\n    </QueryClientProvider>\n  )\n}\n"]}

package/dist/connection/ArbiAppProvider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Composition root for a host app on the ARBI React SDK.
+ *
+ *   QueryClientProvider  → react-query cache shared with the SDK
+ *     ArbiProvider       → the SDK's Arbi instance (no network until login)
+ *       ConnectionProvider → demo/live auth + workspace layer
+ *
+ * With no live `apiUrl`, ArbiProvider is still mounted (cheap, inert) against
+ * `demoApiUrl` and the app runs entirely in seeded demo mode.
+ */
+import { type ReactNode } from 'react';
+import type { ArbiConnectionConfig } from './types';
+export declare function ArbiAppProvider({ config, children, }: {
+    config: ArbiConnectionConfig;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/connection/ConnectionProvider.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The demo/live connection layer for a host app. Holds auth + workspace
+ * selection state and exposes it via {@link useConnection}, so every surface
+ * works identically whether it's talking to a live ARBI backend or the seeded
+ * demo workspace. Host-specific values (backend URL, demo identity, default
+ * workspace/assistant ids) arrive once through {@link ArbiConnectionConfig}.
+ */
+import { type ReactNode } from 'react';
+import type { ArbiMode, ArbiUser, ConnectionStatus, ArbiConnectionConfig } from './types';
+interface ConnectionValue {
+    mode: ArbiMode;
+    status: ConnectionStatus;
+    user: ArbiUser | null;
+    workspaceId: string | null;
+    apiConfigured: boolean;
+    apiUrl: string;
+    error: string | null;
+    /** Default assistant config ext_id (for the AI hooks). */
+    assistantConfig?: string;
+    /** Fallback workspace ext_id when none is actively selected. */
+    fallbackWorkspaceId?: string;
+    /** Authenticate. Live login when a backend is configured, otherwise the demo workspace. */
+    login: (email: string, password: string) => Promise<void>;
+    /** One-click demo entry (no backend required). */
+    enterDemo: () => void;
+    logout: () => void;
+    /**
+     * Affirmatively select a workspace: opens it on the server (via the SDK),
+     * updates the app-wide state, and persists the choice so it survives future
+     * logins. This is the single entry point for "the user is now in workspace X".
+     */
+    setWorkspace: (id: string) => Promise<void>;
+    /**
+     * Re-assert the selected workspace on the server session (idempotent `/open`).
+     * Call before a workspace-scoped write when the session may have lost its open
+     * workspace (token re-login, backend restart, session expiry) — the server
+     * resolves the workspace from the session, so a dropped `/open` yields
+     * "No active workspace" until it's re-opened.
+     */
+    ensureWorkspaceOpen: () => Promise<void>;
+}
+/** Exported for tests. */
+export declare const workspaceStorageKey: (apiUrl: string, userKey: string) => string;
+export declare function ConnectionProvider({ config, children, }: {
+    config: ArbiConnectionConfig;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useConnection(): ConnectionValue;
+export declare const isAuthenticated: (s: ConnectionStatus) => s is "demo" | "authenticated";
+export {};

package/dist/connection/ai.d.ts

@@ -0,0 +1,99 @@
+import { type AiRunOptions } from '@arbidocs/react';
+export type { AiTaskStatus, AiRunOptions, SearchChunk, ArtifactEvent } from '@arbidocs/react';
+/** Client-side redlining, re-exported so a host app has one import surface. */
+export { toRedlineMarkdown, redlineStats, textToArtifact } from '@arbidocs/react';
+/**
+ * The kit's `useAiTask` with the host's default assistant configuration
+ * injected, so call sites needn't know the config ext_id.
+ */
+export declare function useConnectedAiTask(): {
+    run: (question: string, docIds: string[], opts?: AiRunOptions) => Promise<import("@arbidocs/react").SSEStreamResult | null>;
+    status: import("@arbidocs/react").AiTaskStatus;
+    text: string;
+    stepCount: number;
+    error: string | null;
+    responseId: string | null;
+    artifacts: {
+        t?: number | null;
+        type: "arbi.artifact";
+        doc_ext_id: string;
+        title: string;
+        mode: "markdown" | "html" | "text" | "image";
+        content: string;
+        file_type: string;
+        is_complete: boolean;
+        version: number;
+        message_ext_id?: string | null;
+    }[];
+    reset: () => void;
+    isRunning: boolean;
+    isDone: boolean;
+};
+/** Resolve the active workspace + its document ids (what we ground the agent on). */
+export declare function useWorkspaceDocs(): {
+    wsId: string | undefined;
+    docs: {
+        external_id: string;
+        workspace_ext_id: string;
+        file_name?: string | null | undefined;
+        status?: string | null | undefined;
+        error_message?: string | null | undefined;
+        failed_stage?: string | null | undefined;
+        n_pages?: number | null | undefined;
+        n_chunks?: number | null | undefined;
+        tokens?: number | null | undefined;
+        file_type?: string | null | undefined;
+        file_size?: number | null | undefined;
+        storage_type?: string | null | undefined;
+        storage_uri?: string | null | undefined;
+        content_hash?: string | null | undefined;
+        shared?: boolean | null | undefined;
+        re_ocred?: boolean | null | undefined;
+        config_ext_id?: string | null | undefined;
+        parent_ext_id?: string | null | undefined;
+        created_by_ext_id: string;
+        updated_by_ext_id?: string | null | undefined;
+        created_at: string;
+        updated_at: string;
+        wp_type?: string | null | undefined;
+        folder?: string | null | undefined;
+        sender?: string | null | undefined;
+        doctags: {
+            note?: string | null | undefined;
+            citations?: {
+                doc_ext_id: string;
+                chunks?: {
+                    chunk_id: string;
+                    page?: number | null | undefined;
+                }[] | undefined;
+            }[] | null | undefined;
+            external_id: string;
+            doc_ext_id: string;
+            tag_ext_id: string;
+            created_by_ext_id: string;
+            updated_by_ext_id?: string | null | undefined;
+            created_at: string;
+            updated_at: string;
+        }[];
+        doc_metadata?: {
+            doc_nature?: string | null | undefined;
+            doc_author?: string | null | undefined;
+            doc_subject?: string | null | undefined;
+            doc_date?: string | null | undefined;
+            title?: string | null | undefined;
+        } | null | undefined;
+    }[];
+    docIds: string[];
+    isLoading: boolean;
+    isError: boolean;
+    ready: boolean;
+};
+/** Search the active workspace's documents and return the top matching passages. */
+export declare function useSemanticSearch(): {
+    query: string;
+    results: import("@arbidocs/react").SearchChunk[];
+    status: import("@arbidocs/react").AiTaskStatus;
+    error: string | null;
+    search: (q: string, mode?: "semantic" | "keyword" | "hybrid") => Promise<void>;
+    isRunning: boolean;
+};

package/dist/connection/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared shapes for the ARBI adapter — identical in demo and live mode so UI
+ * never needs to know which backend is serving it — plus the per-app config a
+ * host app supplies once to wire the connection + AI layer.
+ */
+export type ArbiMode = 'demo' | 'live';
+export type ConnectionStatus = 'demo' | 'disconnected' | 'connecting' | 'authenticated' | 'error';
+export interface ArbiUser {
+    name: string;
+    email: string;
+    /** The user's external_id (usr-…), when known (live sessions). */
+    externalId?: string;
+    /** Avatar image URL / data-URL from the backend profile, when set. */
+    picture?: string | null;
+}
+/** A retrieval-augmented answer step surfaced from the agent loop. */
+export interface AssistantStep {
+    label: string;
+    detail?: string;
+    status: 'done' | 'running' | 'queued';
+}
+export interface AssistantCitation {
+    docId: string;
+    docName: string;
+    page?: number;
+    quote: string;
+}
+export interface AssistantMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    steps?: AssistantStep[];
+    citations?: AssistantCitation[];
+    streaming?: boolean;
+}
+/**
+ * Everything host-specific about the ARBI wiring, injected once at the app root.
+ * Framework-agnostic on purpose: the app reads its own env (Vite, Next, …) and
+ * passes the resolved values in, so the package never touches `import.meta.env`.
+ */
+export interface ArbiConnectionConfig {
+    /** Live backend URL. Empty string ⇒ run entirely in seeded demo mode. */
+    apiUrl: string;
+    /** Inert URL used to mount the SDK provider when there's no live backend. */
+    demoApiUrl?: string;
+    /** Preferred live workspace ext_id (else the first workspace is used). */
+    workspaceId?: string;
+    /** Default assistant *configuration* ext_id every agentic run is grounded on. */
+    assistantConfig?: string;
+    /** The seeded demo identity shown when running without a backend. */
+    demoUser: ArbiUser;
+    /** Workspace id used in demo mode (default "demo-workspace"). */
+    demoWorkspaceId?: string;
+}

package/dist/connection/useImageGen.d.ts

@@ -0,0 +1,22 @@
+import type { AiTaskStatus } from './ai';
+export interface UseImageGen {
+    /** ext_id of the most recently generated image document (null until one exists). */
+    docExtId: string | null;
+    /** Underlying task status: 'idle' | 'running' | 'done' | 'error'. */
+    status: AiTaskStatus;
+    /** Human-readable failure message, or null. */
+    error: string | null;
+    /** True while a generation is in flight. */
+    isGenerating: boolean;
+    /**
+     * Generate an image from a prompt, optionally editing / drawing on one or
+     * more reference images already in the workspace. Pass the reference images'
+     * document ext_ids in `referenceDocIds` (omit or `[]` for plain text→image).
+     * Resolves with the new image document's ext_id, or null when the prompt is
+     * empty or no image was produced.
+     */
+    generate: (prompt: string, referenceDocIds?: string[]) => Promise<string | null>;
+    /** Clear the current result and error. */
+    reset: () => void;
+}
+export declare function useImageGen(): UseImageGen;

package/dist/facts/FactComposer.d.ts

@@ -0,0 +1,75 @@
+import type { ReactNode, Ref } from 'react';
+export interface FactComposerLabels {
+    shared: string;
+    verified: string;
+    dates: string;
+    deleteFact: string;
+    cancel: string;
+    saveFact: string;
+    saving: string;
+    addFact: string;
+    adding: string;
+}
+export declare const DEFAULT_FACT_COMPOSER_LABELS: FactComposerLabels;
+export interface FactComposerTestIds {
+    tags: string;
+    delete: string;
+    save: string;
+    error: string;
+}
+export interface FactSourcesRowLabels {
+    sources: string;
+    hintButton: string;
+    hint: string;
+}
+export declare const DEFAULT_FACT_SOURCES_ROW_LABELS: FactSourcesRowLabels;
+/** Composer field: the name stacked above its control ("Labels", "Dates"...). */
+export declare function FactFieldRow({ label, children, className, }: {
+    label: string;
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+export interface FactSourcesRowProps {
+    /** The show/hide-sources toggle. */
+    toggle: ReactNode;
+    /** The document picker. */
+    picker: ReactNode;
+    labels?: Partial<FactSourcesRowLabels>;
+    /** Test id of the hint button (default `facts-source-hint`). */
+    hintTestId?: string;
+}
+/** Sources label (with passage-collection guidance), the sources toggle and the picker. */
+export declare function FactSourcesRow({ toggle, picker, labels, hintTestId }: FactSourcesRowProps): import("react").JSX.Element;
+export interface FactComposerProps {
+    /** Whether the composer is open (it stays mounted so it animates both ways). */
+    isOpen: boolean;
+    /** Ref to the panel (used to keep it measured/focus-managed by the page). */
+    panelRef?: Ref<HTMLDivElement>;
+    /** The WYSIWYG fact editor, with its sources row. */
+    editor: ReactNode;
+    /** The labels picker row. */
+    labels: ReactNode;
+    /** The Shared switch (label is added here). */
+    sharedToggle: ReactNode;
+    /** The Verified switch (label is added here). */
+    verifiedToggle: ReactNode;
+    /** The date picker. */
+    dateInput: ReactNode;
+    /** Editing an existing fact (shows Delete, "Save fact"). */
+    isEditing: boolean;
+    canSave: boolean;
+    isSaving: boolean;
+    isDeleting: boolean;
+    onSave: () => void;
+    onCancel: () => void;
+    onDelete: () => void;
+    error?: string | null;
+    uiLabels?: Partial<FactComposerLabels>;
+    testIds?: Partial<FactComposerTestIds>;
+}
+/**
+ * The inline fact composer: editor on top, then labels + Shared / Verified, then the date with
+ * Cancel / Save (and Delete when editing). Always mounted; the grid-rows transition animates it
+ * open and closed symmetrically (a conditional mount could only animate one way).
+ */
+export declare function FactComposer({ isOpen, panelRef, editor, labels, sharedToggle, verifiedToggle, dateInput, isEditing, canSave, isSaving, isDeleting, onSave, onCancel, onDelete, error, uiLabels: labelOverrides, testIds, }: FactComposerProps): import("react").JSX.Element;

package/dist/facts/FactDateInput.d.ts

@@ -0,0 +1,34 @@
+import { type FactDateFields } from './fact-date';
+export interface FactDateInputLabels {
+    weekdays: string[];
+    months: string[];
+    previousMonth: string;
+    earlierYears: string;
+    nextMonth: string;
+    laterYears: string;
+    pickYear: string;
+    addDate: string;
+    startTime: string;
+    endTime: string;
+    setStartFirst: string;
+    timezone: string;
+    endDate: string;
+    clearDate: string;
+}
+export declare const DEFAULT_FACT_DATE_INPUT_LABELS: FactDateInputLabels;
+export interface FactDateInputTestIds {
+    caption: string;
+    day: (dateKey: string) => string;
+    year: (year: number) => string;
+}
+export interface FactDateInputProps {
+    value: FactDateFields;
+    onChange: (next: FactDateFields) => void;
+    /** Prefix for data-testids: keeps composer vs. edit-row instances distinct. */
+    idPrefix: string;
+    labels?: Partial<FactDateInputLabels>;
+    /** Overrides for the calendar's own ids (the field ids derive from `idPrefix`). */
+    testIds?: Partial<FactDateInputTestIds>;
+}
+/** A fact's date in a popover: month/year calendar plus optional times, timezone and end date. */
+export declare function FactDateInput({ value, onChange, idPrefix, labels, testIds }: FactDateInputProps): import("react").JSX.Element;

package/dist/facts/FactLabelsCell.d.ts

@@ -0,0 +1,35 @@
+export interface FactLabelsCellLabels {
+    edit: string;
+    searchPlaceholder: string;
+    create: (name: string) => string;
+    empty: string;
+}
+export declare const DEFAULT_FACT_LABELS_CELL_LABELS: FactLabelsCellLabels;
+export interface FactLabelsCellTestIds {
+    option: (labelId: string) => string;
+}
+/** One selectable label: id, name and a colour (any CSS colour) that keys its chip. */
+export interface FactLabelOption {
+    id: string;
+    name: string;
+    color: string;
+}
+export interface FactLabelsCellProps {
+    /** Every label that can be applied. */
+    options: FactLabelOption[];
+    /** The fact's full label id list (ids not in `options` are preserved on change). */
+    selectedIds: string[];
+    /** Persist the fact's full label id list. */
+    onChange: (ids: string[]) => void;
+    /** Create a label and resolve with its id (undefined when creation failed). */
+    onCreate: (name: string) => Promise<string | undefined>;
+    /** The grid row height; clamps the chips to the rows that fully fit. */
+    rowHeight?: number;
+    labels?: Partial<FactLabelsCellLabels>;
+    testIds?: Partial<FactLabelsCellTestIds>;
+}
+/**
+ * The Labels cell of the Facts table: applied labels as colour-keyed chips (an empty cell shows
+ * a pencil), and a popover to toggle labels or create one with Enter.
+ */
+export declare const FactLabelsCell: import("react").NamedExoticComponent<FactLabelsCellProps>;