@arbidocs/blocks 0.4.147 → 0.4.151

package/dist/connection/billing/plan-constants.d.ts

@@ -0,0 +1,29 @@
+/** Pro's allowance per month (one licence) — must match the backend. Legacy multi-pack plans get it per pack.
+ *  The live numbers for an existing project come from `project.addons`; these are only for
+ *  describing the plan before a project exists (new-project dialog, upgrade picker). */
+export declare const PRO_AI_GBP = 10;
+export declare const PRO_STORAGE_GB = 5;
+/**
+ * Add-on block sizes (£25 of AI usage or 25 GB), the same on every plan. Their prices come from the
+ * products API (`addon_prices`) before a project exists, and from `project.addons` after.
+ */
+export declare const ADDON_BLOCK_AI_GBP = 25;
+export declare const STORAGE_BLOCK_GB = 25;
+/** Default monthly usage cap for a new Pro project (pence); it limits automatic top-ups only. 0 = no automatic
+ *  top-ups, null = no limit. */
+export declare const DEFAULT_SPEND_CAP_PENCE = 10000;
+/** The automatic add-on triggers when less than this much AI usage (£) remains; the backend minimum. */
+export declare const MIN_AUTO_TOPUP_THRESHOLD_GBP = 1;
+/** Free-tier quotas — must match backend FREE_* constants in src/constants.py
+ *  (FREE_AI_GBP=1, FREE_STORAGE_GB=0.05 → 50 MB, FREE_COLLABORATORS=0). */
+export declare const FREE_AI_GBP = 1;
+export declare const FREE_STORAGE_MB = 50;
+export declare const FREE_COLLABORATORS = 0;
+/** Collaborator limits at or above this are "unlimited" (the backend reports 999 for Pro/dev). */
+export declare const UNLIMITED_COLLABORATORS = 999;
+/**
+ * Suggested initial daily per-user AI usage cap (£), pre-filled when creating
+ * a new project. The user can clear it to create a project with no cap.
+ * Backend treats null as "no enforcement" — there is no server-side default.
+ */
+export declare const SUGGESTED_DAILY_CAP_PER_USER = 10;

