@devcabs/folio-engine 0.0.0-stage → 0.1.1

package/dist/hooks/use-auto-toc.d.ts

@@ -0,0 +1,31 @@
+import type { NavItem } from '../types/navigation';
+export interface UseAutoTableOfContentsOptions {
+    /** Target container DOM ID to observe (default: 'node-content') */
+    containerId?: string;
+    /** React ref to container element (overrides containerId if provided) */
+    containerRef?: React.RefObject<HTMLElement | null>;
+    /** Selector for section elements (default: 'section[id], [data-toc-title][id], [data-toc="true"][id]') */
+    sectionSelector?: string;
+    /** Optional custom ID to title formatter */
+    formatIdToTitle?: (id: string) => string;
+}
+/**
+ * Converts a kebab-case or snake_case element ID into a readable title fallback.
+ * e.g. "node-overview" -> "Overview", "source-proof" -> "Evidence & Proof"
+ */
+export declare function defaultFormatIdToTitle(id: string): string;
+/**
+ * Pure function to extract canonical NavItems from a given container element.
+ */
+export declare function extractNavItemsFromContainer(container: HTMLElement, sectionSelector?: string, formatTitle?: typeof defaultFormatIdToTitle): NavItem[];
+/**
+ * useAutoTableOfContents Hook
+ *
+ * Canonical DOM-driven table of contents discovery for long-form editorial views:
+ * - Scans a content container for semantic sections with IDs
+ * - Automatically extracts labels and numbers using a robust cascade
+ * - Dynamic reactivity: attaches a MutationObserver to instantly capture added/removed sections
+ * - Debounced via requestAnimationFrame to guarantee smooth 60fps performance without layout thrashing
+ */
+export declare function useAutoTableOfContents(options?: UseAutoTableOfContentsOptions): NavItem[];
+export default useAutoTableOfContents;

package/dist/hooks/use-discrete-step-navigation.d.ts

@@ -0,0 +1,26 @@
+import type { RoadmapScrollZone } from '../components/roadmap/RoadmapSection';
+export interface UseDiscreteStepNavigationOptions {
+    enabled: boolean;
+    activeStage: number;
+    scrollZone: RoadmapScrollZone;
+    onNextStage: () => void;
+    onPrevStage: () => void;
+    onScrollToTop: () => void;
+    onScrollToFooter: () => void;
+    onDirectStage: (stage: number) => void;
+    /** Cooldown buffer in ms after transition completes before accepting new gestures. Defaults to 200ms. */
+    cooldownMs?: number;
+}
+export interface DiscreteStepNavigationHandle {
+    isTransitioning: boolean;
+    lockTransition: (estimatedDurationMs?: number) => void;
+    unlockTransition: () => void;
+}
+/**
+ * useDiscreteStepNavigation (Task 4.2.1b / Approach B)
+ *
+ * Disables continuous manual document scrolling on the landing page across
+ * desktop mouse wheels, trackpads, and mobile touch devices. Converts gestures
+ * into discrete, debounced milestone-to-milestone transitions with transition locking.
+ */
+export declare function useDiscreteStepNavigation({ enabled, activeStage, scrollZone, onNextStage, onPrevStage, onScrollToTop, onScrollToFooter, onDirectStage, cooldownMs, }: UseDiscreteStepNavigationOptions): DiscreteStepNavigationHandle;

package/dist/hooks/use-dynamic-section-numbers.d.ts

@@ -0,0 +1,30 @@
+import type { SectionElement } from '../types/canvas';
+export interface DynamicSectionItem {
+    id: string;
+    isNumbered: boolean;
+}
+/**
+ * Pure function to compute sequential section numbers skipping unnumbered sections.
+ * e.g.:
+ *   [numbered, numbered] -> { sec1: "01", sec2: "02" }
+ *   [unnumbered, numbered] -> { sec1: null, sec2: "01" } (preceding section skipped in iteration)
+ *   [numbered, unnumbered, numbered] -> { sec1: "01", sec2: null, sec3: "02" }
+ */
+export declare function computeDynamicSectionNumbers(sections: DynamicSectionItem[]): Record<string, string | null>;
+export interface UseNodeSectionNumbersReturn {
+    isSourceNumbered: boolean;
+    isChartNumbered: boolean;
+    sourceNumber: string | null;
+    chartNumber: string | null;
+}
+/**
+ * Reactive hook providing dynamic section numbers for PillarPage.
+ * If Evidence Gallery is unnumbered, Indicator Chart dynamically increments from 01.
+ */
+export declare function useNodeSectionNumbers(nodeId: string): UseNodeSectionNumbersReturn;
+/**
+ * Reactive hook providing sequential section numbers for dynamic canvas sections.
+ * Reactively recalculates whenever a section's numbering toggle is updated in Content DB.
+ */
+export declare function useDynamicCanvasSectionNumbers(nodeId: string, sections: SectionElement[]): Record<string, string | null>;
+export default useNodeSectionNumbers;

