@arbidocs/blocks 0.3.185 → 0.4.0

package/dist/components/PricingTable.d.ts

@@ -0,0 +1,19 @@
+export interface PricingPlan {
+    name: string;
+    price: string;
+    period?: string;
+    description?: string;
+    features?: string[];
+    cta?: {
+        label?: string;
+        href?: string;
+    };
+    /** Highlight this plan as the recommended one. */
+    featured?: boolean;
+}
+export interface PricingTableProps {
+    plans: PricingPlan[];
+    testId?: string;
+}
+/** A row of pricing plan cards with feature lists and a CTA per plan. */
+export declare function PricingTable({ plans, testId }: PricingTableProps): import("react").JSX.Element;

package/dist/components/RichTextBlock.d.ts

@@ -0,0 +1,10 @@
+export interface RichTextBlockProps {
+    content: string;
+    testId?: string;
+}
+/**
+ * Prose block. Reuses the shared markdown renderer (`AiMarkdown`) so long-form copy
+ * gets the one house style for headings, lists, tables and emphasis — token-clean
+ * and themeable per host.
+ */
+export declare function RichTextBlock({ content, testId }: RichTextBlockProps): import("react").JSX.Element;

package/dist/components/SectionHeading.d.ts

@@ -0,0 +1,11 @@
+/** Editorial heading block for marketing sections: eyebrow + title + lead. */
+export declare function SectionHeading({ eyebrow, title, lead, align, className, invert, eyebrowClassName, }: {
+    eyebrow?: string;
+    title: string;
+    lead?: string;
+    align?: 'left' | 'center';
+    className?: string;
+    invert?: boolean;
+    /** Override the eyebrow styling (e.g. a host brand accent). Default: token classes. */
+    eyebrowClassName?: string;
+}): import("react").JSX.Element;

package/dist/components/Spacer.d.ts

@@ -0,0 +1,7 @@
+export type SpacerSize = 'sm' | 'md' | 'lg' | 'xl';
+export interface SpacerProps {
+    size?: SpacerSize;
+    testId?: string;
+}
+/** Vertical whitespace. */
+export declare function Spacer({ size, testId }: SpacerProps): import("react").JSX.Element;

package/dist/components/StatGroup.d.ts

@@ -0,0 +1,12 @@
+export interface StatItem {
+    value: string;
+    label: string;
+    /** Optional caption under the label (e.g. a qualifier or unit). */
+    sub?: string;
+}
+export interface StatGroupProps {
+    items: StatItem[];
+    testId?: string;
+}
+/** Big-number stat group — headline metrics with captions. */
+export declare function StatGroup({ items, testId }: StatGroupProps): import("react").JSX.Element;

package/dist/components/Steps.d.ts

@@ -0,0 +1,12 @@
+export interface StepItem {
+    title: string;
+    description?: string;
+}
+export interface StepsProps {
+    steps: StepItem[];
+    /** `timeline` draws a connected vertical rail; `numbered` is a horizontal grid. */
+    variant?: 'numbered' | 'timeline';
+    testId?: string;
+}
+/** A process / how-it-works sequence, as numbered cards or a vertical timeline. */
+export declare function Steps({ steps, variant, testId }: StepsProps): import("react").JSX.Element;

package/dist/components/Tabs.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+export interface TabItem {
+    label: string;
+    content: ReactNode;
+}
+export interface TabsProps {
+    items: TabItem[];
+    testId?: string;
+}
+/**
+ * A tabbed panel: a row of tabs over the active tab's content. Radix Tabs gives the full WAI-ARIA
+ * pattern: one tab stop, arrow keys / Home / End move between tabs, `aria-controls` and
+ * `aria-labelledby` pair each tab with its panel.
+ */
+export declare function Tabs({ items, testId }: TabsProps): import("react").JSX.Element;

package/dist/components/TeamGrid.d.ts

@@ -0,0 +1,18 @@
+import { type BlockLinkComponent } from './blockLink';
+export interface TeamMember {
+    name: string;
+    role?: string;
+    bio?: string;
+    avatarUrl?: string;
+    /** When set, the card becomes a link to this person's detail page. */
+    href?: string;
+}
+export interface TeamGridProps {
+    members: TeamMember[];
+    columns?: '2' | '3' | '4';
+    /** Inject a router link (adapted to `href`) so linked cards navigate in-SPA. */
+    linkComponent?: BlockLinkComponent;
+    testId?: string;
+}
+/** A grid of people cards: avatar, name, role and an optional short bio. */
+export declare function TeamGrid({ members, columns, linkComponent, testId }: TeamGridProps): import("react").JSX.Element;

package/dist/components/Testimonial.d.ts