package/dist/connection/billing/plan-pricing.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Pro plan price helpers. Prices come from Stripe via GET /v1/user/products (source of truth).
+ * One plan is sold: Pro, one licence (£10 of AI usage + 5 GB a month). Each price lists
+ * `pack_prices` for that one licence — `amount` incl. UK VAT and `amount_ex_vat` — and
+ * `addon_prices` (one add-on block on that interval). Display them as-is.
+ * Legacy subscriptions with several packs keep working; their name and price come from the project.
+ */
+import type { components } from '@arbidocs/client';
+type PlanChangePreview = components['schemas']['PlanChangePreview'];
+type ProductPrice = components['schemas']['ProductPrice'];
+type ProductResponse = components['schemas']['ProductResponse'];
+type PackPrice = components['schemas']['PackPrice'];
+type AddonPrice = components['schemas']['AddonPrice'];
+export type PlanInterval = 'month' | 'year';
+/** The headline price: "£40 + VAT". */
+export declare function plusVat(exVatPence: number, currency?: string): string;
+/** The one licence Pro sells. Other pack counts exist only on legacy subscriptions (displayed, not sold). */
+export declare const PRO_PACKS = 1;
+/** A plan the pickers offer. */
+export type PlanChoice = 'free' | 'pro';
+/** Packs per plan choice (0 = Free). */
+export declare const PLAN_CHOICE_PACKS: Record<PlanChoice, number>;
+/** "Free" (0), "Pro" (1), otherwise "Pro ×N" (a legacy multi-pack plan; the API's own name wins). */
+export declare function planNameForPacks(packs: number | null | undefined): string;
+/** The plan-change panel's fixed lines, each with a test id. */
+export interface PlanChangeLine {
+    id: 'pay-today' | 'from' | 'current-until' | 'no-change' | 'awaiting-bank';
+    text: string;
+}
+/**
+ * What a plan change costs, from the backend's Stripe invoice preview (taxed for the customer's
+ * address), as fixed lines:
+ *  - "Pay today £42.00 incl. VAT (£35.00 + £7.00 VAT 20%)" ("Pay today £0" for a change that waits)
+ *  - "From 16 Nov 2026: £210.00 incl. VAT (£175.00 + £35.00 VAT 20%) a month"
+ *  - "Current plan until 16 Nov 2026" for a change that waits for the period end.
+ * "No change" when the selection is what the project already has; "Waiting for your bank" while
+ * an earlier upgrade payment awaits 3-D Secure.
+ */
+export declare function planPreviewLines(preview: PlanChangePreview): PlanChangeLine[];
+/** Stand-in for "Pay today" when the preview failed for an upgrade. */
+export declare const PAY_TODAY_UNPRICED = "Pay today: the difference for the rest of this period";
+/** One add-on block's price on this interval's plan price (`addon_prices`), if listed. */
+export declare function addonPrice(price: ProductPrice | undefined, kind?: 'ai_usage' | 'storage'): AddonPrice | undefined;
+/** Per add-on block of `kind` per month, ex VAT (annual plans: the monthly equivalent). */
+export declare function addonMonthlyExVat(price: ProductPrice | undefined, kind?: 'ai_usage' | 'storage'): number | undefined;
+/**
+ * The add-on offer on this interval's price, each block with its own price:
+ * "£25 of AI usage for £25/month + VAT or 25 GB for £25/month + VAT". Null when unlisted.
+ */
+export declare function addonOfferText(price: ProductPrice | undefined): string | null;
+/** What a checkout buys: "Pro", "Pro + 2 × £25 of AI usage + 1 × 25 GB". */
+export declare function checkoutItemsLabel(aiBlocks: number, storageBlocks: number): string;
+/** The price of `packs` packs on this interval's price, if Stripe lists it (only one licence is listed). */
+export declare function packPrice(price: ProductPrice | undefined, packs?: number): PackPrice | undefined;
+export interface ProPrices {
+    monthly?: ProductPrice;
+    annual?: ProductPrice;
+}
+/** The Pro product's monthly and annual prices (default price per interval wins). */
+export declare function findProPrices(products: ProductResponse[] | undefined): ProPrices;
+/** Annual savings vs 12 × monthly, as a whole percent (e.g. £360 vs £480 → 25). */
+export declare function calcSavingsPercent(monthlyPrice: ProductPrice | undefined, annualPrice: ProductPrice | undefined): number | null;
+/** Most add-on blocks of each kind a checkout may include (the backend's limit). */
+export declare const MAX_CHECKOUT_BLOCKS = 100;
+/** "£25/month + VAT each", annual: "£225/year + VAT each": one block on the chosen interval. */
+export declare function checkoutBlockPriceText(price: ProductPrice | undefined, kind: 'ai_usage' | 'storage'): string | null;
+export {};

package/dist/connection/billing/quota-items.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Quota display — single source of truth.
+ *
+ * Builds the icon / label / formatted used-of-limit strings for a project's
+ * quotas (AI usage in £, storage, collaborators). Shared by QuotaBadges and the
+ * project tooltip so the numbers and units can never disagree (storage in GB on
+ * plans of 1 GB or more, MB below).
+ */
+import type { QuotaMeterItem } from '../../settings';
+import type { components } from '@arbidocs/client';
+type Quotas = components['schemas']['ProjectResponse']['quotas'];
+/** "May 31, 2025" — the one format every AI-usage-reset mention uses. */
+export declare function formatResetDate(unixTimestamp: number | null | undefined): string | null;
+/**
+ * When the project's AI usage allowance next resets, as a unix timestamp.
+ * Pro projects report it directly (`addons.ai_usage_reset_at` — monthly, even on an
+ * annual plan); monthly subscriptions otherwise reset with the billing period
+ * (`current_period_end`); free projects reset on the backend-stamped signup
+ * anniversary (`quotas.budget_reset_at`). Only a FUTURE date is returned — a stale
+ * past stamp would read as a bug, not a promise.
+ */
+export declare function aiUsageResetTimestamp(project: {
+    quotas?: {
+        budget_reset_at?: number | null;
+    } | null;
+    current_period_end?: number | null;
+    plan_interval?: string | null;
+    addons?: {
+        ai_usage_reset_at?: number | null;
+    } | null;
+}): number | null;
+export declare function getQuotaItems(quotas: Quotas): QuotaMeterItem[];
+export {};