package/dist/hooks/use-hash-route.d.ts

@@ -0,0 +1,36 @@
+import type { NodeCode } from "../types/node";
+export type RouteType = "home" | "node" | "page" | "not-found";
+export interface RouteState {
+    type: "home" | "node" | "not-found";
+    nodeId: NodeCode | null;
+    /** Backwards compatibility alias */
+    pageId: NodeCode | null;
+    targetStage: number | null;
+    rawHash: string;
+    pathname?: string;
+}
+export declare const VALID_NODES: NodeCode[];
+export declare const NODE_TO_STAGE: Record<NodeCode, number>;
+export declare const STAGE_TO_NODE: Record<number, NodeCode>;
+/**
+ * Universal route parser supporting both modern HTML5 path routes (/node/:id/)
+ * and legacy hash routes (#node/:id).
+ * Parameterized to support arbitrary custom node identifiers, stages, and subpaths.
+ */
+export declare function parseRoute(pathname?: string, hash?: string, validNodes?: NodeCode[], basePath?: string): RouteState;
+/**
+ * Backwards compatibility helper for legacy hash parser
+ */
+export declare function parseHash(hash: string, validNodes?: NodeCode[]): RouteState;
+export declare function useHashRoute(validNodes?: NodeCode[], basePath?: string): {
+    route: "node" | "home" | "not-found";
+    nodeId: string | null;
+    pageId: string | null;
+    targetStage: number | null;
+    rawHash: string;
+    pathname: string | undefined;
+    navigateToNode: (nodeId: NodeCode) => void;
+    navigateToPage: (nodeId: NodeCode) => void;
+    navigateToHome: (stage?: number) => void;
+};
+export declare const useAppRoute: typeof useHashRoute;

package/dist/hooks/use-scroll.d.ts

@@ -0,0 +1,22 @@
+export interface UseScrollOptions {
+    target?: React.RefObject<HTMLElement | null>;
+}
+export interface ScrollValues {
+    scrollY: number;
+    scrollProgress: number;
+}
+/**
+ * useScroll Hook
+ *
+ * Tracks scroll position and normalized scroll progress (0 to 1)
+ * relative to the window or a designated container element.
+ *
+ * Provides:
+ * - Reactive state: `scrollProgress` and `scrollY`
+ * - High-performance subscription: `subscribeScroll` (for zero-rerender direct DOM manipulation)
+ */
+export declare const useScroll: (options?: UseScrollOptions) => {
+    subscribeScroll: (callback: (values: ScrollValues) => void) => () => void;
+    scrollY: number;
+    scrollProgress: number;
+};

package/dist/hooks/use-scrollspy.d.ts

@@ -0,0 +1,19 @@
+export interface UseScrollspyOptions {
+    /** Reading reference line distance in px from top of viewport. Defaults to 140px (clearing AppHeader) */
+    offsetPx?: number;
+    /** Fallback active ID when no monitored element is found */
+    defaultActiveId?: string;
+}
+/**
+ * useScrollspy Hook
+ *
+ * High-performance, passive scroll tracking hook for editorial long-form layouts.
+ * Uses document-order threshold detection to determine the active reading section.
+ * Perfectly handles short sections sharing the viewport without skipping or getting stuck.
+ *
+ * @param itemIds Array of element DOM IDs (without '#') to monitor
+ * @param options Configuration for offsetPx and defaultActiveId
+ * @returns The active element ID currently in the reading viewport zone
+ */
+export declare function useScrollspy(itemIds: string[], options?: UseScrollspyOptions): string;
+export default useScrollspy;

package/dist/hooks/useChartTooltip.d.ts