@@ -0,0 +1,9 @@
+export interface TestimonialProps {
+    quote: string;
+    author?: string;
+    role?: string;
+    avatarUrl?: string;
+    testId?: string;
+}
+/** A single pull-quote testimonial with an author and optional avatar. */
+export declare function Testimonial({ quote, author, role, avatarUrl, testId }: TestimonialProps): import("react").JSX.Element;

package/dist/components/TestimonialGrid.d.ts

@@ -0,0 +1,13 @@
+export interface TestimonialItem {
+    quote: string;
+    author?: string;
+    role?: string;
+    avatarUrl?: string;
+}
+export interface TestimonialGridProps {
+    items: TestimonialItem[];
+    columns?: '2' | '3';
+    testId?: string;
+}
+/** A grid of multiple pull-quote testimonials. */
+export declare function TestimonialGrid({ items, columns, testId }: TestimonialGridProps): import("react").JSX.Element;

package/dist/components/ToneBadge.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+import { type Tone } from './tones';
+export type { Tone };
+export interface ToneBadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    tone?: Tone;
+    /** Leading glyph or dot. */
+    icon?: ReactNode;
+    children: ReactNode;
+}
+/** A small tinted label. The host decides the tone and the words (status, level, priority...). */
+export declare function ToneBadge({ tone, icon, children, className, ...rest }: ToneBadgeProps): import("react").JSX.Element;
+export interface DotProps extends HTMLAttributes<HTMLSpanElement> {
+    tone?: Tone;
+    /** Accessible name; without it the dot is decorative (`aria-hidden`). */
+    label?: string;
+}
+/** A solid status dot in a tone. */
+export declare function Dot({ tone, label, className, ...rest }: DotProps): import("react").JSX.Element;

package/dist/components/Toolbar.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+/** Search + filter bar used above every list view. */
+export declare function Toolbar({ search, onSearch, searchPlaceholder, filters, actions, className, testId, }: {
+    search?: string;
+    onSearch?: (v: string) => void;
+    searchPlaceholder?: string;
+    filters?: ReactNode;
+    actions?: ReactNode;
+    className?: string;
+    testId?: string;
+}): import("react").JSX.Element;

package/dist/components/UsageMeter.d.ts

@@ -0,0 +1,21 @@
+import type { LucideIcon } from 'lucide-react';
+/**
+ * One labelled quota meter: icon + label on the left, used-of-limit on the
+ * right, a thin bar underneath. The bar's tone follows pressure with the shared
+ * green → yellow → red gradation — green while there's room, yellow past the
+ * halfway mark, red at the limit — so a stack of meters reads at a glance which
+ * quota is the one to think about.
+ */
+export declare function UsageMeter({ icon: Icon, label, value, pct, hint, className, testId, }: {
+    icon?: LucideIcon;
+    label: string;
+    /** Formatted used-of-limit text, e.g. "1,200 / 25,000" or "40 / 500 MB". */
+    value: string;
+    /** Fill percentage, 0–100 (values are clamped). */
+    pct: number;
+    /** Inline parenthetical after the label, e.g. "resets May 31, 2025" —
+     *  same font as the label, so the meter never grows an extra row. */
+    hint?: string;
+    className?: string;
+    testId?: string;
+}): import("react").JSX.Element;

package/dist/components/VideoEmbed.d.ts

@@ -0,0 +1,16 @@
+export type VideoAspect = '16:9' | '4:3' | '1:1';
+export interface VideoEmbedProps {
+    /** A YouTube / Vimeo / Loom page URL, or a direct video file URL. */
+    url: string;
+    title?: string;
+    aspect?: VideoAspect;
+    rounded?: boolean;
+    testId?: string;
+}
+/**
+ * Resolve a shareable video URL to an embeddable iframe src. Supports YouTube,
+ * Vimeo and Loom; returns null for anything else (rendered as a `<video>`).
+ */
+export declare function toEmbedUrl(url: string): string | null;
+/** Embed a video from a YouTube/Vimeo/Loom link or a direct file, in a set aspect. */
+export declare function VideoEmbed({ url, title, aspect, rounded, testId, }: VideoEmbedProps): import("react").JSX.Element;

package/dist/components/assetImage.d.ts

@@ -0,0 +1,16 @@
+import type { AssetRenderProps } from './assetResolver';
+/**
+ * Resolve an asset ext_id to a displayable image src.
+ *
+ * Prefer the cheap thumbnail endpoint, but fall back to downloading the actual
+ * bytes as an object URL when there's no thumbnail — AI-generated (and freshly
+ * uploaded) images have no thumbnail yet, so the thumbnail-only path renders a
+ * broken `<img>`. The bytes always exist (it's a stored document), so the editor
+ * shows the real image immediately instead of waiting on async thumbnailing.
+ */
+export declare function useAssetImage(docId: string): string | undefined;
+/**
+ * Resolve a single asset ext_id and render it as an `<img>`. This is the
+ * `AssetRenderer` the Studio injects; it satisfies `AssetRenderProps`.
+ */
+export declare function AssetThumb({ docId, alt, className, testId }: AssetRenderProps): import("react").JSX.Element;