package/dist/connection/billing/referral-reward.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Referral-reward logic (hook + pure helpers) shared across the pricing UI.
+ *
+ * The reward is a single GLOBAL per-user number — a Stripe account balance mirrored
+ * read-only into `settings.extra_discount`. It auto-applies to the user's NEXT invoice.
+ * `applyReferralReward` mirrors Stripe's customer-balance logic: applied to the charge,
+ * clamped at zero, remainder rolls forward. Components live in `./ReferralReward`.
+ */
+export { formatMoney } from './reward-balance';
+export interface ReferralReward {
+    amount: number;
+    currency: string;
+}
+/** The standing referral offer — what one successful invite earns. One constant
+ *  so the welcome modal and the rewards modal can never quote different money. */
+export declare const REFERRAL_OFFER: ReferralReward;
+/** The user's available referral reward, or null if none. */
+export declare function useReferralReward(): ReferralReward | null;
+/**
+ * Apply the reward to a charge, mirroring Stripe's customer-balance behaviour.
+ * Returns null when there's no usable reward or the currency doesn't match the price.
+ */
+export declare function applyReferralReward(totalCents: number, reward: ReferralReward | null, priceCurrency: string): {
+    bonus: number;
+    youPay: number;
+    remaining: number;
+    currency: string;
+} | null;

package/dist/connection/billing/refusal-copy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * One template for every refusal where money is involved (declined card, failed or timed-out
+ * upgrade): "<What happened>. Nothing was charged. <Next step>."
+ */
+export declare function refusal(what: string, next: string): string;

package/dist/connection/billing/reward-balance.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Reward-balance logic (hook + money formatter).
+ *
+ * A user's reward balance is their available account balance — a single GLOBAL per-user
+ * number, the Stripe customer account balance mirrored read-only into
+ * `settings.extra_discount`. It auto-applies to the user's NEXT invoice.
+ *
+ * "Rewards" is the broad concept: the balance can be fed by several sources (referral
+ * reward is just one). The referral pricing surfaces of the billing kit
+ * speak to the referral source specifically; this module owns the balance itself.
+ */
+export interface RewardBalance {
+    amount: number;
+    currency: string;
+}
+/** The user's available reward balance (all sources), or null if none. */
+export declare function useRewardBalance(): RewardBalance | null;
+/** Format minor units as a localized money string, e.g. `£20` (whole) or `£29.99`. */
+export declare function formatMoney(cents: number, currency?: string): string;