@@ -0,0 +1,25 @@
+export interface ChartTooltipState<T = unknown> {
+    visible: boolean;
+    x: number;
+    y: number;
+    title?: string;
+    seriesName?: string;
+    value: number | string | null;
+    unit?: string;
+    color?: string;
+    extra?: T;
+}
+export interface UseChartTooltipOptions {
+    clampX?: [number, number];
+    clampY?: [number, number];
+}
+/**
+ * Canonical Tooltip Hook & Boundary Clamping
+ * Standardizes tooltip state management and coordinates across all charts.
+ */
+export declare function useChartTooltip<T = unknown>(options?: UseChartTooltipOptions): {
+    tooltipState: ChartTooltipState<T>;
+    setTooltipState: import("react").Dispatch<import("react").SetStateAction<ChartTooltipState<T>>>;
+    showTooltip: (params: Omit<ChartTooltipState<T>, "visible">) => void;
+    hideTooltip: () => void;
+};

package/dist/hooks/useContent.d.ts

@@ -0,0 +1,36 @@
+export interface UseContentReturn {
+    /** The current resolved text content (from DB or default) */
+    text: string;
+    /** Whether this content key currently has a custom override saved in DB */
+    isModified: boolean;
+    /** Update the text override in the DB */
+    setText: (value: string) => void;
+    /** Alias for setText matching useContentObject signature */
+    setValue: (value: string) => void;
+    /** Revert to the hardcoded system default */
+    resetText: () => void;
+    /** Alias for resetText matching useContentObject signature */
+    resetValue: () => void;
+}
+/**
+ * Reactive hook to dynamically consume and modify text content from the Content DB.
+ * Rebuilt on React 19's useSyncExternalStore for zero-overhead, flicker-free updates.
+ * Guarantees that wildcard and unrelated notifications trigger zero re-renders.
+ */
+export declare function useContent(key: string, defaultValue: string, explicitDevMode?: boolean): UseContentReturn;
+export interface UseContentObjectReturn<T> {
+    /** The current resolved object content (from DB or default) */
+    value: T;
+    /** Whether this content key currently has a custom override saved in DB */
+    isModified: boolean;
+    /** Update the object override in the DB */
+    setValue: (value: T) => void;
+    /** Revert to the hardcoded system default */
+    resetValue: () => void;
+}
+/**
+ * Reactive hook to dynamically consume and modify structured content (e.g. image payloads) from Content DB.
+ * Derives its state from useContent's useSyncExternalStore primitive string snapshots, eliminating ghost re-renders.
+ */
+export declare function useContentObject<T>(key: string, defaultValue: T, explicitDevMode?: boolean): UseContentObjectReturn<T>;
+export default useContent;

package/dist/hooks/useDeveloperMode.d.ts

@@ -0,0 +1 @@
+export { useDeveloperMode } from '../context/DeveloperModeContext';