package/dist/components/assetResolver.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Asset resolution for the editor canvas — the SDK-free half.
+ *
+ * An image block's stored `src` is one of three things: a **workspace asset ref**
+ * while authoring (an `asset:<docId>` string), a plain URL, or — once published —
+ * an inlined `data:` URI (see the studio publish/materialize step). Only inside
+ * the authenticated Studio can an asset ref be resolved to displayable bytes (via
+ * the thumbnail endpoint).
+ *
+ * So the resolver is **injected, not imported**. This module knows only that
+ * *some* component can turn a `docId` into pixels; the Studio supplies
+ * `AssetThumb` from `./assetImage`, which is where the SDK and React Query live.
+ * Everywhere else — the pure coverage guard, the unauthenticated public renderer,
+ * a marketing site importing `@arbidocs/blocks/site` — the context is empty and
+ * `src` renders verbatim. Importing the resolver here instead would drag the SDK
+ * into every website block: a dead code path still pins the module graph, because
+ * neither kit package declares `sideEffects`.
+ *
+ * Refs are **explicitly prefixed** (`asset:`) rather than bare ext_ids so the
+ * publish walk can distinguish an image source from any other token-like prop
+ * (block ids, `"left"`, icon names…) with zero false positives.
+ */
+import { type ComponentType, type ReactNode } from 'react';
+/** Marks a stored image value as a workspace asset ref rather than a URL. */
+export declare const ASSET_REF_PREFIX = "asset:";
+/** Wrap a workspace document ext_id as a storable asset ref. */
+export declare function asAssetRef(docId: string): string;
+/** The workspace document ext_id behind an asset ref (`asset:doc-1` → `doc-1`). */
+export declare function assetRefId(src: string): string;
+/** What a resolver component receives. `AssetThumb` in `./assetImage` implements it. */
+export interface AssetRenderProps {
+    docId: string;
+    alt?: string;
+    className?: string;
+    testId?: string;
+}
+/** Renders a workspace asset ext_id as an image. */
+export type AssetRenderer = ComponentType<AssetRenderProps>;
+/**
+ * The injected resolver, or `null` where asset refs cannot be resolved (the
+ * public renderer, tests, any unauthenticated page).
+ */
+export declare const AssetResolverContext: import("react").Context<AssetRenderer | null>;
+export declare function AssetResolverProvider({ render, children, }: {
+    /** Typically `AssetThumb` from `./assetImage`. */
+    render: AssetRenderer;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The active resolver, or `null` when asset refs must render verbatim. */
+export declare function useAssetRenderer(): AssetRenderer | null;
+/** True only where a bare asset ext_id can be resolved (the authenticated Studio). */
+export declare function useAssetResolverActive(): boolean;
+/**
+ * Is `src` a workspace asset ref (`asset:<docId>`) rather than an already-
+ * renderable URL / `data:` URI? Only prefixed refs need resolution.
+ */
+export declare function isAssetRef(src: string | undefined): src is string;

package/dist/components/blockLink.d.ts

@@ -0,0 +1,26 @@
+import type { AnchorHTMLAttributes, ComponentType, ReactNode } from 'react';
+/**
+ * Firm-agnostic link injection for marketing blocks. A card that navigates to a
+ * detail page renders an internal `<a href>` by default, but a consuming app can
+ * inject its router's link (e.g. react-router's `Link`, adapted to `href`) via
+ * `linkComponent` so navigation stays in-SPA. When no `href` is given the block
+ * renders its children unwrapped, so this is fully opt-in and backward compatible.
+ */
+export type BlockLinkRenderProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & {
+    href: string;
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * The host's link. Interactive blocks (nav rows, tiles, cards) pass anchor attributes beyond
+ * `href` (`onClick`, `aria-current`, `data-*`, a `ref`), so an adapter should forward unknown
+ * props to its anchor, as react-router's `Link` does.
+ */
+export type BlockLinkComponent = ComponentType<BlockLinkRenderProps>;
+export interface BlockLinkProps {
+    href?: string;
+    linkComponent?: BlockLinkComponent;
+    className?: string;
+    children: ReactNode;
+}
+export declare function BlockLink({ href, linkComponent: Link, className, children }: BlockLinkProps): import("react").JSX.Element;

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;
+};