package/dist/connection/billing/support.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What a host adds to the billing kit. Selling plans needs Stripe, which stays the host's: whether
+ * this deployment sells plans (a publishable key is configured), and its embedded checkout. Without
+ * a `BillingSupportProvider` nothing is for sale: projects show their limits and usage only.
+ */
+import { type ReactNode } from 'react';
+export interface BillingCheckoutSupport {
+    /** Load the host's Stripe (lazily, when a checkout opens); `null` when it cannot. */
+    load(): Promise<unknown> | null;
+    /** Stripe's embedded checkout for a session, on the loaded Stripe. */
+    render(stripe: unknown, session: {
+        clientSecret: string;
+        onComplete: () => void;
+    }): ReactNode;
+}
+export interface BillingSupport {
+    /** This deployment sells plans (Stripe is configured). */
+    stripeEnabled: boolean;
+    checkout?: BillingCheckoutSupport;
+    /**
+     * Add-on blocks the user just bought here, so the host does not announce them later as having
+     * arrived on their own.
+     */
+    onAddonBlocksBought?: (projectExtId: string, blocks: {
+        ai: number;
+        storage: number;
+    }) => void;
+}
+export declare function BillingSupportProvider({ value, children, }: {
+    value: BillingSupport;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useBillingSupport(): BillingSupport;
+/** The signed-in user's id (`usr-…`), to tell the projects they own from the others. */
+export declare function useSelfExtId(): string | undefined;

package/dist/connection/billing/tax-quote.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Tax-inclusive totals from the backend's Stripe Tax quotes (`TaxQuoteResponse`, plan-change
+ * previews, add-on quotes): "£48.00 incl. VAT (£40.00 + £8.00 VAT 20%)", "£40.00 · no VAT
+ * (reverse charge)", "£40.00 · no tax".
+ */
+import type { components } from '@arbidocs/client';
+export type TaxQuote = components['schemas']['TaxQuoteResponse'];
+/** Countries whose tax depends on the postcode: the field is shown up front. */
+export declare const POSTCODE_COUNTRIES: readonly string[];
+/** The quote error that asks for a ZIP / postal code. */
+export declare const TAX_LOCATION_INVALID = "TAX_LOCATION_INVALID";
+/** "£42.00" — always pence, so the parts of a total add up on screen. */
+export declare function money2(pence: number, currency?: string): string;
+export interface TaxParts {
+    subtotal: number;
+    tax: number;
+    total: number;
+    /** "VAT 20%"; null when no tax is due. */
+    label?: string | null;
+    reverseCharge?: boolean;
+}
+/** What follows the total: "incl. VAT (£40.00 + £8.00 VAT 20%)", "· no VAT (reverse charge)", "· no tax". */
+export declare function taxDetail({ subtotal, tax, label, reverseCharge }: TaxParts): string;
+/** "£48.00 incl. VAT (£40.00 + £8.00 VAT 20%)", "£40.00 · no VAT (reverse charge)", "£40.00 · no tax". */
+export declare function taxSummary(parts: TaxParts): string;
+/** "£21.00 incl. VAT" / "£17.50" — a total with only the word for its tax. */
+export declare function totalWithTaxWord({ total, tax, label }: TaxParts): string;
+/** The parts of a quote response. */
+export declare function quoteParts(quote: TaxQuote): TaxParts;
+/** "Total today £48.00 incl. VAT (£40.00 + £8.00 VAT 20%)". */
+export declare function quoteTotalLine(quote: TaxQuote): string;
+/** The API error code (`detail.code`) and message, if any. */
+export declare function quoteError(error: unknown): {
+    code?: string;
+    message?: string;
+};

package/dist/connection/billing/useAddonPurchase.d.ts

@@ -0,0 +1,32 @@
+/**
+ * useAddonPurchase — buy one add-on block (+£25 of AI usage or +25 GB) for a Pro project and tell
+ * the user what happened. The monthly usage cap limits automatic top-ups only, so it never refuses a block
+ * bought here. The block is charged now for the current period and then renews every
+ * period until the user reduces it. Shared by the add-on confirm dialog (project Add-ons card,
+ * quota-exceeded modal).
+ *
+ *  - `paid`             → the block is live now.
+ *  - `requires_action`  → the bank wants 3-D Secure: open Stripe's hosted invoice in a new tab;
+ *                         the block is added once confirmed (the next refresh picks it up).
+ *  - 402 `{code, message}` (declined / no card / no billing address) → the
+ *    refusal template ("… Nothing was charged. …"); any other failure leaves the outcome unknown:
+ *    `onUnknownError` lets the caller check the project before saying what happened.
+ */
+export type AddonKind = 'ai_usage' | 'storage';
+export type AddonErrorCode = 'PAYMENT_DECLINED' | 'PAYMENT_METHOD_REQUIRED' | 'BILLING_ADDRESS_REQUIRED';
+/** The user-facing message for a failed add-on request (402 detail object or plain detail). */
+export declare function addonErrorMessage(error: unknown): string;
+/** The refusal for a charge the backend turned down (402 with a known code), else null. */
+export declare function chargeRefusalMessage(error: unknown): string | null;
+/** The 402 code of a failed add-on request, if it has one. */
+export declare function addonErrorCode(error: unknown): AddonErrorCode | null;
+export declare function useAddonPurchase(): {
+    buy: (kind: AddonKind, projectExtId: string, options?: {
+        onPaid?: () => void;
+        onRequiresAction?: () => void;
+        onError?: (code: AddonErrorCode | null) => void;
+        /** A failure that doesn't say whether the charge went through (timeout, 5xx). */
+        onUnknownError?: () => void;
+    }) => void;
+    isPending: boolean;
+};

package/dist/connection/billing/useAutoRefreshPendingProjects.d.ts

@@ -0,0 +1,11 @@
+/**
+ * useAutoRefreshPendingProjects
+ *
+ * Auto-refreshes owned projects stuck at subscription="none" (checkout
+ * completed but not yet synced). Skips member-of projects: refresh requires
+ * owner, and non-owner projects already have `subscription` blanked to
+ * "none" by the backend regardless of real state.
+ *
+ * Each project is refreshed at most once per mount (refreshedRef guard).
+ */
+export declare function useAutoRefreshPendingProjects(): void;

package/dist/connection/billing/useCheckoutQuote.d.ts

@@ -0,0 +1,30 @@
+/**
+ * useCheckoutQuote — the tax-inclusive total of a plan purchase for the billing country (and
+ * ZIP / postcode where the tax depends on it), from the backend's Stripe Tax quote. Shown by
+ * `CheckoutTotal` before Stripe opens.
+ */
+import type { PlanInterval } from './plan-pricing';
+import { type TaxQuote } from './tax-quote';
+export interface CheckoutQuoteState {
+    quote?: TaxQuote;
+    isLoading: boolean;
+    /** Show the ZIP / postcode field. */
+    showPostcode: boolean;
+    /** Why there is no total (e.g. "Enter your ZIP / postal code to see the total."). */
+    error: string | null;
+    /** Continue to payment: priced, or the pricing failed for a reason other than the address. */
+    canContinue: boolean;
+}
+/**
+ * Prices the plan, plus any add-on blocks picked at checkout (one period of each), for the billing address.
+ * `projectExtId` for an existing project.
+ */
+export declare function useCheckoutQuote({ projectExtId, interval, country, postalCode, aiBlocks, storageBlocks, enabled, }: {
+    projectExtId?: string | null;
+    interval: PlanInterval;
+    country: string;
+    postalCode: string;
+    aiBlocks?: number;
+    storageBlocks?: number;
+    enabled?: boolean;
+}): CheckoutQuoteState;

package/dist/connection/billing/useOpenBillingPortal.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Opens a fresh Stripe billing-portal link for a project in a new tab.
+ *
+ * The tab is opened synchronously inside the click: browsers only allow
+ * window.open() during the user gesture, and the portal link arrives after an
+ * await. The tab starts on about:blank and is pointed at the Stripe URL once the
+ * link is ready.
+ */
+export declare function useOpenBillingPortal(): {
+    open: (projectExtId: string) => void;
+    isPending: boolean;
+};

package/dist/connection/calendar/CalendarSettingsDialog.d.ts

@@ -1,6 +1,6 @@
 import { type CalendarSettings } from '@arbidocs/react';
 import { type CalendarListItem } from '../../calendar';
-export type CalendarSettingsTab = 'general' | 'accounts' | 'access' | 'booking' | 'rooms';
+export type CalendarSettingsTab = 'general' | 'accounts' | 'booking' | 'rooms';
 export interface CalendarSettingsDialogProps {
     open: boolean;
     settings: CalendarSettings;

package/dist/connection/facts/ConnectedFactsPage.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The Facts page: the open workspace's facts — what it knows, a date, a decision, a preference —
+ * written by hand or kept by the assistant. A table (with labels, sources, verified and shared
+ * toggles, inline edits and bulk actions), a calendar and a timeline of the dated ones, and Smart
+ * Search when the host has one. A fact is written or edited in the composer above them: its text
+ * (rich markdown), its date, labels, sources (whole documents or passages picked in the viewer),
+ * and whether it is shared and verified.
+ *
+ * Data is `@arbidocs/react` (facts, tags) and the connected workspace documents. The host plugs in
+ * what lives elsewhere in it (see `types.ts`): the current chat's facts, the viewer's passage
+ * collection, where the view choices are kept, a request from another surface, and its own labels
+ * panel, export and Smart Search.
+ */
+import { type ReactNode } from 'react';
+import type { FactCreator, LookupUser } from './factPageColumns';
+import type { FactPassageCollector, FactsChat, FactsPageRequest, FactsPageSlots, FactsPageView } from './types';
+/** Who may do something to a fact, by its creator's id. */
+export type FactCreatorCheck = (creatorExtId: string | null | undefined) => boolean;
+export interface ConnectedFactsPageProps extends FactsPageSlots {
+    /** The current chat's facts (absent: no In chat column, filter or bulk action). */
+    chat?: FactsChat;
+    /** The viewer's passage collection (absent: citing a document opens it). */
+    collector?: FactPassageCollector;
+    /** Where the view choices are kept (default: in the page). */
+    view?: FactsPageView;
+    /** A one-off request from another surface; each part done is reported. */
+    request?: FactsPageRequest;
+    onRequestHandled?: (part: keyof FactsPageRequest) => void;
+    /** Open the labels panel for the selected facts (with `renderLabelsPanel`). */
+    onOpenLabels?: () => void;
+    /**
+     * Who may change who sees a fact (default: its creator) and who may reword or delete it (default:
+     * its creator; a host adds the workspace's owners).
+     */
+    permissions?: {
+        canChangeSharing: FactCreatorCheck;
+        canRewrite: FactCreatorCheck;
+    };
+    /** A creator by id (default: the workspace's members). */
+    lookupUser?: LookupUser;
+    /** A creator's avatar (default: the shared one). */
+    renderUser?: (user: FactCreator | null) => ReactNode;
+}
+/** One id for the grid's persisted column state and its row-height density.
+ *  v11: reset so the Dates column opens beside the fact text.
+ *  v12: reset so the table opens in date order (a saved column state would override the default sort).
+ *  v13: the Pinned column became In chat (colId `in_chat`).
+ *  Bump to reset state. */
+export declare const FACTS_GRID_ID = "facts-grid-v13";
+export declare function ConnectedFactsPage({ chat, collector, view: hostView, request, onRequestHandled, onOpenLabels, permissions, lookupUser: hostLookupUser, renderUser, renderLabelsPanel, renderExport, renderSmartSearch, emptyStateExtra, }: ConnectedFactsPageProps): import("react").JSX.Element;

package/dist/connection/facts/FactMarkdownEditor.d.ts

@@ -0,0 +1,57 @@
+/**
+ * FactMarkdownEditor
+ *
+ * A WYSIWYG editor for a fact: the text is edited as rendered markdown (via the
+ * shared MDXEditor, same engine the document artifacts use), and the fact's
+ * source citations are preserved and managed beneath it exactly as the packaged
+ * CitationEditor did — per-document rows with page refs and a remove control,
+ * and the document picker wired to the viewer's passage-collection flow.
+ *
+ * The editor is heavy (Lexical), so it is lazy-loaded. It adopts its markdown on mount only, so
+ * the parent bumps `editorKey` each time the composer opens to reload the right fact's text.
+ */
+import type { components } from '@arbidocs/client';
+import { type ReactNode } from 'react';
+import type { FactPassageCollector } from './types';
+type CitationSources = components['schemas']['CitationSources'];
+type DocResponse = components['schemas']['DocResponse'];
+export interface FactMarkdownEditorProps {
+    /** Remount key so the editor adopts a different fact's markdown on open. */
+    editorKey: string;
+    value: string;
+    citations: CitationSources | null;
+    onChange: (text: string, citations: CitationSources | null) => void;
+    /** Open a document in the viewer, armed to collect passages for this fact.
+     *  `toggle: false` always opens (the picker's list); otherwise clicking the
+     *  document already in view closes it. */
+    onCiteDocument: (docExtId: string, opts?: {
+        toggle?: boolean;
+    }) => void;
+    /** The viewer's passage collection, while a source's popover is open. */
+    collector?: FactPassageCollector;
+    /** Resolved cited documents, keyed by external id. */
+    citedDocs?: Record<string, DocResponse>;
+    /** The document currently on display in the viewer (null when closed). Its
+     *  Source row is highlighted so it's clear which cited doc you're reading. */
+    viewingDocId?: string | null;
+    /** The workspace document picker (Sources title + combobox), injected.
+     *  `sourcesToggle` is the control that opens the sources popup (every cited
+     *  document with its passages) — place it in front of the combobox (null when
+     *  the fact has no sources to show). */
+    renderDocumentPicker: (onSelect: (docExtId: string) => void, selectedIds: string[], onOpen: (docExtId: string) => void, sourcesToggle: ReactNode, 
+    /** True while the Sources popup is open — shut the picker's list then. */
+    sourcesOpen: boolean) => ReactNode;
+    /** The markdown MDXEditor produces on mount (its canonical round-trip of
+     *  `value`) — use as the "unchanged" baseline for a dirty check. */
+    onNormalized?: (normalized: string) => void;
+    /** Keep the sources toggle in place (disabled) even when the fact has no
+     *  sources, so selecting different events doesn't change the Sources row
+     *  geometry (used by the timeline/calendar). */
+    reserveSourcesSpace?: boolean;
+    /** The fact section element the source Citation popovers portal into and are
+     *  kept within (see FactSourcesPopover), so it never spills over the sidebar. */
+    citationContainer?: HTMLElement | null;
+    'data-testid'?: string;
+}
+export declare function FactMarkdownEditor({ editorKey, value, citations, onChange, onCiteDocument, collector, citedDocs, viewingDocId, renderDocumentPicker, onNormalized, reserveSourcesSpace, citationContainer, 'data-testid': dataTestId, }: FactMarkdownEditorProps): import("react").JSX.Element;
+export {};

package/dist/connection/facts/FactSourcesPopover.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The fact's sources as ONE popup off the "Sources" control in the Sources row — every cited
+ * document, each with the passages the fact draws from it listed beneath (page + excerpt), laid out
+ * like the chat's citations. Being a popover (not an in-flow list) it never pushes the rest of the
+ * composer up or down. Clicking a document opens it in the viewer; clicking a passage jumps to and
+ * highlights it there, exactly like a chat citation. Excerpts are resolved live
+ * (`usePassageQuotes`), never stored on the fact. The viewer side goes through the host's
+ * `FactPassageCollector`.
+ */
+import type { components } from '@arbidocs/client';
+import { type OrderResolver, type QuoteResolver } from '@arbidocs/react';
+import { type ReactNode } from 'react';
+import type { FactCitations } from '../../facts/fact-citations';
+import type { FactPassageCollector } from './types';
+type DocResponse = components['schemas']['DocResponse'];
+export interface FactSourcesPopoverProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The Sources row (picker + the PopoverTrigger toggle) this popup hangs off. */
+    children: ReactNode;
+    /** Cited documents in citation order, each with its passages. */
+    citations: FactCitations;
+    citedDocs?: Record<string, DocResponse>;
+    quoteFor: QuoteResolver;
+    orderOf?: OrderResolver;
+    /** The document currently on display in the viewer (null when closed). */
+    viewingDocId?: string | null;
+    /** Open a document in the viewer, armed to collect passages for this fact. */
+    onCiteDocument: (docExtId: string) => void;
+    onRemoveDoc: (docExtId: string) => void;
+    /** The viewer's passage collection (absent: passages open the document, nothing is marked). */
+    collector?: FactPassageCollector;
+    /** The fact section the popover is portalled INTO and fenced WITHIN, so it
+     *  opens into the fact content rather than across the app sidebar. */
+    container?: HTMLElement | null;
+}
+export declare function FactSourcesPopover({ open, onOpenChange, children, citations, citedDocs, quoteFor, orderOf, viewingDocId, onCiteDocument, onRemoveDoc, collector, container, }: FactSourcesPopoverProps): import("react").JSX.Element;
+export {};

package/dist/connection/facts/FactTextEditor.d.ts

@@ -0,0 +1,2 @@
+import { type ArtifactMarkdownEditorProps } from '../../artifacts/editor/ArtifactMarkdownEditor';
+export default function FactTextEditor(props: Omit<ArtifactMarkdownEditorProps, 'dictation'>): import("react").JSX.Element;

package/dist/connection/facts/factNouns.d.ts

@@ -0,0 +1,4 @@
+export declare const factNouns: () => {
+    SINGULAR: string;
+    PLURAL: string;
+};

package/dist/connection/facts/factPageColumns.d.ts

@@ -0,0 +1,37 @@
+import type { ColDef } from 'ag-grid-community';
+import { type ReactNode } from 'react';
+import type { Fact } from './types';
+/** A fact's creator, as the page knows them. */
+export interface FactCreator {
+    external_id: string;
+    given_name?: string | null;
+    family_name?: string | null;
+    email?: string | null;
+    picture?: string | null;
+}
+/** Resolves a creator's external id to the user. */
+export type LookupUser = (externalId: string | null | undefined) => FactCreator | null;
+export interface FactGridContext {
+    lookupUser?: LookupUser;
+    /** The host's own creator avatar. */
+    renderUser?: (user: FactCreator | null) => ReactNode;
+    renderFactTags?: (fact: Fact, rowHeight?: number) => ReactNode;
+    openEdit?: (fact: Fact) => void;
+    removeFact?: (fact: Fact) => void;
+    /** Who may change who can see a fact: its creator or a workspace owner. */
+    canChangeSharing?: (fact: Fact) => boolean;
+    /** Who may reword a fact (it replaces the note): its creator or a workspace owner. */
+    canRewrite?: (fact: Fact) => boolean;
+    /** Whether the fact is in the current chat (read live: the column defs are built once). */
+    isInChat?: (fact: Fact) => boolean;
+}
+interface FactColumnCallbacks {
+    /** Add the fact to the current chat, or take it out (absent: no chat, no In chat column). */
+    onToggleInChat?: (fact: Fact) => void;
+    /** Whether the fact is in the current chat. */
+    isInChat?: (fact: Fact) => boolean;
+    onToggleConfirmed: (fact: Fact) => void;
+    onToggleShared: (fact: Fact) => void;
+}
+export declare function createFactPageColumns({ onToggleInChat, isInChat, onToggleConfirmed, onToggleShared, }: FactColumnCallbacks): ColDef<Fact>[];
+export {};