package/dist/hooks/useDocumentCanvas.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Folio Engine - Reactive Dynamic Canvas Hook
+ * Location: src/hooks/useNodeCanvas.ts
+ * Specification: docs/tasks/task8_2_storage_and_sync_service.md
+ * Aligned with: docs/00_WORKFLOW.md, docs/03_ARCHITECTURE.md, docs/07_CODING_STANDARDS.md
+ *
+ * Implements:
+ * 1. Synchronous state initialization from local-first storage.
+ * 2. Cross-component synchronization via CustomEvent subscription.
+ * 3. Non-blocking UI updates using React 19 startTransition (rerender-transitions).
+ * 4. Atomic, immutable CRUD dispatchers for sections, subsections, and leaf elements.
+ */
+import type { CanvasElement, CanvasLeafElement, SectionElement, SubsectionElement, NodeCanvasDocument } from '../types/canvas';
+export interface UseNodeCanvasReturn {
+    /** Active in-memory canvas document tree */
+    document: NodeCanvasDocument;
+    /** True when a canvas layout transition is pending */
+    isPending: boolean;
+    /** Add a new section container with automatic numbering */
+    addSection: (targetIndex?: number) => void;
+    /** Add a new subsection container inside a section */
+    addSubsection: (sectionId: string, targetIndex?: number) => void;
+    /** Add a leaf element (text, photo, chart) to a section or subsection */
+    addElement: (sectionId: string, element: CanvasLeafElement, targetIndex?: number, subsectionId?: string) => void;
+    /** Restore or insert an existing section at target index (for undo) */
+    restoreSection: (section: SectionElement, targetIndex?: number) => void;
+    /** Restore or insert an existing subsection at target index (for undo) */
+    restoreSubsection: (sectionId: string, subsection: SubsectionElement, targetIndex?: number) => void;
+    /** Restore or insert an existing leaf element at target index (for undo) */
+    restoreElement: (sectionId: string, element: CanvasLeafElement, targetIndex?: number, subsectionId?: string) => void;
+    /** Move an item up or down within its container */
+    moveItem: (itemId: string, direction: 'up' | 'down', parentId?: string) => void;
+    /** Relocate an item anywhere across the canvas to a target container */
+    relocateItem: (sourceItemId: string, targetContainerId: string, targetIndex?: number) => void;
+    /** Remove an item and all its nested children */
+    removeItem: (itemId: string, parentId?: string) => void;
+    /** Update attributes of an element by ID */
+    updateItem: <T extends CanvasElement>(itemId: string, updates: Partial<T>) => void;
+    /** Reset node canvas back to default structure */
+    resetToDefault: () => void;
+    /** Deploy active canvas document to cloud storage (Supabase) */
+    deployToCloud: () => Promise<boolean>;
+    /** Error message if saving canvas to storage failed (e.g. storage quota exceeded) */
+    saveError: string | null;
+    /** Dismiss the active save error */
+    clearSaveError: () => void;
+}
+/**
+ * Hook providing reactive state and atomic dispatchers for managing a node's Dynamic Canvas.
+ */
+export declare const useNodeCanvas: typeof useDocumentCanvas;
+export declare function useDocumentCanvas(nodeId: string): UseNodeCanvasReturn;
+export default useDocumentCanvas;

package/dist/hooks/useDrivePhotoSync.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Reactive SWR Google Drive Photo Sync Hook
+ * Folio Engine
+ * Subtask 6.2: Zero-Quota Public Cache & Persistence Layer
+ *
+ * Implements a non-blocking React 19 SWR hook for Google Drive photo synchronization:
+ * - Deterministic 5-State Coexistence Lifecycle:
+ *     never_synced | syncing | synced_success | synced_empty | sync_error
+ * - React 19 useTransition wrapper to eliminate UI render blocking
+ * - Synchronous local storage reading for zero layout shift (CLS = 0)
+ * - Cross-tab / multi-window synchronization via storage events
+ */
+import type { UseDrivePhotoSyncResult } from '../types/source';
+export declare function useDrivePhotoSync(nodeId: string): UseDrivePhotoSyncResult;
+export default useDrivePhotoSync;

package/dist/hooks/useImageLoader.d.ts

@@ -0,0 +1,12 @@
+import type { UseImageLoaderResult } from '../types/source';
+/**
+ * useImageLoader Hook
+ *
+ * Fault-tolerant finite state machine governing image asset loading lifecycle.
+ * - Handles 4 deterministic states: idle, loading, loaded, error
+ * - Fast-path bypass for cached images to eliminate layout flicker
+ * - Subscription flag cleanup to prevent memory leaks and state updates after unmount
+ * - Stable retry callback for recovery from network interruptions
+ */
+export declare function useImageLoader(src?: string, fallbackSrc?: string): UseImageLoaderResult;
+export default useImageLoader;

package/dist/hooks/useLightboxHistory.d.ts

@@ -0,0 +1,14 @@
+export interface UseLightboxHistoryProps {
+    isOpen: boolean;
+    onClose: () => void;
+    hash?: string;
+}
+/**
+ * useLightboxHistory Hook
+ *
+ * Synchronizes modal visibility with browser history and popstate events.
+ * Guarantees that pressing the browser or hardware Back button on mobile
+ * dismisses the lightbox and returns to the exact source page and scroll position.
+ */
+export declare function useLightboxHistory({ isOpen, onClose, hash, }: UseLightboxHistoryProps): void;
+export default useLightboxHistory;

package/dist/hooks/useNodeCanvas.d.ts

@@ -0,0 +1,2 @@
+export * from "./useDocumentCanvas";
+export { default } from "./useDocumentCanvas";

