@the-syllabus/analysis-renderers 0.2.0

package/src/components/EvidenceTrail.tsx

@@ -0,0 +1,203 @@
+/**
+ * EvidenceTrail — Reusable vertical chain of evidence steps.
+ *
+ * Renders a narrative progression with dot markers, gradient connectors,
+ * and quoted content. Each step can contain multiple items (with title,
+ * quote, citation) or a single text block.
+ *
+ * Two usage modes:
+ *   1. Direct — import EvidenceTrail and pass pre-built steps array
+ *   2. Sub-renderer — use EvidenceTrailSubRenderer with config-driven
+ *      field mapping (registered in SubRenderers.tsx)
+ *
+ * CSS classes used (from renderers.css):
+ *   .gen-evidence-trail, .gen-trail-chain, .gen-trail-step,
+ *   .gen-trail-marker, .gen-trail-dot, .gen-trail-label,
+ *   .gen-trail-content, .gen-trail-connector, .gen-trail-quote,
+ *   .gen-quote-mark, .gen-trail-cite, .ar-card-assessment
+ */
+
+import React from 'react';
+
+// ── Public types ─────────────────────────────────────────
+
+export interface EvidenceTrailItem {
+  title?: string;
+  quote?: string;
+  cite?: string;
+}
+
+export interface EvidenceTrailStep {
+  label: string;
+  variant: 'prior' | 'current' | 'assessment';
+  items?: EvidenceTrailItem[];
+  text?: string;
+}
+
+export interface EvidenceTrailProps {
+  steps: EvidenceTrailStep[];
+  accentColor?: string;
+  borderColor?: string;
+}
+
+// ── Core component ───────────────────────────────────────
+
+export function EvidenceTrail({ steps, accentColor, borderColor }: EvidenceTrailProps) {
+  if (steps.length === 0) return null;
+
+  const accent = accentColor || 'var(--dt-text-muted)';
+  const border = borderColor || 'var(--dt-border-light)';
+
+  return (
+    <div className="gen-trail-chain">
+      {steps.map((step, idx) => {
+        const prevStep = idx > 0 ? steps[idx - 1] : null;
+        const showConnector = Boolean(prevStep);
+        const isLast = step.variant === 'assessment';
+
+        return (
+          <React.Fragment key={idx}>
+            {/* Connector between steps */}
+            {showConnector && (
+              <div
+                className={`gen-trail-connector${isLast ? ' gen-trail-connector--final' : ''}`}
+                style={{
+                  background: isLast
+                    ? border
+                    : `linear-gradient(to bottom, ${border}, ${accent})`,
+                }}
+              />
+            )}
+
+            {/* Step */}
+            <div className={`gen-trail-step gen-trail-step--${step.variant}`}>
+              <div className="gen-trail-marker">
+                <span
+                  className={`gen-trail-dot gen-trail-dot--${step.variant}`}
+                  style={step.variant === 'current' ? { background: accent } : undefined}
+                />
+                <span className="gen-trail-label">{step.label}</span>
+              </div>
+              <div className="gen-trail-content">
+                {/* Multi-item steps (prior work, current evidence) */}
+                {step.items && step.items.map((item, i) => {
+                  if (step.variant === 'prior') {
+                    return (
+                      <div key={i} className="gen-trail-ref">
+                        {item.title && <span className="gen-ref-title">{item.title}</span>}
+                        {item.quote && (
+                          <blockquote className="gen-trail-quote">
+                            <span className="gen-quote-mark">&ldquo;</span>
+                            {item.quote}
+                            <span className="gen-quote-mark">&rdquo;</span>
+                          </blockquote>
+                        )}
+                      </div>
+                    );
+                  }
+                  // current and other variants with items
+                  return (
+                    <blockquote
+                      key={i}
+                      className="gen-trail-quote gen-trail-quote--current"
+                      style={{ borderLeftColor: border }}
+                    >
+                      <span className="gen-quote-mark">&ldquo;</span>
+                      {item.quote || item.title || ''}
+                      <span className="gen-quote-mark">&rdquo;</span>
+                      {item.cite && <cite className="gen-trail-cite">{item.cite}</cite>}
+                    </blockquote>
+                  );
+                })}
+
+                {/* Single-text step (assessment) */}
+                {step.text && (
+                  <p className="ar-card-assessment">{step.text}</p>
+                )}
+              </div>
+            </div>
+          </React.Fragment>
+        );
+      })}
+    </div>
+  );
+}
+
+// ── Sub-renderer wrapper (config-driven) ─────────────────
+
+/**
+ * Config shape for sub-renderer usage:
+ *   steps: Array<{
+ *     label: string;           — display label ("Prior work")
+ *     field: string;           — data field to read from
+ *     variant: string;         — "prior" | "current" | "assessment"
+ *     item_title_field?: string;   — field within each item for title
+ *     item_quote_field?: string;   — field within each item for quote
+ *     item_cite_field?: string;    — field within each item for citation
+ *     is_text?: boolean;       — treat field as single text (not array)
+ *   }>
+ *   accent_color?: string;
+ *   border_color?: string;
+ */
+export function EvidenceTrailSubRenderer({
+  data,
+  config,
+}: {
+  data: unknown;
+  config: Record<string, unknown>;
+}) {
+  const obj = (data && typeof data === 'object' && !Array.isArray(data))
+    ? data as Record<string, unknown>
+    : {};
+
+  const stepConfigs = config.steps as Array<{
+    label: string;
+    field: string;
+    variant: string;
+    item_title_field?: string;
+    item_quote_field?: string;
+    item_cite_field?: string;
+    is_text?: boolean;
+  }> | undefined;
+
+  if (!stepConfigs || !Array.isArray(stepConfigs)) return null;
+
+  const steps: EvidenceTrailStep[] = [];
+
+  for (const sc of stepConfigs) {
+    const raw = obj[sc.field];
+    if (raw === undefined || raw === null || raw === '') continue;
+
+    const variant = (sc.variant || 'prior') as EvidenceTrailStep['variant'];
+
+    if (sc.is_text || typeof raw === 'string') {
+      steps.push({ label: sc.label, variant, text: String(raw) });
+    } else if (Array.isArray(raw)) {
+      const items: EvidenceTrailItem[] = raw.map((entry: unknown) => {
+        if (typeof entry === 'string') return { quote: entry };
+        if (typeof entry === 'object' && entry !== null) {
+          const e = entry as Record<string, unknown>;
+          return {
+            title: sc.item_title_field ? String(e[sc.item_title_field] || '') : undefined,
+            quote: sc.item_quote_field ? String(e[sc.item_quote_field] || '') : undefined,
+            cite: sc.item_cite_field ? String(e[sc.item_cite_field] || '') : undefined,
+          };
+        }
+        return { quote: String(entry) };
+      });
+      if (items.length > 0) {
+        steps.push({ label: sc.label, variant, items });
+      }
+    }
+  }
+
+  if (steps.length === 0) return null;
+
+  return (
+    <EvidenceTrail
+      steps={steps}
+      accentColor={config.accent_color as string | undefined}
+      borderColor={config.border_color as string | undefined}
+    />
+  );
+}