package/dist/hooks/useSheetChartData.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Reactive Chart Data Hook (SWR + Instant Synchronous Baseline Paint)
+ * Folio Engine — Subtask 7.4.6
+ * Document Reference: docs/tasks/task7_4_drawer_range_matrix_supabase_deploy.md
+ *
+ * Implements:
+ * 1. Instant <10ms synchronous initial render from baked JSON & local storage cache.
+ * 2. SWR background re-validation from Supabase cloud storage.
+ * 3. Live in-drawer configuration override support for real-time previewing.
+ */
+import type { ChartDataset, SheetChartConfig, ChartSyncStatus } from '../types/chart';
+import type { NodeCode } from '../types/node';
+export declare const getMatrixCacheKey: (chartId: string) => string;
+export interface UseSheetChartDataOptions {
+    chartId: string;
+    nodeId?: NodeCode;
+    initialDataset?: ChartDataset;
+    pollIntervalMs?: number;
+    isDevMode?: boolean;
+}
+export interface UseSheetChartDataReturn {
+    dataset: ChartDataset | null;
+    config: SheetChartConfig | null;
+    status: ChartSyncStatus;
+    errorMessage?: string;
+    lastSyncedAt?: string;
+    reload: () => Promise<void>;
+    syncLiveSheet: () => Promise<(string | number | null)[][] | null>;
+    setOverrideConfig: (config: Partial<SheetChartConfig> | null) => void;
+}
+export declare function useSheetChartData({ chartId, nodeId, initialDataset, pollIntervalMs, isDevMode, }: UseSheetChartDataOptions): UseSheetChartDataReturn;

package/dist/hooks/useSourcePoint.d.ts

@@ -0,0 +1,35 @@
+import type { LiveSourceSource } from '../types/source';
+export interface UseSourcePointResult {
+    /** The current live source source record or null if unset */
+    source: LiveSourceSource | null;
+    /** Sanitized Google Drive folder URL */
+    folderUrl: string;
+    /** Official or custom folder title */
+    folderTitle: string;
+    /** Optional editorial description */
+    description?: string;
+    /** ISO date when source was last verified */
+    lastVerified?: string;
+    /** Whether the initial background fetch is running */
+    isLoading: boolean;
+    /** Whether a mutation update is in-flight */
+    isUpdating: boolean;
+    /** Error message string if fetch or mutation failed */
+    error: string | null;
+    /** Optimistic mutation handler to update folder metadata */
+    updateFolder: (newUrl: string, newTitle?: string, description?: string) => Promise<LiveSourceSource>;
+    /** Convenience flag indicating whether a non-empty valid folder URL exists */
+    hasFolder: boolean;
+}
+/**
+ * useSourcePoint Hook
+ * Folio Engine — Subtask 5.3: Contextual Point Anchor & Integration
+ *
+ * Reactive state machine for anchoring any component or photo point across Folio Engine
+ * directly to a verified Google Drive folder:
+ * 1. Immediate synchronous resolution via getSourceSourceSync to guarantee zero layout shift.
+ * 2. Background live resolution against BaaS / Supabase database.
+ * 3. Bidirectional reactive subscriptions to cross-tab/window storage & mutation events.
+ * 4. Optimistic mutation handler updateFolder with automatic rollbacks on network failure.
+ */
+export declare function useSourcePoint(pointId: string): UseSourcePointResult;

package/dist/hooks/useSwipeGesture.d.ts

@@ -0,0 +1,30 @@
+export interface SwipeGestureOptions {
+    onSwipeLeft?: () => void;
+    onSwipeRight?: () => void;
+    onSwipeDown?: () => void;
+    minDistance?: number;
+    disabled?: boolean;
+}
+export interface UseSwipeGestureResult {
+    onTouchStart: (e: React.TouchEvent) => void;
+    onTouchMove: (e: React.TouchEvent) => void;
+    onTouchEnd: (e: React.TouchEvent) => void;
+    onTouchCancel: (e: React.TouchEvent) => void;
+    onPointerDown: (e: React.PointerEvent) => void;
+    onPointerMove: (e: React.PointerEvent) => void;
+    onPointerUp: (e: React.PointerEvent) => void;
+    onPointerCancel: (e: React.PointerEvent) => void;
+    wasSwipeJustTriggered: () => boolean;
+}
+/**
+ * useSwipeGesture Hook
+ *
+ * Captures mobile touch and pointer interactions for native photo gallery conventions:
+ * - Horizontal swipe left/right for carousel navigation
+ * - Vertical pull-down gesture to dismiss the modal
+ * - Supports both Touch Events and Pointer Events with touchcancel/pointercancel resilience
+ * - Prevents collision with interactive elements (photo strip, buttons, links)
+ * - Exposes wasSwipeJustTriggered() to suppress synthetic click events after swiping
+ */
+export declare function useSwipeGesture({ onSwipeLeft, onSwipeRight, onSwipeDown, minDistance, disabled, }: SwipeGestureOptions): UseSwipeGestureResult;
+export default useSwipeGesture;

package/dist/hooks/useUndoRedo.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Folio Engine - Active Session Undo / Redo Hook
+ * Location: src/hooks/useUndoRedo.ts
+ * Specification: docs/tasks/task9_2_active_session_undo_redo_engine.md
+ * Aligned with: docs/00_WORKFLOW.md, docs/03_ARCHITECTURE.md, docs/07_CODING_STANDARDS.md
+ */
+import type { UndoRedoContextType } from '../types/history';
+export declare function useUndoRedo(): UndoRedoContextType;
+export default useUndoRedo;

package/dist/hooks/useUnsavedChangesPrompt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Folio Engine - Reusable Unsaved Changes Prompt Hook
+ * Location: src/hooks/useUnsavedChangesPrompt.ts
+ * Specification: docs/tasks/task12_0_prevent_refresh_unsaved_changes.md
+ * Aligned with: docs/00_WORKFLOW.md, docs/03_ARCHITECTURE.md, docs/07_CODING_STANDARDS.md
+ *
+ * Implements:
+ * 1. Automatic registration into the central unsavedChangesService.
+ * 2. Window beforeunload event interception for active dirty editors.
+ * 3. Graceful cleanup on unmount or when form resets to clean state.
+ */
+/**
+ * Hook to safeguard open modals, drawers, and form editors from accidental browser refresh or closure.
+ *
+ * @param isDirty Whether the editor currently has unsaved modifications.
+ * @param editorId Unique identifier for this editor (e.g. 'universal-edit-modal', 'chart-config-drawer').
+ */
+export declare function useUnsavedChangesPrompt(isDirty: boolean, editorId: string): void;

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+export { App } from './App';
+import './styles/tokens.css';
+import './styles/reset.css';
+export * from './types/node';
+export * from './types/canvas';
+export * from './types/chart';
+export * from './types/developer';
+export * from './types/draft';
+export * from './types/source';
+export * from './types/history';
+export * from './types/media';
+export * from './types/navigation';
+export * from './config/engine.config';
+export * from './diagnostics/verifyEngineSetup';
+export * from './components/feedback';
+export * from './components/ui';
+export * from './utils/scrollLock';
+export * from './utils/modalActions';
+export * from "./components/roadmap/serpentine-generator";
+export * from "./components/roadmap/use-roadmap-scroll";
+export * from "./components/roadmap/RoadmapNode";
+export * from "./components/roadmap/RoadmapTrack";
+export * from "./components/roadmap/RoadmapSection";
+export * from "./hooks/use-hash-route";
+export * from "./hooks/use-scroll";
+export * from "./hooks/use-scrollspy";
+export * from "./utils/smooth-scroll";
+export * from "./components/canvas";
+export * from "./hooks/useDocumentCanvas";
+export * from "./hooks/useNodeCanvas";
+export * from "./hooks/useLightboxHistory";
+export * from "./services/canvasLayoutService";
+export * from "./components/layout";
+export * from "./services/draftService";
+export * from "./services/historyService";
+export * from "./services/historyStorage";
+export * from "./services/devLockService";
+export * from "./services/mediaService";
+export * from "./services/sourceService";
+export * from "./services/undoRedoService";
+export * from "./services/unsavedChangesService";
+export * from "./utils/contentDb";
+export * from "./utils/storage";
+export * from "./utils/devSecurity";
+export * from "./utils/supabase-config";
+export * from "./components/dev";
+export * from "./components/history";
+export * from "./context/DeveloperModeContext";
+export * from "./context/UndoRedoContext";
+export * from "./hooks/useDeveloperMode";
+export * from "./hooks/useUndoRedo";
+export * from './components/chart';
+export * from './services/chartSourceService';

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};