package/src/dispatch/SubRendererDispatch.tsx

@@ -0,0 +1,282 @@
+/**
+ * SubRendererDispatch — Shared dispatch utilities for sub-renderer resolution.
+ *
+ * Extracted from AccordionRenderer to be shared by both AccordionRenderer
+ * and CardRenderer. Provides:
+ *   - Pre-render compatibility checking (data type vs renderer expectations)
+ *   - Defense-in-depth fallback wrapper (catches empty output at layout time)
+ *   - Generic recursive renderer for arbitrary data shapes
+ *   - Enum color resolution via design tokens
+ */
+
+import React, { useState, useLayoutEffect, useRef } from 'react';
+import { resolveSubRenderer, autoDetectSubRenderer } from '../sub-renderers/SubRenderers';
+import type { SubRendererProps } from '../types';
+import { useDesignTokens } from '../tokens/DesignTokenContext';
+import type { SemanticTriple } from '../types/designTokens';
+
+// ── Pre-render compatibility check ──────────────────────
+// Sub-renderers silently return null when data doesn't match their
+// expectations (e.g. chip_grid given a string). This check prevents
+// blank sections by falling through to auto-detection on mismatch.
+
+export const REQUIRES_ARRAY = new Set([
+  'chip_grid', 'mini_card_list', 'timeline_strip',
+  'comparison_panel', 'definition_list',
+  'intensity_matrix', 'move_repertoire', 'grouped_card_list', 'rich_description_list',
+]);
+export const REQUIRES_OBJECT = new Set(['stat_row', 'phase_timeline', 'distribution_summary']);
+
+export function isRendererCompatible(
+  rendererType: string,
+  data: unknown,
+  rendererConfig?: Record<string, unknown>,
+): boolean {
+  if (REQUIRES_ARRAY.has(rendererType) && !Array.isArray(data)) return false;
+  if (REQUIRES_OBJECT.has(rendererType) && (typeof data !== 'object' || Array.isArray(data) || data === null)) return false;
+  // evidence_trail requires config.steps array — without it, always returns null
+  if (rendererType === 'evidence_trail' && (!rendererConfig?.steps || !Array.isArray(rendererConfig.steps))) return false;
+  return true;
+}
+
+// ── Defense-in-depth fallback wrapper ────────────────────
+// Even after the pre-render compatibility check, a sub-renderer might
+// return null for reasons we can't predict (e.g. data is an array but
+// items are wrong shape). This wrapper detects empty output via
+// useLayoutEffect (before browser paint) and swaps in auto-detection.
+
+export function SubRendererFallback({ Renderer, data, config, sectionKey }: {
+  Renderer: React.FC<SubRendererProps>;
+  data: unknown;
+  config: Record<string, unknown>;
+  sectionKey: string;
+}) {
+  const ref = useRef<HTMLDivElement>(null);
+  const [fallback, setFallback] = useState(false);
+
+  useLayoutEffect(() => {
+    if (ref.current && ref.current.innerHTML.trim() === '') {
+      console.warn(
+        `[SubRendererDispatch] Renderer produced empty output for section '${sectionKey}' — falling back to auto-detection`
+      );
+      setFallback(true);
+    }
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
+
+  if (fallback) {
+    const autoType = autoDetectSubRenderer(data);
+    const AutoComp = autoType ? resolveSubRenderer(autoType) : null;
+    if (AutoComp) {
+      return <AutoComp data={data} config={config} />;
+    }
+    return <GenericSectionRenderer data={data} />;
+  }
+
+  return <div ref={ref}><Renderer data={data} config={config} /></div>;
+}
+
+// ── Enum color resolution ───────────────────────────────
+// Resolve enum-like string values to semantic token colors.
+// Tries each semantic scale in order; returns first match or null.
+const SEMANTIC_SCALES = ['severity', 'visibility', 'change', 'modality'];
+
+export function resolveEnumColor(
+  getSemanticColor: (scale: string, level: string) => SemanticTriple | null,
+  value: string,
+): { bg: string; text: string } | null {
+  for (const scale of SEMANTIC_SCALES) {
+    const result = getSemanticColor(scale, value);
+    if (result) return result;
+  }
+  return null;
+}
+
+// ── Generic Section Renderer ────────────────────────────
+// Recursively renders arbitrary structured data shapes:
+// - string → paragraphs (with enum badge detection)
+// - string[] → chip grid
+// - object[] → mini-cards with key-value rendering
+// - object → recursive render with indentation (with sub-renderer dispatch)
+// - primitive → inline display
+
+export function GenericSectionRenderer({ data, depth = 0, subRenderers }: {
+  data: unknown;
+  depth?: number;
+  subRenderers?: Record<string, { renderer_type: string; config?: Record<string, unknown> }>;
+}) {
+  const { getSemanticColor } = useDesignTokens();
+
+  if (data === null || data === undefined) return null;
+
+  // String → paragraphs
+  if (typeof data === 'string') {
+    // Check if it looks like an enum value via semantic token lookup
+    if (data.length < 30) {
+      const enumStyle = resolveEnumColor(getSemanticColor, data);
+      if (enumStyle) {
+        return (
+          <span className="gen-enum-badge" style={{ backgroundColor: enumStyle.bg, color: enumStyle.text }}>
+            {data.replace(/_/g, ' ')}
+          </span>
+        );
+      }
+    }
+    return (
+      <div className="gen-field-text" style={{ marginBottom: 'var(--space-xs, 0.25rem)' }}>
+        {data.split('\n').map((p, i) => (
+          <p key={i}>{p}</p>
+        ))}
+      </div>
+    );
+  }
+
+  // Number/boolean → inline
+  if (typeof data === 'number') {
+    return <span className="gen-number-value">{String(data)}</span>;
+  }
+  if (typeof data === 'boolean') {
+    const boolColor = getSemanticColor('severity', data ? 'low' : 'high');
+    return (
+      <span className="gen-enum-badge" style={{
+        backgroundColor: boolColor?.bg || 'rgba(34, 197, 94, 0.12)',
+        color: boolColor?.text || '#16a34a',
+      }}>
+        {String(data)}
+      </span>
+    );
+  }
+
+  // Array of strings → chip grid
+  if (Array.isArray(data) && data.length > 0 && data.every(d => typeof d === 'string')) {
+    return (
+      <div className="gen-chip-grid">
+        {data.map((item, i) => (
+          <span key={i} className="gen-chip-inline">
+            {item}
+          </span>
+        ))}
+      </div>
+    );
+  }
+
+  // Array of objects → mini-cards
+  if (Array.isArray(data) && data.length > 0) {
+    return (
+      <div style={{ display: 'flex', flexDirection: 'column', gap: 'var(--space-sm, 0.5rem)', margin: 'var(--space-xs, 0.25rem) 0' }}>
+        {data.map((item, i) => (
+          <GenericMiniCard key={i} data={item} depth={depth} />
+        ))}
+      </div>
+    );
+  }
+
+  // Empty array
+  if (Array.isArray(data) && data.length === 0) {
+    return <p className="gen-empty-list">None</p>;
+  }
+
+  // Object → key-value pairs (with optional sub-renderer dispatch)
+  if (typeof data === 'object') {
+    const obj = data as Record<string, unknown>;
+    const entries = Object.entries(obj).filter(([, v]) => v !== null && v !== undefined && v !== '');
+    if (entries.length === 0) return null;
+
+    return (
+      <div className={depth > 0 ? 'gen-nested-content' : undefined}>
+        {entries.map(([key, value]) => {
+          // Check if a sub-renderer is configured for this key
+          const subHint = subRenderers?.[key];
+          if (subHint) {
+            const SubComp = resolveSubRenderer(subHint.renderer_type);
+            if (SubComp) {
+              return (
+                <div key={key} className="gen-field-row">
+                  <div className="gen-field-label">
+                    {key.replace(/_/g, ' ')}:
+                  </div>
+                  <SubComp data={value} config={subHint.config || {}} />
+                </div>
+              );
+            }
+          }
+
+          return (
+            <div key={key} className="gen-field-row">
+              <span className="gen-field-label">
+                {key.replace(/_/g, ' ')}:
+              </span>
+              {typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' ? (
+                <span className="gen-field-value-inline">
+                  <GenericSectionRenderer data={value} depth={depth + 1} />
+                </span>
+              ) : (
+                <div className="gen-field-value-block">
+                  <GenericSectionRenderer data={value} depth={depth + 1} />
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+    );
+  }
+
+  // Fallback
+  return <span style={{ fontSize: 'var(--type-body, 0.9375rem)' }}>{String(data)}</span>;
+}
+
+export function GenericMiniCard({ data, depth }: { data: unknown; depth: number }) {
+  const { getSemanticColor } = useDesignTokens();
+
+  if (typeof data !== 'object' || data === null) {
+    return <GenericSectionRenderer data={data} depth={depth + 1} />;
+  }
+
+  const obj = data as Record<string, unknown>;
+  const entries = Object.entries(obj).filter(([, v]) => v !== null && v !== undefined && v !== '');
+  if (entries.length === 0) return null;
+
+  // Heuristic: find a "name" or "title" field for the card header
+  const nameKey = entries.find(([k]) => ['name', 'term', 'title', 'commitment', 'cluster_name', 'channel', 'evidence_type'].includes(k));
+  const typeKey = entries.find(([k]) => ['type', 'centrality', 'drift_type', 'explicitness'].includes(k));
+
+  return (
+    <div className="gen-mini-card">
+      {/* Header: name + type badge */}
+      {nameKey && (
+        <div className="gen-mini-card-header">
+          <span className="gen-mini-card-name">
+            {String(nameKey[1])}
+          </span>
+          {typeKey && (
+            <GenericSectionRenderer data={typeKey[1]} depth={depth + 1} />
+          )}
+        </div>
+      )}
+
+      {/* Remaining fields */}
+      {entries
+        .filter(([k]) => k !== nameKey?.[0] && k !== typeKey?.[0])
+        .map(([key, value]) => (
+          <div key={key} className="gen-mini-card-field">
+            <span className="gen-mini-card-label">
+              {key.replace(/_/g, ' ')}:
+            </span>
+            {typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' ? (
+              <span className="gen-mini-card-value" style={{ marginLeft: 'var(--space-xs, 0.25rem)' }}>
+                {typeof value === 'string' && value.length < 30 && resolveEnumColor(getSemanticColor, value) ? (
+                  <GenericSectionRenderer data={value} depth={depth + 1} />
+                ) : (
+                  String(value)
+                )}
+              </span>
+            ) : (
+              <div style={{ marginTop: 'var(--space-2xs, 0.125rem)' }}>
+                <GenericSectionRenderer data={value} depth={depth + 1} />
+              </div>
+            )}
+          </div>
+        ))}
+    </div>
+  );
+}

package/src/hooks/useProseExtraction.ts

@@ -0,0 +1,125 @@
+/**
+ * useProseExtraction — Detects prose-mode output and extracts structured data.
+ *
+ * Several workflow passes can produce output in "prose mode" (rich analytical
+ * narrative) instead of structured JSON. When this happens the data contains
+ * a `_prose_output` marker. This hook:
+ *
+ * 1. Detects the marker
+ * 2. Calls the presentation extraction endpoint to get structured data
+ * 3. Manages loading / error / extracted state
+ *
+ * Usage:
+ *   const { data, loading, error, isProseMode } = useProseExtraction<Pass5Result>(
+ *     result.pass5_tactics,
+ *     result._job_id,
+ *     'tactics'
+ *   );
+ */
+
+import { useState, useEffect } from 'react';
+
+// Consumer apps set this via env var. Supports CRA and Next.js conventions.
+const API_BASE =
+  (typeof process !== 'undefined' && process.env?.REACT_APP_API_URL) ||
+  (typeof process !== 'undefined' && process.env?.NEXT_PUBLIC_API_URL) ||
+  'http://localhost:5555/api';
+
+interface ProseMarker {
+  _prose_output: string;
+  _output_mode: 'prose';
+}
+
+export interface ProseExtractionResult<T> {
+  /** The structured data — either raw (if not prose) or extracted */
+  data: T | null;
+  /** Whether extraction is in progress */
+  loading: boolean;
+  /** Extraction error message, if any */
+  error: string | null;
+  /** Whether the source data was prose mode */
+  isProseMode: boolean;
+}
+
+function isProseMarker(value: unknown): value is ProseMarker {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    '_prose_output' in (value as Record<string, unknown>)
+  );
+}
+
+export function useProseExtraction<T>(
+  rawData: T | ProseMarker | undefined,
+  jobId: string | undefined,
+  presentEndpoint: string, // e.g. 'tactics', 'conditions', 'synthesis', 'functional'
+  options?: { apiPathPrefix?: string }
+): ProseExtractionResult<T> {
+  const [extracted, setExtracted] = useState<T | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const proseMode = isProseMarker(rawData);
+
+  useEffect(() => {
+    // Not prose mode — nothing to extract
+    if (!proseMode || !jobId) return;
+    // Already extracted
+    if (extracted) return;
+
+    let cancelled = false;
+
+    const fetchPresentation = async () => {
+      setLoading(true);
+      setError(null);
+      try {
+        const prefix = options?.apiPathPrefix || 'analysis/default';
+        const response = await fetch(
+          `${API_BASE}/${prefix}/${jobId}/present/${presentEndpoint}`,
+          { method: 'POST' }
+        );
+        if (cancelled) return;
+
+        if (response.ok) {
+          const data = await response.json();
+          setExtracted(data.data as T);
+        } else {
+          const errData = await response.json().catch(() => ({ detail: 'Unknown error' }));
+          setError(errData.detail || `Extraction failed (${response.status})`);
+        }
+      } catch (e) {
+        if (!cancelled) {
+          setError(`Network error: ${e}`);
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    };
+
+    fetchPresentation();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [proseMode, jobId, presentEndpoint, extracted]);
+
+  // Not prose mode — return raw data directly
+  if (!proseMode) {
+    return {
+      data: (rawData as T) ?? null,
+      loading: false,
+      error: null,
+      isProseMode: false,
+    };
+  }
+
+  // Prose mode — return extracted data (or loading/error state)
+  return {
+    data: extracted,
+    loading,
+    error,
+    isProseMode: true,
+  };
+}

package/src/index.ts

@@ -0,0 +1,82 @@
+/**
+ * @the-syllabus/analysis-renderers — Shared renderer components for analyzer-v2 view definitions.
+ *
+ * This package provides the complete rendering pipeline:
+ * - Container renderers (accordion, card_grid, prose, table, etc.)
+ * - Sub-renderers (chip_grid, mini_card_list, distribution_summary, etc.)
+ * - Cell renderers (template_card, default auto-classify, etc.)
+ * - Design token system (DesignTokenProvider + useDesignTokens hook)
+ * - Renderer registry (view_key → component resolution)
+ *
+ * CSS: import '@the-syllabus/analysis-renderers/styles' for all renderer styles.
+ */
+
+// ── Types ────────────────────────────────────────────────
+export type {
+  RendererProps,
+  RendererComponent,
+  CellRendererProps,
+  CellRendererComponent,
+  SubRendererProps,
+  SubRendererComponent,
+  StyleOverrides,
+  DesignTokenSet,
+  SemanticTriple,
+  CategoricalItem,
+  PrimitiveTokens,
+  SurfaceTokens,
+  ScaleTokens,
+  SemanticTokens,
+  CategoricalTokens,
+  ComponentTokens,
+} from './types';
+export { getSO } from './types';
+
+// ── Design Tokens ────────────────────────────────────────
+export {
+  DesignTokenProvider,
+  useDesignTokens,
+  FALLBACK_TOKENS,
+} from './tokens/DesignTokenContext';
+
+// ── Utilities ────────────────────────────────────────────
+export { flattenTokens } from './utils/tokenFlattener';
+
+// ── Container Renderers ──────────────────────────────────
+export { AccordionRenderer } from './renderers/AccordionRenderer';
+export { CardGridRenderer } from './renderers/CardGridRenderer';
+export { CardRenderer } from './renderers/CardRenderer';
+export { ProseRenderer, formatProse } from './renderers/ProseRenderer';
+export { TableRenderer } from './renderers/TableRenderer';
+export { StatSummaryRenderer } from './renderers/StatSummaryRenderer';
+export { RawJsonRenderer } from './renderers/RawJsonRenderer';
+
+// ── Sub-Renderers ────────────────────────────────────────
+export {
+  resolveSubRenderer,
+  autoDetectSubRenderer,
+  DistributionSummary,
+} from './sub-renderers/SubRenderers';
+
+// ── Sub-Renderer Dispatch ────────────────────────────────
+export {
+  isRendererCompatible,
+  SubRendererFallback,
+  GenericSectionRenderer,
+  GenericMiniCard,
+  resolveEnumColor,
+  REQUIRES_ARRAY,
+  REQUIRES_OBJECT,
+} from './dispatch/SubRendererDispatch';
+
+// ── Cell Renderers ───────────────────────────────────────
+export { cellRenderers, DefaultCardCell } from './cells';
+export { TemplateCardCell } from './cells/TemplateCardCell';
+
+// ── Shared Components ────────────────────────────────────
+export { EvidenceTrail, EvidenceTrailSubRenderer } from './components/EvidenceTrail';
+export type { EvidenceTrailStep, EvidenceTrailItem } from './components/EvidenceTrail';
+export { EnableConditionsSubRenderer, ConstrainConditionsSubRenderer } from './components/ConditionCards';
+
+// ── Hooks ────────────────────────────────────────────────
+export { useProseExtraction } from './hooks/useProseExtraction';